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