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