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