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 namespace {
  18 class EngineWrapper {
  19   int argc = 1;
  20   char* argv;
  21   simgrid::s4u::Engine e;
  22
  23 public:
  24   explicit EngineWrapper(std::string name) : argv(&name[0]), e(&argc, &argv) {}
  25 };
  26 } // namespace
  27
  28 TEST_CASE("kernel::routing::StarZone: Creating Zone", "[creation]")
  29 {
  30   EngineWrapper e("test");
  31
  32   REQUIRE(simgrid::s4u::create_star_zone("test"));
  33 }
  34
  35 // One day we may be able to test contracts and asserts with catch2
  36 // https://github.com/catchorg/Catch2/issues/853
  37 TEST_CASE("kernel::routing::StarZone: Adding routes (hosts): assert", "[.][assert]")
  38 {
  39   EngineWrapper e("test");
  40   auto* zone      = new simgrid::kernel::routing::StarZone("test");
  41   auto* netpoint1 = new simgrid::kernel::routing::NetPoint("netpoint1", simgrid::kernel::routing::NetPoint::Type::Host);
  42   auto* netpoint2 = new simgrid::kernel::routing::NetPoint("netpoint2", simgrid::kernel::routing::NetPoint::Type::Host);
  43
  44   SECTION("src and dst: nullptr") { zone->add_route(nullptr, nullptr, nullptr, nullptr, {}, false); }
  45
  46   SECTION("src: nullptr and symmetrical: true") { zone->add_route(nullptr, netpoint2, nullptr, nullptr, {}, true); }
  47
  48   SECTION("src and dst: not nullptr") { zone->add_route(netpoint1, netpoint2, nullptr, nullptr, {}, false); }
  49 }
  50
  51 TEST_CASE("kernel::routing::StarZone: Adding routes (netzones): assert", "[.][assert]")
  52 {
  53   EngineWrapper e("test");
  54   auto* zone = new simgrid::kernel::routing::StarZone("test");
  55   auto* netpoint1 =
  56       new simgrid::kernel::routing::NetPoint("netpoint1", simgrid::kernel::routing::NetPoint::Type::NetZone);
  57   auto* netpoint2 =
  58       new simgrid::kernel::routing::NetPoint("netpoint2", simgrid::kernel::routing::NetPoint::Type::NetZone);
  59
  60   SECTION("src: is a netzone and gw_src: nullptr") { zone->add_route(netpoint1, nullptr, nullptr, nullptr, {}, false); }
  61
  62   SECTION("src: is a netzone and gw_src: is a netzone")
  63   {
  64     zone->add_route(netpoint1, nullptr, netpoint2, nullptr, {}, false);
  65   }
  66
  67   SECTION("dst: is a netzone and gw_dst: nullptr") { zone->add_route(nullptr, netpoint2, nullptr, nullptr, {}, false); }
  68
  69   SECTION("dst: is a netzone and gw_dst: is a netzone")
  70   {
  71     zone->add_route(nullptr, netpoint2, nullptr, netpoint1, {}, false);
  72   }
  73 }
  74
  75 TEST_CASE("kernel::routing::StarZone: Get routes: assert", "[.][assert]")
  76 {
  77   /* workaround to initialize things, they must be done in this particular order */
  78   EngineWrapper e("test");
  79   auto* zone = new simgrid::kernel::routing::StarZone("test");
  80   surf_network_model_init_LegrandVelho();
  81   surf_cpu_model_init_Cas01();
  82
  83   const auto* host1 = zone->create_host("netpoint1", {100});
  84   const auto* host2 = zone->create_host("netpoint2", {100});
  85   std::vector<simgrid::kernel::resource::LinkImpl*> links;
  86   links.push_back(zone->create_link("link1", {100})->get_impl());
  87   std::vector<simgrid::kernel::resource::LinkImpl*> links2;
  88   links2.push_back(zone->create_link("link2", {100})->get_impl());
  89
  90   SECTION("Get route: no UP link")
  91   {
  92     zone->add_route(host1->get_netpoint(), nullptr, nullptr, nullptr, links, true);
  93     zone->add_route(nullptr, host2->get_netpoint(), nullptr, nullptr, links2, false);
  94     double lat;
  95     simgrid::kernel::routing::RouteCreationArgs route;
  96     zone->get_local_route(host2->get_netpoint(), host1->get_netpoint(), &route, &lat);
  97   }
  98
  99   SECTION("Get route: no DOWN link")
 100   {
 101     zone->add_route(host1->get_netpoint(), nullptr, nullptr, nullptr, links, false);
 102     zone->add_route(host2->get_netpoint(), nullptr, nullptr, nullptr, links2, true);
 103     double lat;
 104     simgrid::kernel::routing::RouteCreationArgs route;
 105     zone->get_local_route(host2->get_netpoint(), host1->get_netpoint(), &route, &lat);
 106   }
 107 }
 108
 109 TEST_CASE("kernel::routing::StarZone: Adding routes (hosts): valid", "")
 110 {
 111   EngineWrapper e("test");
 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   EngineWrapper e("test");
 136   auto* zone     = new simgrid::kernel::routing::StarZone("test");
 137   auto* netpoint = new simgrid::kernel::routing::NetPoint("netpoint1", simgrid::kernel::routing::NetPoint::Type::Host);
 138   auto* gw       = new simgrid::kernel::routing::NetPoint("gw1", simgrid::kernel::routing::NetPoint::Type::Router);
 139
 140   SECTION("src: is a netzone, src_gw: is a router") { zone->add_route(netpoint, nullptr, gw, nullptr, {}, true); }
 141
 142   SECTION("dst: is a netzone, dst_gw: is a router") { zone->add_route(nullptr, netpoint, nullptr, gw, {}, false); }
 143 }
 144
 145 TEST_CASE("kernel::routing::StarZone: Get routes (hosts)", "")
 146 {
 147   /* workaround to initialize things, they must be done in this particular order */
 148   EngineWrapper e("test");
 149   auto* zone = new simgrid::kernel::routing::StarZone("test");
 150   surf_network_model_init_LegrandVelho();
 151   surf_cpu_model_init_Cas01();
 152
 153   const auto* host1 = zone->create_host("netpoint1", {100});
 154   const auto* host2 = zone->create_host("netpoint2", {100});
 155
 156   SECTION("Get route: no shared link")
 157   {
 158     std::vector<simgrid::kernel::resource::LinkImpl*> links;
 159     links.push_back(zone->create_link("link1", {100})->set_latency(10)->get_impl());
 160     std::vector<simgrid::kernel::resource::LinkImpl*> links2;
 161     links2.push_back(zone->create_link("link2", {200})->set_latency(20)->get_impl());
 162     zone->add_route(host1->get_netpoint(), nullptr, nullptr, nullptr, links, true);
 163     zone->add_route(host2->get_netpoint(), nullptr, nullptr, nullptr, links2, true);
 164     zone->seal();
 165
 166     double lat = 0.0;
 167     simgrid::kernel::routing::RouteCreationArgs route;
 168     zone->get_local_route(host1->get_netpoint(), host2->get_netpoint(), &route, &lat);
 169     REQUIRE(lat == 30);
 170     REQUIRE(route.gw_src == nullptr);
 171     REQUIRE(route.gw_dst == nullptr);
 172     REQUIRE(route.link_list.size() == 2);
 173     REQUIRE(route.link_list[0]->get_name() == "link1");
 174     REQUIRE(route.link_list[1]->get_name() == "link2");
 175   }
 176
 177   SECTION("Get route: shared link(backbone)")
 178   {
 179     auto* backbone = zone->create_link("backbone", {1000})->set_latency(100)->get_impl();
 180     std::vector<simgrid::kernel::resource::LinkImpl*> links;
 181     links.push_back(zone->create_link("link1", {100})->set_latency(10)->get_impl());
 182     links.push_back(backbone);
 183     std::vector<simgrid::kernel::resource::LinkImpl*> links2;
 184     links2.push_back(zone->create_link("link2", {200})->set_latency(20)->get_impl());
 185     links2.push_back(backbone);
 186
 187     zone->add_route(host1->get_netpoint(), nullptr, nullptr, nullptr, links, true);
 188     zone->add_route(host2->get_netpoint(), nullptr, nullptr, nullptr, links2, true);
 189     zone->seal();
 190
 191     double lat = 0.0;
 192     simgrid::kernel::routing::RouteCreationArgs route;
 193     zone->get_local_route(host1->get_netpoint(), host2->get_netpoint(), &route, &lat);
 194     REQUIRE(lat == 130);
 195     REQUIRE(route.link_list.size() == 3);
 196     REQUIRE(route.link_list[0]->get_name() == "link1");
 197     REQUIRE(route.link_list[1]->get_name() == "backbone");
 198     REQUIRE(route.link_list[2]->get_name() == "link2");
 199   }
 200
 201   SECTION("Get route: loopback")
 202   {
 203     auto* backbone = zone->create_link("backbone", {1000})->set_latency(100)->get_impl();
 204     std::vector<simgrid::kernel::resource::LinkImpl*> links;
 205     links.push_back(zone->create_link("link1", {100})->set_latency(10)->get_impl());
 206     links.push_back(backbone);
 207
 208     zone->add_route(host1->get_netpoint(), host1->get_netpoint(), nullptr, nullptr, links, true);
 209     zone->seal();
 210
 211     double lat = 0.0;
 212     simgrid::kernel::routing::RouteCreationArgs route;
 213     zone->get_local_route(host1->get_netpoint(), host1->get_netpoint(), &route, &lat);
 214     REQUIRE(lat == 110);
 215     REQUIRE(route.link_list.size() == 2);
 216     REQUIRE(route.link_list[0]->get_name() == "link1");
 217     REQUIRE(route.link_list[1]->get_name() == "backbone");
 218   }
 219 }
 220
 221 TEST_CASE("kernel::routing::StarZone: Get routes (netzones)", "")
 222 {
 223   /* workaround to initialize things, they must be done in this particular order */
 224   EngineWrapper e("test");
 225   auto* zone = new simgrid::kernel::routing::StarZone("test");
 226   surf_network_model_init_LegrandVelho();
 227   surf_cpu_model_init_Cas01();
 228
 229   auto* subzone1 =
 230       (new simgrid::kernel::routing::NetPoint("subzone1", simgrid::kernel::routing::NetPoint::Type::NetZone))
 231           ->set_englobing_zone(zone);
 232   auto* subzone2 =
 233       (new simgrid::kernel::routing::NetPoint("subzone2", simgrid::kernel::routing::NetPoint::Type::NetZone))
 234           ->set_englobing_zone(zone);
 235   auto* router1 = new simgrid::kernel::routing::NetPoint("router1", simgrid::kernel::routing::NetPoint::Type::Router);
 236   auto* router2 = new simgrid::kernel::routing::NetPoint("router2", simgrid::kernel::routing::NetPoint::Type::Router);
 237
 238   SECTION("Get route: netzone")
 239   {
 240     std::vector<simgrid::kernel::resource::LinkImpl*> links;
 241     links.push_back(zone->create_link("link1", {100})->set_latency(10)->get_impl());
 242     std::vector<simgrid::kernel::resource::LinkImpl*> links2;
 243     links2.push_back(zone->create_link("link2", {200})->set_latency(20)->get_impl());
 244     zone->add_route(subzone1, nullptr, router1, nullptr, links, true);
 245     zone->add_route(subzone2, nullptr, router2, nullptr, links2, true);
 246     zone->seal();
 247
 248     double lat = 0.0;
 249     simgrid::kernel::routing::RouteCreationArgs route;
 250     zone->get_local_route(subzone1, subzone2, &route, &lat);
 251     REQUIRE(lat == 30);
 252     REQUIRE(route.gw_src == router1);
 253     REQUIRE(route.gw_dst == router2);
 254     REQUIRE(route.link_list.size() == 2);
 255     REQUIRE(route.link_list[0]->get_name() == "link1");
 256     REQUIRE(route.link_list[1]->get_name() == "link2");
 257   }
 258 }