-#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>
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.");
}
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) {
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
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
}
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
}
- // 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++) {
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(";"));
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
}
-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";
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);
}
}
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);
}
+
+}
+}