src/kernel/routing/StarZone_test.cpp

   1 /* Copyright (c) 2017-2022. 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/kernel/resource/StandardLinkImpl.hpp"
  14
  15 TEST_CASE("kernel::routing::StarZone: Creating Zone", "[creation]")
  16 {
  17   simgrid::s4u::Engine e("test");
  18
  19   REQUIRE(simgrid::s4u::create_star_zone("test"));
  20 }
  21
  22 TEST_CASE("kernel::routing::StarZone: Create links: exceptions", "")
  23 {
  24   simgrid::s4u::Engine e("test");
  25   auto* zone = simgrid::s4u::create_star_zone("test");
  26   SECTION("create_link: invalid bandwidth")
  27   {
  28     REQUIRE_THROWS_AS(zone->create_link("link", "speed"), std::invalid_argument);
  29   }
  30
  31   SECTION("split-duplex create_link: invalid bandwidth")
  32   {
  33     REQUIRE_THROWS_AS(zone->create_split_duplex_link("link", "speed"), std::invalid_argument);
  34   }
  35 }
  36
  37 TEST_CASE("kernel::routing::StarZone: Adding routes (hosts): exception", "")
  38 {
  39   simgrid::s4u::Engine 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")
  45   {
  46     REQUIRE_THROWS_AS(zone->add_route(nullptr, nullptr, nullptr, nullptr, {}, false), std::invalid_argument);
  47   }
  48
  49   SECTION("src: nullptr and symmetrical: true")
  50   {
  51     REQUIRE_THROWS_AS(zone->add_route(nullptr, netpoint2, nullptr, nullptr, {}, true), std::invalid_argument);
  52   }
  53
  54   SECTION("src and dst: not nullptr")
  55   {
  56     REQUIRE_THROWS_AS(zone->add_route(netpoint1, netpoint2, nullptr, nullptr, {}, false), std::invalid_argument);
  57   }
  58 }
  59
  60 TEST_CASE("kernel::routing::StarZone: Adding routes (netzones): exception", "")
  61 {
  62   simgrid::s4u::Engine e("test");
  63   auto* zone = new simgrid::kernel::routing::StarZone("test");
  64   auto* netpoint1 =
  65       new simgrid::kernel::routing::NetPoint("netpoint1", simgrid::kernel::routing::NetPoint::Type::NetZone);
  66   auto* netpoint2 =
  67       new simgrid::kernel::routing::NetPoint("netpoint2", simgrid::kernel::routing::NetPoint::Type::NetZone);
  68   auto zone3      = std::make_unique<simgrid::kernel::routing::StarZone>("test3");
  69   auto* netpoint3 = zone3->create_router("netpoint3");
  70
  71   SECTION("src: is a netzone and gw_src: nullptr")
  72   {
  73     REQUIRE_THROWS_AS(zone->add_route(netpoint1, nullptr, nullptr, nullptr, {}, false), std::invalid_argument);
  74   }
  75
  76   SECTION("src: is a netzone and gw_src: is a netzone")
  77   {
  78     REQUIRE_THROWS_AS(zone->add_route(netpoint1, nullptr, netpoint2, nullptr, {}, false), std::invalid_argument);
  79   }
  80
  81   SECTION("dst: is a netzone and gw_dst: nullptr")
  82   {
  83     REQUIRE_THROWS_AS(zone->add_route(nullptr, netpoint2, nullptr, nullptr, {}, false), std::invalid_argument);
  84   }
  85
  86   SECTION("dst: is a netzone and gw_dst: is a netzone")
  87   {
  88     REQUIRE_THROWS_AS(zone->add_route(nullptr, netpoint2, nullptr, netpoint1, {}, false), std::invalid_argument);
  89   }
  90
  91   SECTION("issue71: gw_src isn't member of the src netzone")
  92   {
  93     REQUIRE_THROWS_AS(zone->add_route(zone->get_netpoint(), nullptr, netpoint3, nullptr, {}, false),
  94                       std::invalid_argument);
  95   }
  96
  97   SECTION("issue71: gw_dst isn't member of the dst netzone")
  98   {
  99     REQUIRE_THROWS_AS(zone->add_route(nullptr, zone->get_netpoint(), nullptr, netpoint3, {}, false),
 100                       std::invalid_argument);
 101   }
 102 }
 103
 104 // One day we may be able to test contracts and asserts with catch2
 105 // https://github.com/catchorg/Catch2/issues/853
 106 TEST_CASE("kernel::routing::StarZone: Get routes: assert", "[.][assert]")
 107 {
 108   simgrid::s4u::Engine e("test");
 109   auto* zone = new simgrid::kernel::routing::StarZone("test");
 110
 111   const auto* host1 = zone->create_host("netpoint1", {100});
 112   const auto* host2 = zone->create_host("netpoint2", {100});
 113   std::vector<simgrid::s4u::LinkInRoute> links;
 114   links.emplace_back(zone->create_link("link1", {100}));
 115   std::vector<simgrid::s4u::LinkInRoute> links2;
 116   links2.emplace_back(zone->create_link("link2", {100}));
 117
 118   SECTION("Get route: no UP link")
 119   {
 120     zone->add_route(host1->get_netpoint(), nullptr, nullptr, nullptr, links, true);
 121     zone->add_route(nullptr, host2->get_netpoint(), nullptr, nullptr, links2, false);
 122     double lat;
 123     simgrid::kernel::routing::Route route;
 124     zone->get_local_route(host2->get_netpoint(), host1->get_netpoint(), &route, &lat);
 125   }
 126
 127   SECTION("Get route: no DOWN link")
 128   {
 129     zone->add_route(host1->get_netpoint(), nullptr, nullptr, nullptr, links, false);
 130     zone->add_route(host2->get_netpoint(), nullptr, nullptr, nullptr, links2, true);
 131     double lat;
 132     simgrid::kernel::routing::Route route;
 133     zone->get_local_route(host2->get_netpoint(), host1->get_netpoint(), &route, &lat);
 134   }
 135 }
 136
 137 TEST_CASE("kernel::routing::StarZone: Adding routes (hosts): valid", "")
 138 {
 139   simgrid::s4u::Engine e("test");
 140   auto* zone     = new simgrid::kernel::routing::StarZone("test");
 141   auto* netpoint = new simgrid::kernel::routing::NetPoint("netpoint1", simgrid::kernel::routing::NetPoint::Type::Host);
 142
 143   SECTION("Source set, destination nullptr, symmetrical true")
 144   {
 145     zone->add_route(netpoint, nullptr, nullptr, nullptr, {}, true);
 146   }
 147
 148   SECTION("Source nullptr, destination set, symmetrical false")
 149   {
 150     zone->add_route(nullptr, netpoint, nullptr, nullptr, {}, false);
 151   }
 152
 153   SECTION("Source set, destination nullptr, symmetrical false")
 154   {
 155     zone->add_route(netpoint, nullptr, nullptr, nullptr, {}, false);
 156   }
 157
 158   SECTION("Source == destination") { zone->add_route(netpoint, netpoint, nullptr, nullptr, {}, false); }
 159 }
 160
 161 TEST_CASE("kernel::routing::StarZone: Adding routes (netzones): valid", "")
 162 {
 163   simgrid::s4u::Engine e("test");
 164   auto* zone     = new simgrid::kernel::routing::StarZone("test");
 165   auto* netpoint = new simgrid::kernel::routing::NetPoint("netpoint1", simgrid::kernel::routing::NetPoint::Type::Host);
 166   auto* gw       = new simgrid::kernel::routing::NetPoint("gw1", simgrid::kernel::routing::NetPoint::Type::Router);
 167
 168   SECTION("src: is a netzone, src_gw: is a router") { zone->add_route(netpoint, nullptr, gw, nullptr, {}, true); }
 169
 170   SECTION("dst: is a netzone, dst_gw: is a router") { zone->add_route(nullptr, netpoint, nullptr, gw, {}, false); }
 171 }
 172
 173 TEST_CASE("kernel::routing::StarZone: Get routes (hosts)", "")
 174 {
 175   simgrid::s4u::Engine e("test");
 176   auto* zone = new simgrid::kernel::routing::StarZone("test");
 177
 178   const auto* host1 = zone->create_host("netpoint1", {100});
 179   const auto* host2 = zone->create_host("netpoint2", {100});
 180
 181   SECTION("Get route: no shared link")
 182   {
 183     std::vector<simgrid::s4u::LinkInRoute> links;
 184     links.emplace_back(zone->create_link("link1", {100})->set_latency(10));
 185     std::vector<simgrid::s4u::LinkInRoute> links2;
 186     links2.emplace_back(zone->create_link("link2", {200})->set_latency(20));
 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::Route route;
 193     zone->get_local_route(host1->get_netpoint(), host2->get_netpoint(), &route, &lat);
 194     REQUIRE(lat == 30);
 195     REQUIRE(route.gw_src_ == nullptr);
 196     REQUIRE(route.gw_dst_ == nullptr);
 197     REQUIRE(route.link_list_.size() == 2);
 198     REQUIRE(route.link_list_[0]->get_name() == "link1");
 199     REQUIRE(route.link_list_[1]->get_name() == "link2");
 200   }
 201
 202   SECTION("Get route: shared link(backbone)")
 203   {
 204     auto* backbone = zone->create_link("backbone", {1000})->set_latency(100);
 205     std::vector<simgrid::s4u::LinkInRoute> links;
 206     links.emplace_back(zone->create_link("link1", {100})->set_latency(10));
 207     links.emplace_back(backbone);
 208     std::vector<simgrid::s4u::LinkInRoute> links2;
 209     links2.emplace_back(zone->create_link("link2", {200})->set_latency(20));
 210     links2.emplace_back(backbone);
 211
 212     zone->add_route(host1->get_netpoint(), nullptr, nullptr, nullptr, links, true);
 213     zone->add_route(host2->get_netpoint(), nullptr, nullptr, nullptr, links2, true);
 214     zone->seal();
 215
 216     double lat = 0.0;
 217     simgrid::kernel::routing::Route route;
 218     zone->get_local_route(host1->get_netpoint(), host2->get_netpoint(), &route, &lat);
 219     REQUIRE(lat == 130);
 220     REQUIRE(route.link_list_.size() == 3);
 221     REQUIRE(route.link_list_[0]->get_name() == "link1");
 222     REQUIRE(route.link_list_[1]->get_name() == "backbone");
 223     REQUIRE(route.link_list_[2]->get_name() == "link2");
 224   }
 225
 226   SECTION("Get route: loopback")
 227   {
 228     auto* backbone = zone->create_link("backbone", {1000})->set_latency(100);
 229     std::vector<simgrid::s4u::LinkInRoute> links;
 230     links.emplace_back(zone->create_link("link1", {100})->set_latency(10));
 231     links.emplace_back(backbone);
 232
 233     zone->add_route(host1->get_netpoint(), host1->get_netpoint(), nullptr, nullptr, links, true);
 234     zone->seal();
 235
 236     double lat = 0.0;
 237     simgrid::kernel::routing::Route route;
 238     zone->get_local_route(host1->get_netpoint(), host1->get_netpoint(), &route, &lat);
 239     REQUIRE(lat == 110);
 240     REQUIRE(route.link_list_.size() == 2);
 241     REQUIRE(route.link_list_[0]->get_name() == "link1");
 242     REQUIRE(route.link_list_[1]->get_name() == "backbone");
 243   }
 244 }
 245
 246 TEST_CASE("kernel::routing::StarZone: Get routes (netzones)", "")
 247 {
 248   simgrid::s4u::Engine e("test");
 249   auto* zone = new simgrid::kernel::routing::StarZone("test");
 250
 251   auto* subzone1 = new simgrid::kernel::routing::StarZone("subzone1");
 252   subzone1->set_parent(zone);
 253   auto* subzone2 = new simgrid::kernel::routing::StarZone("subzone2");
 254   subzone2->set_parent(zone);
 255
 256   auto* router1 = subzone1->create_router("router1");
 257   auto* router2 = subzone2->create_router("router2");
 258
 259   SECTION("Get route: netzone")
 260   {
 261     std::vector<simgrid::s4u::LinkInRoute> links;
 262     links.emplace_back(zone->create_link("link1", {100})->set_latency(10));
 263     std::vector<simgrid::s4u::LinkInRoute> links2;
 264     links2.emplace_back(zone->create_link("link2", {200})->set_latency(20));
 265     zone->add_route(subzone1->get_netpoint(), nullptr, router1, nullptr, links, true);
 266     zone->add_route(subzone2->get_netpoint(), nullptr, router2, nullptr, links2, true);
 267     zone->seal();
 268
 269     double lat = 0.0;
 270     simgrid::kernel::routing::Route route;
 271     zone->get_local_route(subzone1->get_netpoint(), subzone2->get_netpoint(), &route, &lat);
 272     REQUIRE(lat == 30);
 273     REQUIRE(route.gw_src_ == router1);
 274     REQUIRE(route.gw_dst_ == router2);
 275     REQUIRE(route.link_list_.size() == 2);
 276     REQUIRE(route.link_list_[0]->get_name() == "link1");
 277     REQUIRE(route.link_list_[1]->get_name() == "link2");
 278   }
 279 }
 280
 281 TEST_CASE("kernel::routing::StarZone: mix new routes and hosts", "")
 282 {
 283   simgrid::s4u::Engine e("test");
 284   auto* zone = simgrid::s4u::create_star_zone("test");
 285
 286   const simgrid::s4u::Link* link = zone->create_link("my_link", 1e6)->seal();
 287   for (int i = 0; i < 10; i++) {
 288     std::string cpu_name          = "CPU" + std::to_string(i);
 289     const simgrid::s4u::Host* cpu = zone->create_host(cpu_name, 1e9)->seal();
 290     REQUIRE_NOTHROW(
 291         zone->add_route(cpu->get_netpoint(), nullptr, nullptr, nullptr, {simgrid::s4u::LinkInRoute(link)}, true));
 292   }
 293 }