X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/f21c3891971f5b45e2664c31a76ad526b076abfb..8d777265e12b0b9c5f13fecfc719474cdd214e9e:/src/surf/surf_routing_cluster_fat_tree.cpp

diff --git a/src/surf/surf_routing_cluster_fat_tree.cpp b/src/surf/surf_routing_cluster_fat_tree.cpp
index a1db45bbd2..041abb77bb 100644
--- a/src/surf/surf_routing_cluster_fat_tree.cpp
+++ b/src/surf/surf_routing_cluster_fat_tree.cpp
@@ -1,4 +1,13 @@
-#include "surf_routing_cluster_fat_tree.hpp"
+#include <cstdlib>
+
+#include <map>
+#include <string>
+#include <utility>
+#include <vector>
+#include <iostream>
+
+#include "src/surf/surf_routing_private.hpp"
+#include "src/surf/surf_routing_cluster_fat_tree.hpp"
 #include "xbt/lib.h"
 
 #include <boost/algorithm/string/split.hpp>
@@ -11,9 +20,12 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_route_fat_tree, surf, "Routing for fat tree
 
 AS_t model_fat_tree_cluster_create(void)
 {
-  return new AsClusterFatTree();
+  return new simgrid::surf::AsClusterFatTree();
 }
 
+namespace simgrid {
+namespace surf {
+
 AsClusterFatTree::AsClusterFatTree() : levels(0) {
   XBT_DEBUG("Creating a new fat tree.");
 }
@@ -22,6 +34,9 @@ AsClusterFatTree::~AsClusterFatTree() {
   for (unsigned int i = 0 ; i < this->nodes.size() ; i++) {
     delete this->nodes[i];
   }
+  for (unsigned int i = 0 ; i < this->links.size() ; i++) {
+    delete this->links[i];
+  }
 }
 
 bool AsClusterFatTree::isInSubTree(FatTreeNode *root, FatTreeNode *node) {
@@ -44,14 +59,17 @@ bool AsClusterFatTree::isInSubTree(FatTreeNode *root, FatTreeNode *node) {
   return true;
 }
 
-void AsClusterFatTree::getRouteAndLatency(RoutingEdgePtr src,
-                                          RoutingEdgePtr dst,
+void AsClusterFatTree::getRouteAndLatency(NetCard *src,
+                                          NetCard *dst,
                                           sg_platf_route_cbarg_t into,
                                           double *latency) {
   FatTreeNode *source, *destination, *currentNode;
-  std::vector<NetworkLink*> route;
+
   std::map<int, FatTreeNode*>::const_iterator tempIter;
+  
+if (dst->getRcType() == SURF_NETWORK_ELEMENT_ROUTER || src->getRcType() == SURF_NETWORK_ELEMENT_ROUTER) return;
 
+  /* Let's find the source and the destination in our internal structure */
   tempIter = this->computeNodes.find(src->getId());
 
   // xbt_die -> assert
@@ -63,14 +81,25 @@ void AsClusterFatTree::getRouteAndLatency(RoutingEdgePtr src,
   tempIter = this->computeNodes.find(dst->getId());
   if (tempIter == this->computeNodes.end()) {
     xbt_die("Could not find the destination %s [%d] in the fat tree",
-            src->getName(), src->getId());
+            dst->getName(), dst->getId());
   }
 
 
   destination = tempIter->second;
+  
   XBT_VERB("Get route and latency from '%s' [%d] to '%s' [%d] in a fat tree",
             src->getName(), src->getId(), dst->getName(), dst->getId());
 
+  /* In case destination is the source, and there is a loopback, let's get
+     through it instead of going up to a switch*/
+  if(source->id == destination->id && this->p_has_loopback) {
+    xbt_dynar_push_as(into->link_list, void*, source->loopback);
+    if(latency) {
+      *latency += source->loopback->getLatency();
+    }
+    return;
+  }
+
   currentNode = source;
 
   // up part
@@ -83,41 +112,41 @@ void AsClusterFatTree::getRouteAndLatency(RoutingEdgePtr src,
     }
     k = this->upperLevelNodesNumber[currentNode->level];
     d = d % k;
-    route.push_back(currentNode->parents[d]->upLink);
+    xbt_dynar_push_as(into->link_list, void*,currentNode->parents[d]->upLink);
 
     if(latency) {
       *latency += currentNode->parents[d]->upLink->getLatency();
     }
 
     if (this->p_has_limiter) {
-      route.push_back(currentNode->limiterLink);
+      xbt_dynar_push_as(into->link_list, void*,currentNode->limiterLink);
     }
     currentNode = currentNode->parents[d]->upNode;
   }
+
   XBT_DEBUG("%d(%u,%u) is in the sub tree of %d(%u,%u).", destination->id,
             destination->level, destination->position, currentNode->id,
             currentNode->level, currentNode->position);
+
   // Down part
   while(currentNode != destination) {
     for(unsigned int i = 0 ; i < currentNode->children.size() ; i++) {
       if(i % this->lowerLevelNodesNumber[currentNode->level - 1] ==
          destination->label[currentNode->level - 1]) {
-        route.push_back(currentNode->children[i]->downLink);
+        xbt_dynar_push_as(into->link_list, void*,currentNode->children[i]->downLink);
         if(latency) {
           *latency += currentNode->children[i]->downLink->getLatency();
         }
         currentNode = currentNode->children[i]->downNode;
+        if (this->p_has_limiter) {
+          xbt_dynar_push_as(into->link_list, void*,currentNode->limiterLink);
+        }
         XBT_DEBUG("%d(%u,%u) is accessible through %d(%u,%u)", destination->id,
                   destination->level, destination->position, currentNode->id,
                   currentNode->level, currentNode->position);
       }
     }
   }
-  
-  for (unsigned int i = 0 ; i < route.size() ; i++) {
-    xbt_dynar_push_as(into->link_list, void*, route[i]);
-  }
-
 }
 
 /* This function makes the assumption that parse_specific_arguments() and
@@ -271,9 +300,6 @@ void AsClusterFatTree::generateSwitches() {
   }
 
 
-  // If we have to many compute nodes, we ditch them
-  
-
   // We create the switches
   int k = 0;
   for (unsigned int i = 0 ; i < this->levels ; i++) {
@@ -386,12 +412,15 @@ void AsClusterFatTree::addLink(FatTreeNode *parent, unsigned int parentPort,
   child->parents[childPort] = newLink;
 
   this->links.push_back(newLink);
+
+  
+
 }
 
 void AsClusterFatTree::parse_specific_arguments(sg_platf_cluster_cbarg_t 
                                                 cluster) {
-  std::vector<string> parameters;
-  std::vector<string> tmp;
+  std::vector<std::string> parameters;
+  std::vector<std::string> tmp;
   boost::split(parameters, cluster->topo_parameters, boost::is_any_of(";"));
  
 
@@ -399,7 +428,6 @@ void AsClusterFatTree::parse_specific_arguments(sg_platf_cluster_cbarg_t
   if (parameters.size() != 4){
     surf_parse_error("Fat trees are defined by the levels number and 3 vectors" 
                      ", see the documentation for more informations");
-    // Well, there's no doc, yet
   }
 
   // The first parts of topo_parameters should be the levels number
@@ -439,12 +467,12 @@ void AsClusterFatTree::parse_specific_arguments(sg_platf_cluster_cbarg_t
 }
 
 
-void AsClusterFatTree::generateDotFile(const string& filename) const {
-  ofstream file;
+void AsClusterFatTree::generateDotFile(const std::string& filename) const {
+  std::ofstream file;
   /* Maybe should we get directly a char*, as open takes strings only beginning
    * with C++11...
    */
-  file.open(filename.c_str(), ios::out | ios::trunc); 
+  file.open(filename.c_str(), std::ios::out | std::ios::trunc); 
   
   if(file.is_open()) {
     file << "graph AsClusterFatTree {\n";
@@ -476,31 +504,27 @@ void AsClusterFatTree::generateDotFile(const string& filename) const {
 FatTreeNode::FatTreeNode(sg_platf_cluster_cbarg_t cluster, int id, int level,
                          int position) : id(id), level(level),
                                          position(position) {
-  s_sg_platf_link_cbarg_t linkTemplate;
+  s_sg_platf_link_cbarg_t linkTemplate = SG_PLATF_LINK_INITIALIZER;
   if(cluster->limiter_link) {
     memset(&linkTemplate, 0, sizeof(linkTemplate));
     linkTemplate.bandwidth = cluster->limiter_link;
     linkTemplate.latency = 0;
-    linkTemplate.state = SURF_RESOURCE_ON;
+    linkTemplate.initiallyOn = 1;
     linkTemplate.policy = SURF_LINK_SHARED;
     linkTemplate.id = bprintf("limiter_%d", id);
     sg_platf_new_link(&linkTemplate);
-    this->limiterLink = (NetworkLink*) xbt_lib_get_or_null(link_lib,
-                                                           linkTemplate.id,
-                                                           SURF_LINK_LEVEL);
+    this->limiterLink = Link::byName(linkTemplate.id);
     free((void*)linkTemplate.id);
   }
   if(cluster->loopback_bw || cluster->loopback_lat) {
     memset(&linkTemplate, 0, sizeof(linkTemplate));
     linkTemplate.bandwidth = cluster->loopback_bw;
     linkTemplate.latency = cluster->loopback_lat;
-    linkTemplate.state = SURF_RESOURCE_ON;
+    linkTemplate.initiallyOn = 1;
     linkTemplate.policy = SURF_LINK_FATPIPE;
     linkTemplate.id = bprintf("loopback_%d", id);
     sg_platf_new_link(&linkTemplate);
-    this->loopback = (NetworkLink*) xbt_lib_get_or_null(link_lib,
-                                                        linkTemplate.id,
-                                                        SURF_LINK_LEVEL);
+    this->loopback = Link::byName(linkTemplate.id);
     free((void*)linkTemplate.id);
   }  
 }
@@ -510,33 +534,33 @@ FatTreeLink::FatTreeLink(sg_platf_cluster_cbarg_t cluster,
                          FatTreeNode *upNode) : upNode(upNode),
                                                 downNode(downNode) {
   static int uniqueId = 0;
-  s_sg_platf_link_cbarg_t linkTemplate;
+  s_sg_platf_link_cbarg_t linkTemplate = SG_PLATF_LINK_INITIALIZER;
   memset(&linkTemplate, 0, sizeof(linkTemplate));
   linkTemplate.bandwidth = cluster->bw;
   linkTemplate.latency = cluster->lat;
-  linkTemplate.state = SURF_RESOURCE_ON;
+  linkTemplate.initiallyOn = 1;
   linkTemplate.policy = cluster->sharing_policy; // sthg to do with that ?
   linkTemplate.id = bprintf("link_from_%d_to_%d_%d", downNode->id, upNode->id,
                             uniqueId);
   sg_platf_new_link(&linkTemplate);
-  NetworkLink* link;
+  Link* link;
   std::string tmpID;
   if (cluster->sharing_policy == SURF_LINK_FULLDUPLEX) {
     tmpID = std::string(linkTemplate.id) + "_UP";
-    link = (NetworkLink*) xbt_lib_get_or_null(link_lib, tmpID.c_str(),
-                                              SURF_LINK_LEVEL);
+    link =  Link::byName(tmpID.c_str());
     this->upLink = link; // check link?
     tmpID = std::string(linkTemplate.id) + "_DOWN";
-    link = (NetworkLink*) xbt_lib_get_or_null(link_lib, tmpID.c_str(),
-                                              SURF_LINK_LEVEL);
+    link = Link::byName(tmpID.c_str());
     this->downLink = link; // check link ?
   }
   else {
-    link = (NetworkLink*) xbt_lib_get_or_null(link_lib, linkTemplate.id,
-                                              SURF_LINK_LEVEL);
+    link = Link::byName(linkTemplate.id);
     this->upLink = link;
     this->downLink = link;
   }
   uniqueId++;
   free((void*)linkTemplate.id);
 }
+
+}
+}