empty RoutingPlatf: move the loopback link to the network_model(s)

[simgrid.git] / src / kernel / routing / AsImpl.cpp

diff --git a/src/kernel/routing/AsImpl.cpp b/src/kernel/routing/AsImpl.cpp
index 150982509186e16b0b19c9ebbfc36c52e9d44300..3bd9c9e08011853cc4efd0185f3ef53c0e9aa900 100644 (file)
--- a/src/kernel/routing/AsImpl.cpp
+++ b/src/kernel/routing/AsImpl.cpp
@@ -7,6 +7,7 @@
 
 #include "simgrid/s4u/host.hpp"
 #include "src/kernel/routing/AsImpl.hpp"
+#include "src/surf/cpu_interface.hpp"
 #include "src/surf/network_interface.hpp" // Link FIXME: move to proper header
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(AsImpl,surf, "Implementation of S4U autonomous systems");
@@ -26,12 +27,18 @@ namespace simgrid {
   }
   AsImpl::~AsImpl() = default;
 
-  void AsImpl::attachHost(s4u::Host* host)
+  simgrid::s4u::Host* AsImpl::createHost(const char* name, std::vector<double>* speedPerPstate, int coreAmount)
   {
+    simgrid::s4u::Host* res = new simgrid::s4u::Host(name);
+
     if (hierarchy_ == RoutingMode::unset)
       hierarchy_ = RoutingMode::base;
 
-    host->pimpl_netcard = new NetCardImpl(host->name().c_str(), NetCard::Type::Host, this);
+    res->pimpl_netcard = new NetCardImpl(name, NetCard::Type::Host, this);
+
+    surf_cpu_model_pm->createCpu(res, speedPerPstate, coreAmount);
+
+    return res;
   }
 
   xbt_dynar_t AsImpl::getOneLinkRoutes()
@@ -158,14 +165,14 @@ namespace simgrid {
 
     /* Base case, no recursion is needed */
     if (dst->containingAS() == this && src->containingAS() == this) {
-      if (bypassRoutes_.find({src->name(), dst->name()}) != bypassRoutes_.end()) {
-        std::vector<surf::Link*>* bypassedRoute = bypassRoutes_.at({src->name(), dst->name()});
-        for (surf::Link* link : *bypassedRoute) {
+      if (bypassRoutes_.find({src, dst}) != bypassRoutes_.end()) {
+        AsRoute* bypassedRoute = bypassRoutes_.at({src, dst});
+        for (surf::Link* link : bypassedRoute->links) {
           links->push_back(link);
           if (latency)
             *latency += link->latency();
         }
-        XBT_DEBUG("Found a bypass route with %zu links", bypassedRoute->size());
+        XBT_DEBUG("Found a bypass route with %zu links", bypassedRoute->links.size());
         return true;
       }
       return false;
@@ -173,20 +180,19 @@ namespace simgrid {
 
     /* Engage recursive search */
 
-    std::vector<surf::Link*>* bypassedRoute = nullptr;
 
     /* (1) find the path to the root routing component */
-    std::vector<As*> path_src;
+    std::vector<AsImpl*> path_src;
     As* current = src->containingAS();
     while (current != nullptr) {
-      path_src.push_back(current);
+      path_src.push_back(static_cast<AsImpl*>(current));
       current = current->father_;
     }
 
-    std::vector<As*> path_dst;
+    std::vector<AsImpl*> path_dst;
     current = dst->containingAS();
     while (current != nullptr) {
-      path_dst.push_back(current);
+      path_dst.push_back(static_cast<AsImpl*>(current));
       current = current->father_;
     }
 
@@ -202,17 +208,20 @@ namespace simgrid {
 
     int max_index = std::max(max_index_src, max_index_dst);
 
+    /* (3) Search for a bypass making the path up to the ancestor useless */
+    AsRoute* bypassedRoute = nullptr;
+    std::pair<kernel::routing::NetCard*, kernel::routing::NetCard*> key;
     for (int max = 0; max <= max_index; max++) {
       for (int i = 0; i < max; i++) {
         if (i <= max_index_src && max <= max_index_dst) {
-          const std::pair<std::string, std::string> key = {path_src.at(i)->name(), path_dst.at(max)->name()};
+          key = {path_src.at(i)->netcard_, path_dst.at(max)->netcard_};
           if (bypassRoutes_.find(key) != bypassRoutes_.end()) {
             bypassedRoute = bypassRoutes_.at(key);
             break;
           }
         }
         if (max <= max_index_src && i <= max_index_dst) {
-          const std::pair<std::string, std::string> key = {path_src.at(max)->name(), path_dst.at(i)->name()};
+          key = {path_src.at(max)->netcard_, path_dst.at(i)->netcard_};
           if (bypassRoutes_.find(key) != bypassRoutes_.end()) {
             bypassedRoute = bypassRoutes_.at(key);
             break;
@@ -224,7 +233,7 @@ namespace simgrid {
         break;
 
       if (max <= max_index_src && max <= max_index_dst) {
-        const std::pair<std::string, std::string> key = {path_src.at(max)->name(), path_dst.at(max)->name()};
+        key = {path_src.at(max)->netcard_, path_dst.at(max)->netcard_};
         if (bypassRoutes_.find(key) != bypassRoutes_.end()) {
           bypassedRoute = bypassRoutes_.at(key);
           break;
@@ -232,12 +241,17 @@ namespace simgrid {
       }
     }
 
+    /* (4) If we have the bypass, use it. If not, caller will do the Right Thing. */
     if (bypassedRoute) {
-      for (surf::Link* link : *bypassedRoute) {
+      if (src != key.first)
+        getRouteRecursive(src, const_cast<NetCard*>(bypassedRoute->gw_src), links, latency);
+      for (surf::Link* link : bypassedRoute->links) {
         links->push_back(link);
         if (latency)
           *latency += link->latency();
       }
+      if (dst != key.second)
+        getRouteRecursive(const_cast<NetCard*>(bypassedRoute->gw_dst), dst, links, latency);
       return true;
     }
     return false;