give a network_model to each NetZone (unused for now)

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

diff --git a/src/kernel/routing/DragonflyZone.cpp b/src/kernel/routing/DragonflyZone.cpp
index dbb52a3..34b4513 100644 (file)
--- a/src/kernel/routing/DragonflyZone.cpp
+++ b/src/kernel/routing/DragonflyZone.cpp
@@ -18,7 +18,8 @@ namespace simgrid {
 namespace kernel {
 namespace routing {
 
-DragonflyZone::DragonflyZone(NetZone* father, std::string name) : ClusterZone(father, name)
+DragonflyZone::DragonflyZone(NetZoneImpl* father, std::string name, resource::NetworkModel* netmodel)
+    : ClusterZone(father, name, netmodel)
 {
 }
 
@@ -31,15 +32,15 @@ DragonflyZone::~DragonflyZone()
   }
 }
 
-void DragonflyZone::rankId_to_coords(int rankId, unsigned int (*coords)[4])
+void DragonflyZone::rankId_to_coords(int rankId, unsigned int coords[4])
 {
   // coords : group, chassis, blade, node
-  (*coords)[0] = rankId / (num_chassis_per_group_ * num_blades_per_chassis_ * num_nodes_per_blade_);
-  rankId       = rankId % (num_chassis_per_group_ * num_blades_per_chassis_ * num_nodes_per_blade_);
-  (*coords)[1] = rankId / (num_blades_per_chassis_ * num_nodes_per_blade_);
-  rankId       = rankId % (num_blades_per_chassis_ * num_nodes_per_blade_);
-  (*coords)[2] = rankId / num_nodes_per_blade_;
-  (*coords)[3] = rankId % num_nodes_per_blade_;
+  coords[0] = rankId / (num_chassis_per_group_ * num_blades_per_chassis_ * num_nodes_per_blade_);
+  rankId    = rankId % (num_chassis_per_group_ * num_blades_per_chassis_ * num_nodes_per_blade_);
+  coords[1] = rankId / (num_blades_per_chassis_ * num_nodes_per_blade_);
+  rankId    = rankId % (num_blades_per_chassis_ * num_nodes_per_blade_);
+  coords[2] = rankId / num_nodes_per_blade_;
+  coords[3] = rankId % num_nodes_per_blade_;
 }
 
 void DragonflyZone::parse_specific_arguments(ClusterCreationArgs* cluster)
@@ -114,7 +115,7 @@ void DragonflyZone::parse_specific_arguments(ClusterCreationArgs* cluster)
   }
 
   this->sharing_policy_ = cluster->sharing_policy;
-  if (cluster->sharing_policy == SURF_LINK_SPLITDUPLEX)
+  if (cluster->sharing_policy == s4u::Link::SharingPolicy::SPLITDUPLEX)
     this->num_links_per_link_ = 2;
   this->bw_  = cluster->bw;
   this->lat_ = cluster->lat;
@@ -127,8 +128,8 @@ void DragonflyZone::seal()
     return;
   }
 
-  this->generateRouters();
-  this->generateLinks();
+  this->generate_routers();
+  this->generate_links();
 }
 
 DragonflyRouter::DragonflyRouter(int group, int chassis, int blade) : group_(group), chassis_(chassis), blade_(blade)
@@ -143,7 +144,7 @@ DragonflyRouter::~DragonflyRouter()
   delete blue_links_;
 }
 
-void DragonflyZone::generateRouters()
+void DragonflyZone::generate_routers()
 {
   this->routers_ =
       new DragonflyRouter*[this->num_groups_ * this->num_chassis_per_group_ * this->num_blades_per_chassis_];
@@ -159,8 +160,8 @@ void DragonflyZone::generateRouters()
   }
 }
 
