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