X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/5b2ffa67d0e82b06951b2619815db43bacfdb1f3..dad398b4437e937d222bafff987814b8f2d80409:/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 b2697d103d..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 + +#include +#include +#include +#include +#include + +#include "src/surf/surf_routing_private.hpp" +#include "src/surf/surf_routing_cluster_fat_tree.hpp" #include "xbt/lib.h" #include @@ -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,10 +34,14 @@ 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) { - XBT_DEBUG("Is %d(%u,%u) in the sub tree of %d(%u,%u) ?", node->id, node->level, node->position, root->id, root->level, root->position); + XBT_DEBUG("Is %d(%u,%u) in the sub tree of %d(%u,%u) ?", node->id, + node->level, node->position, root->id, root->level, root->position); if (root->level <= node->level) { return false; } @@ -43,30 +59,47 @@ 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 route; + std::map::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 if (tempIter == this->computeNodes.end()) { - xbt_die("Could not find the source %s [%d] in the fat tree", src->getName(), src->getId()); + xbt_die("Could not find the source %s [%d] in the fat tree", src->getName(), + src->getId()); } source = tempIter->second; tempIter = this->computeNodes.find(dst->getId()); if (tempIter == this->computeNodes.end()) { - xbt_die("Could not find the destination %s [%d] in the fat tree", dst->getName(), dst->getId()); + xbt_die("Could not find the destination %s [%d] in the fat tree", + dst->getName(), dst->getId()); } destination = tempIter->second; - XBT_DEBUG("Get route and latency from '%s' [%d] to '%s' [%d] in a fat tree", + + 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 @@ -79,39 +112,47 @@ 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) { + 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); + + 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; - XBT_DEBUG("%d(%u,%u) is accessible through %d(%u,%u)", destination->id, destination->level, destination->position, currentNode->id, currentNode->level, currentNode->position); + 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 * addNodes() have already been called */ -void AsClusterFatTree::create_links(sg_platf_cluster_cbarg_t cluster){ +void AsClusterFatTree::create_links(){ if(this->levels == 0) { return; } @@ -144,7 +185,7 @@ void AsClusterFatTree::create_links(sg_platf_cluster_cbarg_t cluster){ // Nodes are totally ordered, by level and then by position, in this->nodes for (unsigned int i = 0 ; i < this->levels ; i++) { for (unsigned int j = 0 ; j < this->nodesByLevel[i] ; j++) { - this->connectNodeToParents(cluster, this->nodes[k]); + this->connectNodeToParents(this->nodes[k]); k++; } } @@ -162,8 +203,7 @@ void AsClusterFatTree::create_links(sg_platf_cluster_cbarg_t cluster){ } -int AsClusterFatTree::connectNodeToParents(sg_platf_cluster_cbarg_t cluster, - FatTreeNode *node) { +int AsClusterFatTree::connectNodeToParents(FatTreeNode *node) { std::vector::iterator currentParentNode = this->nodes.begin(); int connectionsNumber = 0; const int level = node->level; @@ -177,7 +217,7 @@ int AsClusterFatTree::connectNodeToParents(sg_platf_cluster_cbarg_t cluster, node->level, node->position, (*currentParentNode)->id, (*currentParentNode)->level, (*currentParentNode)->position, this->lowerLevelPortsNumber[level]); for (unsigned int j = 0 ; j < this->lowerLevelPortsNumber[level] ; j++) { - this->addLink(cluster, *currentParentNode, node->label[level] + + this->addLink(*currentParentNode, node->label[level] + j * this->lowerLevelNodesNumber[level], node, (*currentParentNode)->label[level] + j * this->upperLevelNodesNumber[level]); @@ -260,20 +300,19 @@ 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++) { for (unsigned int j = 0 ; j < this->nodesByLevel[i + 1] ; j++) { FatTreeNode* newNode; - newNode = new FatTreeNode(--k, i + 1, j); - XBT_DEBUG("We create the switch %d(%d,%d)", newNode->id, newNode->level, newNode->position); + newNode = new FatTreeNode(this->cluster, --k, i + 1, j); + XBT_DEBUG("We create the switch %d(%d,%d)", newNode->id, newNode->level, + newNode->position); newNode->children.resize(this->lowerLevelNodesNumber[i] * this->lowerLevelPortsNumber[i]); if (i != this->levels - 1) { - newNode->parents.resize(this->upperLevelNodesNumber[i + 1] * this->lowerLevelPortsNumber[i + 1]); + newNode->parents.resize(this->upperLevelNodesNumber[i + 1] * + this->lowerLevelPortsNumber[i + 1]); } newNode->label.resize(this->levels); this->nodes.push_back(newNode); @@ -354,18 +393,18 @@ void AsClusterFatTree::addProcessingNode(int id) { using std::make_pair; static int position = 0; FatTreeNode* newNode; - newNode = new FatTreeNode(id, 0, position++); - newNode->parents.resize(this->upperLevelNodesNumber[0] * this->lowerLevelPortsNumber[0]); + newNode = new FatTreeNode(this->cluster, id, 0, position++); + newNode->parents.resize(this->upperLevelNodesNumber[0] * + this->lowerLevelPortsNumber[0]); newNode->label.resize(this->levels); this->computeNodes.insert(make_pair(id,newNode)); this->nodes.push_back(newNode); } -void AsClusterFatTree::addLink(sg_platf_cluster_cbarg_t cluster, - FatTreeNode *parent, unsigned int parentPort, +void AsClusterFatTree::addLink(FatTreeNode *parent, unsigned int parentPort, FatTreeNode *child, unsigned int childPort) { FatTreeLink *newLink; - newLink = new FatTreeLink(cluster, child, parent); + newLink = new FatTreeLink(this->cluster, child, parent); XBT_DEBUG("Creating a link between the parent (%d,%d,%u)" " and the child (%d,%d,%u)", parent->level, parent->position, parentPort, child->level, child->position, childPort); @@ -380,8 +419,8 @@ void AsClusterFatTree::addLink(sg_platf_cluster_cbarg_t cluster, void AsClusterFatTree::parse_specific_arguments(sg_platf_cluster_cbarg_t cluster) { - std::vector parameters; - std::vector tmp; + std::vector parameters; + std::vector tmp; boost::split(parameters, cluster->topo_parameters, boost::is_any_of(";")); @@ -389,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 @@ -425,15 +463,16 @@ void AsClusterFatTree::parse_specific_arguments(sg_platf_cluster_cbarg_t for(size_t i = 0 ; i < tmp.size() ; i++){ this->lowerLevelPortsNumber.push_back(std::atoi(tmp[i].c_str())); } + this->cluster = cluster; } -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"; @@ -457,42 +496,71 @@ void AsClusterFatTree::generateDotFile(const string& filename) const { file.close(); } else { - std::cerr << "Unable to open file " << filename << std::endl; + XBT_DEBUG("Unable to open file %s", filename.c_str()); return; } } -FatTreeNode::FatTreeNode(int id, int level, int position) : id(id), - level(level), - position(position){} +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 = SG_PLATF_LINK_INITIALIZER; + if(cluster->limiter_link) { + memset(&linkTemplate, 0, sizeof(linkTemplate)); + linkTemplate.bandwidth = cluster->limiter_link; + linkTemplate.latency = 0; + linkTemplate.initiallyOn = 1; + linkTemplate.policy = SURF_LINK_SHARED; + linkTemplate.id = bprintf("limiter_%d", id); + sg_platf_new_link(&linkTemplate); + 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.initiallyOn = 1; + linkTemplate.policy = SURF_LINK_FATPIPE; + linkTemplate.id = bprintf("loopback_%d", id); + sg_platf_new_link(&linkTemplate); + this->loopback = Link::byName(linkTemplate.id); + free((void*)linkTemplate.id); + } +} -FatTreeLink::FatTreeLink(sg_platf_cluster_cbarg_t cluster, FatTreeNode *downNode, +FatTreeLink::FatTreeLink(sg_platf_cluster_cbarg_t cluster, + FatTreeNode *downNode, 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.policy = cluster->sharing_policy; // Maybe should we do sthg with that ? - linkTemplate.id = bprintf("link_from_%d_to_%d_%d", downNode->id, upNode->id, uniqueId); + 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) { - std::string tmpID; 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); +} + +} }