X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/95a02a8febe84fd1c2ed98c78c594a5e8a0116f7..fc8be6494932e66a359ae5d47103a566cc8234f4:/src/kernel/routing/TorusZone.cpp

diff --git a/src/kernel/routing/TorusZone.cpp b/src/kernel/routing/TorusZone.cpp
index 0e45b8101f..a23d1b1581 100644
--- a/src/kernel/routing/TorusZone.cpp
+++ b/src/kernel/routing/TorusZone.cpp
@@ -6,6 +6,7 @@
 #include "simgrid/kernel/routing/TorusZone.hpp"
 #include "simgrid/kernel/routing/NetPoint.hpp"
 #include "src/surf/network_interface.hpp"
+#include "src/surf/xml/platf_private.hpp"
 
 #include <boost/algorithm/string/classification.hpp>
 #include <boost/algorithm/string/split.hpp>
@@ -14,12 +15,12 @@
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_route_cluster_torus, surf_route_cluster, "Torus Routing part of surf");
 
-inline void rankId_to_coords(int rankId, std::vector<unsigned int> dimensions, unsigned int (*coords)[4])
+inline void rankId_to_coords(int rankId, std::vector<unsigned int> dimensions, unsigned int* coords)
 {
   unsigned int dim_size_product = 1;
   unsigned int i = 0;
   for (auto const& cur_dim_size : dimensions) {
-    (*coords)[i] = (rankId / dim_size_product) % cur_dim_size;
+    coords[i] = (rankId / dim_size_product) % cur_dim_size;
     dim_size_product *= cur_dim_size;
     i++;
   }
@@ -28,7 +29,8 @@ inline void rankId_to_coords(int rankId, std::vector<unsigned int> dimensions, u
 namespace simgrid {
 namespace kernel {
 namespace routing {
-TorusZone::TorusZone(NetZone* father, std::string name) : ClusterZone(father, name)
+TorusZone::TorusZone(NetZoneImpl* father, std::string name, resource::NetworkModel* netmodel)
+    : ClusterZone(father, name, netmodel)
 {
 }
 
@@ -53,15 +55,13 @@ void TorusZone::create_links_for_node(ClusterCreationArgs* cluster, int id, int
     link.latency   = cluster->lat;
     link.policy    = cluster->sharing_policy;
     sg_platf_new_link(&link);
-    surf::LinkImpl* linkUp;
-    surf::LinkImpl* linkDown;
-    if (link.policy == SURF_LINK_SPLITDUPLEX) {
-      std::string tmp_link = link_id + "_UP";
-      linkUp         = surf::LinkImpl::byName(tmp_link);
-      tmp_link             = link_id + "_DOWN";
-      linkDown = surf::LinkImpl::byName(tmp_link);
+    resource::LinkImpl* linkUp;
+    resource::LinkImpl* linkDown;
+    if (link.policy == s4u::Link::SharingPolicy::SPLITDUPLEX) {
+      linkUp   = s4u::Link::by_name(link_id + "_UP")->get_impl();
+      linkDown = s4u::Link::by_name(link_id + "_DOWN")->get_impl();
     } else {
-      linkUp   = surf::LinkImpl::byName(link_id);
+      linkUp   = s4u::Link::by_name(link_id)->get_impl();
       linkDown = linkUp;
     }
     /*
@@ -69,7 +69,7 @@ void TorusZone::create_links_for_node(ClusterCreationArgs* cluster, int id, int
      * Note that position rankId*(xbt_dynar_length(dimensions)+has_loopback?+has_limiter?)
      * holds the link "rankId->rankId"
      */
-    privateLinks_.insert({position + j, {linkUp, linkDown}});
+    private_links_.insert({position + j, {linkUp, linkDown}});
     dim_product *= current_dimension;
   }
   rank++;
@@ -88,24 +88,24 @@ void TorusZone::parse_specific_arguments(ClusterCreationArgs* cluster)
     for (auto const& group : dimensions)
       dimensions_.push_back(surf_parse_get_int(group));
 
-    linkCountPerNode_ = dimensions_.size();
+    num_links_per_node_ = dimensions_.size();
   }
 }
 
-void TorusZone::getLocalRoute(NetPoint* src, NetPoint* dst, RouteCreationArgs* route, double* lat)
+void TorusZone::get_local_route(NetPoint* src, NetPoint* dst, RouteCreationArgs* route, double* lat)
 {
 
-  XBT_VERB("torus getLocalRoute from '%s'[%u] to '%s'[%u]", src->getCname(), src->id(), dst->getCname(), dst->id());
+  XBT_VERB("torus getLocalRoute from '%s'[%u] to '%s'[%u]", src->get_cname(), src->id(), dst->get_cname(), dst->id());
 
-  if (dst->isRouter() || src->isRouter())
+  if (dst->is_router() || src->is_router())
     return;
 
-  if (src->id() == dst->id() && hasLoopback_) {
-    std::pair<surf::LinkImpl*, surf::LinkImpl*> info = privateLinks_.at(src->id() * linkCountPerNode_);
+  if (src->id() == dst->id() && has_loopback_) {
+    std::pair<resource::LinkImpl*, resource::LinkImpl*> info = private_links_.at(src->id() * num_links_per_node_);
 
     route->link_list.push_back(info.first);
     if (lat)
-      *lat += info.first->latency();
+      *lat += info.first->get_latency();
     return;
   }
 
@@ -119,10 +119,10 @@ void TorusZone::getLocalRoute(NetPoint* src, NetPoint* dst, RouteCreationArgs* r
    * Arrays that hold the coordinates of the current node andthe target; comparing the values at the i-th position of
    * both arrays, we can easily assess whether we need to route into this dimension or not.
    */
-  unsigned int myCoords[4];
-  rankId_to_coords(src->id(), dimensions_, &myCoords);
-  unsigned int targetCoords[4];
-  rankId_to_coords(dst->id(), dimensions_, &targetCoords);
+  unsigned int myCoords[dimensions_.size()];
+  rankId_to_coords(src->id(), dimensions_, myCoords);
+  unsigned int targetCoords[dimensions_.size()];
+  rankId_to_coords(dst->id(), dimensions_, targetCoords);
   /*
    * linkOffset describes the offset where the link we want to use is stored(+1 is added because each node has a link
    * from itself to itself, which can only be the case if src->m_id == dst->m_id -- see above for this special case)
@@ -150,8 +150,8 @@ void TorusZone::getLocalRoute(NetPoint* src, NetPoint* dst, RouteCreationArgs* r
             next_node = (current_node + dim_product);
 
           // HERE: We use *CURRENT* node for calculation (as opposed to next_node)
-          nodeOffset = current_node * (linkCountPerNode_);
-          linkOffset = nodeOffset + (hasLoopback_ ? 1 : 0) + (hasLimiter_ ? 1 : 0) + j;
+          nodeOffset = current_node * (num_links_per_node_);
+          linkOffset = nodeOffset + (has_loopback_ ? 1 : 0) + (has_limiter_ ? 1 : 0) + j;
           use_lnk_up = true;
           assert(linkOffset >= 0);
         } else { // Route to the left
@@ -161,8 +161,8 @@ void TorusZone::getLocalRoute(NetPoint* src, NetPoint* dst, RouteCreationArgs* r
             next_node = (current_node - dim_product);
 
           // HERE: We use *next* node for calculation (as opposed to current_node!)
-          nodeOffset = next_node * (linkCountPerNode_);
-          linkOffset = nodeOffset + j + (hasLoopback_ ? 1 : 0) + (hasLimiter_ ? 1 : 0);
+          nodeOffset = next_node * (num_links_per_node_);
+          linkOffset = nodeOffset + j + (has_loopback_ ? 1 : 0) + (has_limiter_ ? 1 : 0);
           use_lnk_up = false;
 
           assert(linkOffset >= 0);
@@ -176,23 +176,23 @@ void TorusZone::getLocalRoute(NetPoint* src, NetPoint* dst, RouteCreationArgs* r
       dim_product *= cur_dim;
     }
 
-    std::pair<surf::LinkImpl*, surf::LinkImpl*> info;
+    std::pair<resource::LinkImpl*, resource::LinkImpl*> info;
 
-    if (hasLimiter_) { // limiter for sender
-      info = privateLinks_.at(nodeOffset + (hasLoopback_ ? 1 : 0));
+    if (has_limiter_) { // limiter for sender
+      info = private_links_.at(nodeOffset + (has_loopback_ ? 1 : 0));
       route->link_list.push_back(info.first);
     }
 
-    info = privateLinks_.at(linkOffset);
+    info = private_links_.at(linkOffset);
 
     if (use_lnk_up == false) {
       route->link_list.push_back(info.second);
       if (lat)
-        *lat += info.second->latency();
+        *lat += info.second->get_latency();
     } else {
       route->link_list.push_back(info.first);
       if (lat)
-        *lat += info.first->latency();
+        *lat += info.first->get_latency();
     }
     current_node = next_node;
     next_node    = 0;