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