src/kernel/routing/StarZone_test.cpp

   1 /* Copyright (c) 2017-2021. The SimGrid Team. All rights reserved.               */
   2
   3 /* This program is free software; you can redistribute it and/or modify it
   4  * under the terms of the license (GNU LGPL) which comes with this package. */
   5
   6 #include "catch.hpp"
   7
   8 #include "simgrid/kernel/routing/NetPoint.hpp"
   9 #include "simgrid/kernel/routing/StarZone.hpp"
  10 #include "simgrid/s4u/Engine.hpp"
  11 #include "simgrid/s4u/Host.hpp"
  12 #include "simgrid/s4u/NetZone.hpp"
  13 #include "src/surf/network_interface.hpp"
  14 #include "src/surf/surf_interface.hpp"    // create models
  15 #include "src/surf/xml/platf_private.hpp" // RouteCreationArgs and friends
  16
  17 TEST_CASE("kernel::routing::StarZone: Creating Zone", "[creation]")
  18 {
  19   int argc           = 1;
  20   const char* argv[] = {"test"};
  21
  22   simgrid::s4u::Engine e(&argc, const_cast<char**>(argv));
  23
  24   REQUIRE(simgrid::s4u::create_star_zone("test"));
  25 }
  26
  27 // One day we may be able to test contracts and asserts with catch2
  28 // https://github.com/catchorg/Catch2/issues/853
  29 TEST_CASE("kernel::routing::StarZone: Adding routes (hosts): assert", "[.][assert]")
  30 {
  31   int argc           = 1;
  32   const char* argv[] = {"test"};
  33   simgrid::s4u::Engine e(&argc, const_cast<char**>(argv));
  34   auto* zone      = new simgrid::kernel::routing::StarZone("test");
  35   auto* netpoint1 = new simgrid::kernel::routing::NetPoint("netpoint1", simgrid::kernel::routing::NetPoint::Type::Host);
  36   auto* netpoint2 = new simgrid::kernel::routing::NetPoint("netpoint2", simgrid::kernel::routing::NetPoint::Type::Host);
  37
  38   SECTION("src and dst: nullptr") { zone->add_route(nullptr, nullptr, nullptr, nullptr, {}, false); }
  39
  40   SECTION("src: nullptr and symmetrical: true") { zone->add_route(nullptr, netpoint2, nullptr, nullptr, {}, true); }
  41
  42   SECTION("src and dst: not nullptr") { zone->add_route(netpoint1, netpoint2, nullptr, nullptr, {}, false); }
  43 }
  44
  45 TEST_CASE("kernel::routing::StarZone: Adding routes (netzones): assert", "[.][assert]")
  46 {
  47   int argc           = 1;
  48   const char* argv[] = {"test"};
  49   simgrid::s4u::Engine e(&argc, const_cast<char**>(argv));
  50   auto* zone = new simgrid::kernel::routing::StarZone("test");
  51   auto* netpoint1 =
  52       new simgrid::kernel::routing::NetPoint("netpoint1", simgrid::kernel::routing::NetPoint::Type::NetZone);
  53   auto* netpoint2 =
  54       new simgrid::kernel::routing::NetPoint("netpoint2", simgrid::kernel::routing::NetPoint::Type::NetZone);
  55
  56   SECTION("src: is a netzone and gw_src: nullptr") { zone->add_route(netpoint1, nullptr, nullptr, nullptr, {}, false); }
  57
  58   SECTION("src: is a netzone and gw_src: is a netzone")
  59   {
  60     zone->add_route(netpoint1, nullptr, netpoint2, nullptr, {}, false);
  61   }
  62
  63   SECTION("dst: is a netzone and gw_dst: nullptr") { zone->add_route(nullptr, netpoint2, nullptr, nullptr, {}, false); }
  64
  65   SECTION("dst: is a netzone and gw_dst: is a netzone")
  66   {
  67     zone->add_route(nullptr, netpoint2, nullptr, netpoint1, {}, false);
  68   }
  69 }
  70
  71 TEST_CASE("kernel::routing::StarZone: Get routes: assert", "[.][assert]")
  72 {
  73   /* workaround to initialize things, they must be done in this particular order */
  74   int argc           = 1;
  75   const char* argv[] = {"test"};
  76   simgrid::s4u::Engine e(&argc, const_cast<char**>(argv));
  77   auto* zone = new simgrid::kernel::routing::StarZone("test");
  78   surf_network_model_init_LegrandVelho();
  79   surf_cpu_model_init_Cas01();
  80
  81   auto* host1 = zone->create_host("netpoint1", {100});
  82   auto* host2 = zone->create_host("netpoint2", {100});
  83   std::vector<simgrid::kernel::resource::LinkImpl*> links;
  84   links.push_back(zone->create_link("link1", {100})->get_impl());
  85   std::vector<simgrid::kernel::resource::LinkImpl*> links2;
  86   links2.push_back(zone->create_link("link2", {100})->get_impl());
  87
  88   SECTION("Get route: no UP link")
  89   {
  90     zone->add_route(host1->get_netpoint(), nullptr, nullptr, nullptr, links, true);
  91     zone->add_route(nullptr, host2->get_netpoint(), nullptr, nullptr, links2, false);
  92     double lat;
  93     simgrid::kernel::routing::RouteCreationArgs route;
  94     zone->get_local_route(host2->get_netpoint(), host1->get_netpoint(), &route, &lat);
  95   }
  96
  97   SECTION("Get route: no DOWN link")
  98   {
  99     zone->add_route(host1->get_netpoint(), nullptr, nullptr, nullptr, links, false);
 100     zone->add_route(host2->get_netpoint(), nullptr, nullptr, nullptr, links2, true);
 101     double lat;
 102     simgrid::kernel::routing::RouteCreationArgs route;
 103     zone->get_local_route(host2->get_netpoint(), host1->get_netpoint(), &route, &lat);
 104   }
 105 }
 106
 107 TEST_CASE("kernel::routing::StarZone: Adding routes (hosts): valid", "")
 108 {
 109   int argc           = 1;
 110   const char* argv[] = {"test"};
 111   simgrid::s4u::Engine e(&argc, const_cast<char**>(argv));
 112   auto* zone     = new simgrid::kernel::routing::StarZone("test");
 113   auto* netpoint = new simgrid::kernel::routing::NetPoint("netpoint1", simgrid::kernel::routing::NetPoint::Type::Host);
 114
 115   SECTION("Source set, destination nullptr, symmetrical true")
 116   {
 117     zone->add_route(netpoint, nullptr, nullptr, nullptr, {}, true);
 118   }
 119
 120   SECTION("Source nullptr, destination set, symmetrical false")
 121   {
 122     zone->add_route(nullptr, netpoint, nullptr, nullptr, {}, false);
 123   }
 124
 125   SECTION("Source set, destination nullptr, symmetrical false")
 126   {
 127     zone->add_route(netpoint, nullptr, nullptr, nullptr, {}, false);
 128   }
 129
 130   SECTION("Source == destination") { zone->add_route(netpoint, netpoint, nullptr, nullptr, {}, false); }
 131 }
 132
 133 TEST_CASE("kernel::routing::StarZone: Adding routes (netzones): valid", "")
 134 {
 135   int argc           = 1;
 136   const char* argv[] = {"test"};
 137   simgrid::s4u::Engine e(&argc, const_cast<char**>(argv));
 138   auto* zone     = new simgrid::kernel::routing::StarZone("test");
 139   auto* netpoint = new simgrid::kernel::routing::NetPoint("netpoint1", simgrid::kernel::routing::NetPoint::Type::Host);
 140   auto* gw       = new simgrid::kernel::routing::NetPoint("gw1", simgrid::kernel::routing::NetPoint::Type::Router);
 141
 142   SECTION("src: is a netzone, src_gw: is a router") { zone->add_route(netpoint, nullptr, gw, nullptr, {}, true); }
 143
 144   SECTION("dst: is a netzone, dst_gw: is a router") { zone->add_route(nullptr, netpoint, nullptr, gw, {}, false); }
 145 }
 146
 147 TEST_CASE("kernel::routing::StarZone: Get routes (hosts)", "")
 148 {
 149   /* workaround to initialize things, they must be done in this particular order */
 150   int argc           = 1;
 151   const char* argv[] = {"test"};
 152   simgrid::s4u::Engine e(&argc, const_cast<char**>(argv));
 153   auto* zone = new simgrid::kernel::routing::StarZone("test");
 154   surf_network_model_init_LegrandVelho();
 155   surf_cpu_model_init_Cas01();
 156
 157   auto* host1 = zone->create_host("netpoint1", {100});
 158   auto* host2 = zone->create_host("netpoint2", {100});
 159
 160   SECTION("Get route: no shared link")
 161   {
 162     std::vector<simgrid::kernel::resource::LinkImpl*> links;
 163     links.push_back(zone->create_link("link1", {100})->set_latency(10)->get_impl());
 164     std::vector<simgrid::kernel::resource::LinkImpl*> links2;
 165     links2.push_back(zone->create_link("link2", {200})->set_latency(20)->get_impl());
 166     zone->add_route(host1->get_netpoint(), nullptr, nullptr, nullptr, links, true);
 167     zone->add_route(host2->get_netpoint(), nullptr, nullptr, nullptr, links2, true);
 168     zone->seal();
 169
 170     double lat = 0.0;
 171     simgrid::kernel::routing::RouteCreationArgs route;
 172     zone->get_local_route(host1->get_netpoint(), host2->get_netpoint(), &route, &lat);
 173     REQUIRE(lat == 30);
 174     REQUIRE(route.gw_src == nullptr);
 175     REQUIRE(route.gw_dst == nullptr);
 176     REQUIRE(route.link_list.size() == 2);
 177     REQUIRE(route.link_list[0]->get_name() == "link1");
 178     REQUIRE(route.link_list[1]->get_name() == "link2");
 179   }
 180
 181   SECTION("Get route: shared link(backbone)")
 182   {
 183     auto* backbone = zone->create_link("backbone", {1000})->set_latency(100)->get_impl();
 184     std::vector<simgrid::kernel::resource::LinkImpl*> links;
 185     links.push_back(zone->create_link("link1", {100})->set_latency(10)->get_impl());
 186     links.push_back(backbone);
 187     std::vector<simgrid::kernel::resource::LinkImpl*> links2;
 188     links2.push_back(zone->create_link("link2", {200})->set_latency(20)->get_impl());
 189     links2.push_back(backbone);
 190
 191     zone->add_route(host1->get_netpoint(), nullptr, nullptr, nullptr, links, true);
 192     zone->add_route(host2->get_netpoint(), nullptr, nullptr, nullptr, links2, true);
 193     zone->seal();
 194
 195     double lat = 0.0;
 196     simgrid::kernel::routing::RouteCreationArgs route;
 197     zone->get_local_route(host1->get_netpoint(), host2->get_netpoint(), &route, &lat);
 198     REQUIRE(lat == 130);
 199     REQUIRE(route.link_list.size() == 3);
 200     REQUIRE(route.link_list[0]->get_name() == "link1");
 201     REQUIRE(route.link_list[1]->get_name() == "backbone");
 202     REQUIRE(route.link_list[2]->get_name() == "link2");
 203   }
 204
 205   SECTION("Get route: loopback")
 206   {
 207     auto* backbone = zone->create_link("backbone", {1000})->set_latency(100)->get_impl();
 208     std::vector<simgrid::kernel::resource::LinkImpl*> links;
 209     links.push_back(zone->create_link("link1", {100})->set_latency(10)->get_impl());
 210     links.push_back(backbone);
 211
 212     zone->add_route(host1->get_netpoint(), host1->get_netpoint(), nullptr, nullptr, links, true);
 213     zone->seal();
 214
 215     double lat = 0.0;
 216     simgrid::kernel::routing::RouteCreationArgs route;
 217     zone->get_local_route(host1->get_netpoint(), host1->get_netpoint(), &route, &lat);
 218     REQUIRE(lat == 110);
 219     REQUIRE(route.link_list.size() == 2);
 220     REQUIRE(route.link_list[0]->get_name() == "link1");
 221     REQUIRE(route.link_list[1]->get_name() == "backbone");
 222   }
 223 }
 224
 225 TEST_CASE("kernel::routing::StarZone: Get routes (netzones)", "")
 226 {
 227   /* workaround to initialize things, they must be done in this particular order */
 228   int argc           = 1;
 229   const char* argv[] = {"test"};
 230   simgrid::s4u::Engine e(&argc, const_cast<char**>(argv));
 231   auto* zone = new simgrid::kernel::routing::StarZone("test");
 232   surf_network_model_init_LegrandVelho();
 233   surf_cpu_model_init_Cas01();
 234
 235   auto* subzone1 =
 236       (new simgrid::kernel::routing::NetPoint("subzone1", simgrid::kernel::routing::NetPoint::Type::NetZone))
 237           ->set_englobing_zone(zone);
 238   auto* subzone2 =
 239       (new simgrid::kernel::routing::NetPoint("subzone2", simgrid::kernel::routing::NetPoint::Type::NetZone))
 240           ->set_englobing_zone(zone);
 241   auto* router1 = new simgrid::kernel::routing::NetPoint("router1", simgrid::kernel::routing::NetPoint::Type::Router);
 242   auto* router2 = new simgrid::kernel::routing::NetPoint("router2", simgrid::kernel::routing::NetPoint::Type::Router);
 243
 244   SECTION("Get route: netzone")
 245   {
 246     std::vector<simgrid::kernel::resource::LinkImpl*> links;
 247     links.push_back(zone->create_link("link1", {100})->set_latency(10)->get_impl());
 248     std::vector<simgrid::kernel::resource::LinkImpl*> links2;
 249     links2.push_back(zone->create_link("link2", {200})->set_latency(20)->get_impl());
 250     zone->add_route(subzone1, nullptr, router1, nullptr, links, true);
 251     zone->add_route(subzone2, nullptr, router2, nullptr, links2, true);
 252     zone->seal();
 253
 254     double lat = 0.0;
 255     simgrid::kernel::routing::RouteCreationArgs route;
 256     zone->get_local_route(subzone1, subzone2, &route, &lat);
 257     REQUIRE(lat == 30);
 258     REQUIRE(route.gw_src == router1);
 259     REQUIRE(route.gw_dst == router2);
 260     REQUIRE(route.link_list.size() == 2);
 261     REQUIRE(route.link_list[0]->get_name() == "link1");
 262     REQUIRE(route.link_list[1]->get_name() == "link2");
 263   }
 264 }