-void DragonflyZone::createLink(const std::string& id, int numlinks, resource::LinkImpl** linkup,
-                               resource::LinkImpl** linkdown)
+void DragonflyZone::create_link(const std::string& id, int numlinks, resource::LinkImpl** linkup,
+                                resource::LinkImpl** linkdown)
 {
   *linkup   = nullptr;
   *linkdown = nullptr;
@@ -172,17 +173,17 @@ void DragonflyZone::createLink(const std::string& id, int numlinks, resource::Li
   sg_platf_new_link(&linkTemplate);
   XBT_DEBUG("Generating link %s", id.c_str());
   resource::LinkImpl* link;
-  if (this->sharing_policy_ == SURF_LINK_SPLITDUPLEX) {
-    *linkup   = resource::LinkImpl::byName(linkTemplate.id + "_UP");   // check link?
-    *linkdown = resource::LinkImpl::byName(linkTemplate.id + "_DOWN"); // check link ?
+  if (this->sharing_policy_ == s4u::Link::SharingPolicy::SPLITDUPLEX) {
+    *linkup   = s4u::Link::by_name(linkTemplate.id + "_UP")->get_impl();   // check link?
+    *linkdown = s4u::Link::by_name(linkTemplate.id + "_DOWN")->get_impl(); // check link ?
   } else {
-    link      = resource::LinkImpl::byName(linkTemplate.id);
+    link      = s4u::Link::by_name(linkTemplate.id)->get_impl();
     *linkup   = link;
     *linkdown = link;
   }
 }
 
-void DragonflyZone::generateLinks()
+void DragonflyZone::generate_links()
 {
   static int uniqueId = 0;
   resource::LinkImpl* linkup;
@@ -200,10 +201,10 @@ void DragonflyZone::generateLinks()
     for (unsigned int j = 0; j < num_links_per_link_ * this->num_nodes_per_blade_; j += num_links_per_link_) {
       std::string id = "local_link_from_router_" + std::to_string(i) + "_to_node_" +
                        std::to_string(j / num_links_per_link_) + "_" + std::to_string(uniqueId);
-      this->createLink(id, 1, &linkup, &linkdown);
+      this->create_link(id, 1, &linkup, &linkdown);
 
       this->routers_[i]->my_nodes_[j] = linkup;
-      if (this->sharing_policy_ == SURF_LINK_SPLITDUPLEX)
+      if (this->sharing_policy_ == s4u::Link::SharingPolicy::SPLITDUPLEX)
         this->routers_[i]->my_nodes_[j + 1] = linkdown;
 
       uniqueId++;
@@ -216,7 +217,7 @@ void DragonflyZone::generateLinks()
       for (unsigned int k = j + 1; k < this->num_blades_per_chassis_; k++) {
         std::string id = "green_link_in_chassis_" + std::to_string(i % num_chassis_per_group_) + "_between_routers_" +
                          std::to_string(j) + "_and_" + std::to_string(k) + "_" + std::to_string(uniqueId);
-        this->createLink(id, this->num_links_green_, &linkup, &linkdown);
+        this->create_link(id, this->num_links_green_, &linkup, &linkdown);
 
         this->routers_[i * num_blades_per_chassis_ + j]->green_links_[k] = linkup;
         this->routers_[i * num_blades_per_chassis_ + k]->green_links_[j] = linkdown;
@@ -232,7 +233,7 @@ void DragonflyZone::generateLinks()
         for (unsigned int l = 0; l < this->num_blades_per_chassis_; l++) {
           std::string id = "black_link_in_group_" + std::to_string(i) + "_between_chassis_" + std::to_string(j) +
               "_and_" + std::to_string(k) +"_blade_" + std::to_string(l) + "_" + std::to_string(uniqueId);
-          this->createLink(id, this->num_links_black_, &linkup, &linkdown);
+          this->create_link(id, this->num_links_black_, &linkup, &linkdown);
 
           this->routers_[i * num_blades_per_chassis_ * num_chassis_per_group_ + j * num_blades_per_chassis_ + l]
               ->black_links_[k] = linkup;
@@ -255,7 +256,7 @@ void DragonflyZone::generateLinks()
       this->routers_[routernumj]->blue_links_ = new resource::LinkImpl*;
       std::string id = "blue_link_between_group_"+ std::to_string(i) +"_and_" + std::to_string(j) +"_routers_" +
           std::to_string(routernumi) + "_and_" + std::to_string(routernumj) + "_" + std::to_string(uniqueId);
-      this->createLink(id, this->num_links_blue_, &linkup, &linkdown);
+      this->create_link(id, this->num_links_blue_, &linkup, &linkdown);
 
       this->routers_[routernumi]->blue_links_[0] = linkup;
       this->routers_[routernumj]->blue_links_[0] = linkdown;
@@ -280,14 +281,14 @@ void DragonflyZone::get_local_route(NetPoint* src, NetPoint* dst, RouteCreationA
 
     route->link_list.push_back(info.first);
     if (latency)
-      *latency += info.first->latency();
+      *latency += info.first->get_latency();
     return;
   }
 
   unsigned int myCoords[4];
-  rankId_to_coords(src->id(), &myCoords);
+  rankId_to_coords(src->id(), myCoords);
   unsigned int targetCoords[4];
-  rankId_to_coords(dst->id(), &targetCoords);
+  rankId_to_coords(dst->id(), targetCoords);
   XBT_DEBUG("src : %u group, %u chassis, %u blade, %u node", myCoords[0], myCoords[1], myCoords[2], myCoords[3]);
   XBT_DEBUG("dst : %u group, %u chassis, %u blade, %u node", targetCoords[0], targetCoords[1], targetCoords[2],
             targetCoords[3]);
@@ -301,7 +302,7 @@ void DragonflyZone::get_local_route(NetPoint* src, NetPoint* dst, RouteCreationA
   // node->router local link
   route->link_list.push_back(myRouter->my_nodes_[myCoords[3] * num_links_per_link_]);
   if (latency)
-    *latency += myRouter->my_nodes_[myCoords[3] * num_links_per_link_]->latency();
+    *latency += myRouter->my_nodes_[myCoords[3] * num_links_per_link_]->get_latency();
 
   if (has_limiter_) { // limiter for sender
     std::pair<resource::LinkImpl*, resource::LinkImpl*> info = private_links_.at(node_pos_with_loopback(src->id()));
@@ -317,7 +318,7 @@ void DragonflyZone::get_local_route(NetPoint* src, NetPoint* dst, RouteCreationA
         // go to the nth router in our chassis
         route->link_list.push_back(currentRouter->green_links_[targetCoords[0]]);
         if (latency)
-          *latency += currentRouter->green_links_[targetCoords[0]]->latency();
+          *latency += currentRouter->green_links_[targetCoords[0]]->get_latency();
         currentRouter = routers_[myCoords[0] * (num_chassis_per_group_ * num_blades_per_chassis_) +
                                  myCoords[1] * num_blades_per_chassis_ + targetCoords[0]];
       }
@@ -326,14 +327,14 @@ void DragonflyZone::get_local_route(NetPoint* src, NetPoint* dst, RouteCreationA
         // go to the first chassis of our group
         route->link_list.push_back(currentRouter->black_links_[0]);
         if (latency)
-          *latency += currentRouter->black_links_[0]->latency();
+          *latency += currentRouter->black_links_[0]->get_latency();
         currentRouter = routers_[myCoords[0] * (num_chassis_per_group_ * num_blades_per_chassis_) + targetCoords[0]];
       }
 
       // go to destination group - the only optical hop
       route->link_list.push_back(currentRouter->blue_links_[0]);
       if (latency)
-        *latency += currentRouter->blue_links_[0]->latency();
+        *latency += currentRouter->blue_links_[0]->get_latency();
       currentRouter = routers_[targetCoords[0] * (num_chassis_per_group_ * num_blades_per_chassis_) + myCoords[0]];
     }
 
@@ -341,7 +342,7 @@ void DragonflyZone::get_local_route(NetPoint* src, NetPoint* dst, RouteCreationA
     if (targetRouter->blade_ != currentRouter->blade_) {
       route->link_list.push_back(currentRouter->green_links_[targetCoords[2]]);
       if (latency)
-        *latency += currentRouter->green_links_[targetCoords[2]]->latency();
+        *latency += currentRouter->green_links_[targetCoords[2]]->get_latency();
       currentRouter = routers_[targetCoords[0] * (num_chassis_per_group_ * num_blades_per_chassis_) + targetCoords[2]];
     }
 
@@ -349,7 +350,7 @@ void DragonflyZone::get_local_route(NetPoint* src, NetPoint* dst, RouteCreationA
     if (targetRouter->chassis_ != currentRouter->chassis_) {
       route->link_list.push_back(currentRouter->black_links_[targetCoords[1]]);
       if (latency)
-        *latency += currentRouter->black_links_[targetCoords[1]]->latency();
+        *latency += currentRouter->black_links_[targetCoords[1]]->get_latency();
     }
   }
 
@@ -361,7 +362,7 @@ void DragonflyZone::get_local_route(NetPoint* src, NetPoint* dst, RouteCreationA
   // router->node local link
   route->link_list.push_back(targetRouter->my_nodes_[targetCoords[3] * num_links_per_link_ + num_links_per_link_ - 1]);
   if (latency)
-    *latency += targetRouter->my_nodes_[targetCoords[3] * num_links_per_link_ + num_links_per_link_ - 1]->latency();
+    *latency += targetRouter->my_nodes_[targetCoords[3] * num_links_per_link_ + num_links_per_link_ - 1]->get_latency();
 }
 }
 }