X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/a18117755285a374ec3d5830309c924f2830e3ba..de57b34916659892d2dc26edabf552253afe2c18:/src/kernel/routing/FatTreeZone.cpp diff --git a/src/kernel/routing/FatTreeZone.cpp b/src/kernel/routing/FatTreeZone.cpp index 97c57d3bcc..e8732f1e11 100644 --- a/src/kernel/routing/FatTreeZone.cpp +++ b/src/kernel/routing/FatTreeZone.cpp @@ -1,17 +1,16 @@ -/* Copyright (c) 2014-2016. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2014-2017. The SimGrid Team. All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include +#include #include "src/kernel/routing/FatTreeZone.hpp" -#include "src/kernel/routing/NetCard.hpp" +#include "src/kernel/routing/NetPoint.hpp" #include "src/surf/network_interface.hpp" -#include "xbt/lib.h" - #include #include @@ -21,12 +20,12 @@ namespace simgrid { namespace kernel { namespace routing { -AsClusterFatTree::AsClusterFatTree(As* father, const char* name) : AsCluster(father, name) +FatTreeZone::FatTreeZone(NetZone* father, std::string name) : ClusterZone(father, name) { XBT_DEBUG("Creating a new fat tree."); } -AsClusterFatTree::~AsClusterFatTree() +FatTreeZone::~FatTreeZone() { for (unsigned int i = 0; i < this->nodes_.size(); i++) { delete this->nodes_[i]; @@ -36,7 +35,7 @@ AsClusterFatTree::~AsClusterFatTree() } } -bool AsClusterFatTree::isInSubTree(FatTreeNode* root, FatTreeNode* node) +bool FatTreeZone::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); @@ -57,7 +56,7 @@ bool AsClusterFatTree::isInSubTree(FatTreeNode* root, FatTreeNode* node) return true; } -void AsClusterFatTree::getLocalRoute(NetCard* src, NetCard* dst, sg_platf_route_cbarg_t into, double* latency) +void FatTreeZone::getLocalRoute(NetPoint* src, NetPoint* dst, RouteCreationArgs* into, double* latency) { if (dst->isRouter() || src->isRouter()) @@ -65,21 +64,21 @@ void AsClusterFatTree::getLocalRoute(NetCard* src, NetCard* dst, sg_platf_route_ /* Let's find the source and the destination in our internal structure */ auto searchedNode = this->computeNodes_.find(src->id()); - xbt_assert(searchedNode != this->computeNodes_.end(), "Could not find the source %s [%d] in the fat tree", - src->name().c_str(), src->id()); + xbt_assert(searchedNode != this->computeNodes_.end(), "Could not find the source %s [%u] in the fat tree", + src->getCname(), src->id()); FatTreeNode* source = searchedNode->second; searchedNode = this->computeNodes_.find(dst->id()); - xbt_assert(searchedNode != this->computeNodes_.end(), "Could not find the destination %s [%d] in the fat tree", - dst->name().c_str(), dst->id()); + xbt_assert(searchedNode != this->computeNodes_.end(), "Could not find the destination %s [%u] in the fat tree", + dst->getCname(), dst->id()); FatTreeNode* destination = searchedNode->second; - XBT_VERB("Get route and latency from '%s' [%d] to '%s' [%d] in a fat tree", src->name().c_str(), src->id(), - dst->name().c_str(), dst->id()); + XBT_VERB("Get route and latency from '%s' [%u] to '%s' [%u] in a fat tree", src->getCname(), src->id(), + dst->getCname(), dst->id()); /* In case destination is the source, and there is a loopback, let's use it instead of going up to a switch */ if (source->id == destination->id && this->hasLoopback_) { - into->link_list->push_back(source->loopback); + into->link_list.push_back(source->loopback); if (latency) *latency += source->loopback->latency(); return; @@ -88,7 +87,7 @@ void AsClusterFatTree::getLocalRoute(NetCard* src, NetCard* dst, sg_platf_route_ FatTreeNode* currentNode = source; // up part - while (!isInSubTree(currentNode, destination)) { + while (not isInSubTree(currentNode, destination)) { int d = destination->position; // as in d-mod-k for (unsigned int i = 0; i < currentNode->level; i++) @@ -96,13 +95,13 @@ void AsClusterFatTree::getLocalRoute(NetCard* src, NetCard* dst, sg_platf_route_ int k = this->upperLevelNodesNumber_[currentNode->level]; d = d % k; - into->link_list->push_back(currentNode->parents[d]->upLink); + into->link_list.push_back(currentNode->parents[d]->upLink); if (latency) *latency += currentNode->parents[d]->upLink->latency(); if (this->hasLimiter_) - into->link_list->push_back(currentNode->limiterLink); + into->link_list.push_back(currentNode->limiterLink); currentNode = currentNode->parents[d]->upNode; } @@ -113,12 +112,12 @@ void AsClusterFatTree::getLocalRoute(NetCard* src, NetCard* dst, sg_platf_route_ 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]) { - into->link_list->push_back(currentNode->children[i]->downLink); + into->link_list.push_back(currentNode->children[i]->downLink); if (latency) *latency += currentNode->children[i]->downLink->latency(); currentNode = currentNode->children[i]->downNode; if (this->hasLimiter_) - into->link_list->push_back(currentNode->limiterLink); + into->link_list.push_back(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); } @@ -129,7 +128,7 @@ void AsClusterFatTree::getLocalRoute(NetCard* src, NetCard* dst, sg_platf_route_ /* This function makes the assumption that parse_specific_arguments() and * addNodes() have already been called */ -void AsClusterFatTree::seal() +void FatTreeZone::seal() { if (this->levels_ == 0) { return; @@ -175,7 +174,7 @@ void AsClusterFatTree::seal() } } -int AsClusterFatTree::connectNodeToParents(FatTreeNode* node) +int FatTreeZone::connectNodeToParents(FatTreeNode* node) { std::vector::iterator currentParentNode = this->nodes_.begin(); int connectionsNumber = 0; @@ -199,7 +198,7 @@ int AsClusterFatTree::connectNodeToParents(FatTreeNode* node) return connectionsNumber; } -bool AsClusterFatTree::areRelated(FatTreeNode* parent, FatTreeNode* child) +bool FatTreeZone::areRelated(FatTreeNode* parent, FatTreeNode* child) { std::stringstream msgBuffer; @@ -231,11 +230,10 @@ bool AsClusterFatTree::areRelated(FatTreeNode* parent, FatTreeNode* child) return true; } -void AsClusterFatTree::generateSwitches() +void FatTreeZone::generateSwitches() { XBT_DEBUG("Generating switches."); this->nodesByLevel_.resize(this->levels_ + 1, 0); - unsigned int nodesRequired = 0; // Take care of the number of nodes by level this->nodesByLevel_[0] = 1; @@ -243,9 +241,9 @@ void AsClusterFatTree::generateSwitches() this->nodesByLevel_[0] *= this->lowerLevelNodesNumber_[i]; if (this->nodesByLevel_[0] != this->nodes_.size()) { - surf_parse_error("The number of provided nodes does not fit with the wanted topology." - " Please check your platform description (We need %d nodes, we got %zu)", - this->nodesByLevel_[0], this->nodes_.size()); + surf_parse_error(std::string("The number of provided nodes does not fit with the wanted topology.") + + " Please check your platform description (We need " + std::to_string(this->nodesByLevel_[0]) + + "nodes, we got " + std::to_string(this->nodes_.size())); return; } @@ -259,7 +257,6 @@ void AsClusterFatTree::generateSwitches() nodesInThisLevel *= this->lowerLevelNodesNumber_[j]; this->nodesByLevel_[i + 1] = nodesInThisLevel; - nodesRequired += nodesInThisLevel; } // Create the switches @@ -267,7 +264,7 @@ void AsClusterFatTree::generateSwitches() for (unsigned int i = 0; i < this->levels_; i++) { for (unsigned int j = 0; j < this->nodesByLevel_[i + 1]; j++) { FatTreeNode* newNode = new FatTreeNode(this->cluster_, --k, i + 1, j); - XBT_DEBUG("We create the switch %d(%d,%d)", newNode->id, newNode->level, newNode->position); + XBT_DEBUG("We create the switch %d(%u,%u)", 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]); @@ -278,7 +275,7 @@ void AsClusterFatTree::generateSwitches() } } -void AsClusterFatTree::generateLabels() +void FatTreeZone::generateLabels() { XBT_DEBUG("Generating labels."); // TODO : check if nodesByLevel and nodes are filled @@ -324,7 +321,7 @@ void AsClusterFatTree::generateLabels() } } -int AsClusterFatTree::getLevelPosition(const unsigned int level) +int FatTreeZone::getLevelPosition(const unsigned int level) { xbt_assert(level <= this->levels_, "The impossible did happen. Yet again."); int tempPosition = 0; @@ -335,7 +332,7 @@ int AsClusterFatTree::getLevelPosition(const unsigned int level) return tempPosition; } -void AsClusterFatTree::addProcessingNode(int id) +void FatTreeZone::addProcessingNode(int id) { using std::make_pair; static int position = 0; @@ -347,11 +344,11 @@ void AsClusterFatTree::addProcessingNode(int id) this->nodes_.push_back(newNode); } -void AsClusterFatTree::addLink(FatTreeNode* parent, unsigned int parentPort, FatTreeNode* child, unsigned int childPort) +void FatTreeZone::addLink(FatTreeNode* parent, unsigned int parentPort, FatTreeNode* child, unsigned int childPort) { FatTreeLink* newLink; 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, + XBT_DEBUG("Creating a link between the parent (%u,%u,%u) and the child (%u,%u,%u)", parent->level, parent->position, parentPort, child->level, child->position, childPort); parent->children[parentPort] = newLink; child->parents[childPort] = newLink; @@ -359,54 +356,67 @@ void AsClusterFatTree::addLink(FatTreeNode* parent, unsigned int parentPort, Fat this->links_.push_back(newLink); } -void AsClusterFatTree::parse_specific_arguments(sg_platf_cluster_cbarg_t cluster) +void FatTreeZone::parse_specific_arguments(ClusterCreationArgs* cluster) { std::vector parameters; std::vector tmp; boost::split(parameters, cluster->topo_parameters, boost::is_any_of(";")); + const std::string error_msg {"Fat trees are defined by the levels number and 3 vectors, see the documentation for more information"}; // TODO : we have to check for zeros and negative numbers, or it might crash if (parameters.size() != 4) { - surf_parse_error( - "Fat trees are defined by the levels number and 3 vectors, see the documentation for more information"); + surf_parse_error(error_msg); } // The first parts of topo_parameters should be the levels number - this->levels_ = xbt_str_parse_int(parameters[0].c_str(), "First parameter is not the amount of levels: %s"); + try { + this->levels_ = std::stoi(parameters[0]); + } catch (std::invalid_argument& ia) { + throw std::invalid_argument(std::string("First parameter is not the amount of levels:") + parameters[0]); + } // Then, a l-sized vector standing for the children number by level boost::split(tmp, parameters[1], boost::is_any_of(",")); if (tmp.size() != this->levels_) { - surf_parse_error("Fat trees are defined by the levels number and 3 vectors" - ", see the documentation for more information"); + surf_parse_error(error_msg); } for (size_t i = 0; i < tmp.size(); i++) { - this->lowerLevelNodesNumber_.push_back(xbt_str_parse_int(tmp[i].c_str(), "Invalid lower level node number: %s")); + try { + this->lowerLevelNodesNumber_.push_back(std::stoi(tmp[i])); + } catch (std::invalid_argument& ia) { + throw std::invalid_argument(std::string("Invalid lower level node number:") + tmp[i]); + } } // Then, a l-sized vector standing for the parents number by level boost::split(tmp, parameters[2], boost::is_any_of(",")); if (tmp.size() != this->levels_) { - surf_parse_error("Fat trees are defined by the levels number and 3 vectors" - ", see the documentation for more information"); + surf_parse_error(error_msg); } for (size_t i = 0; i < tmp.size(); i++) { - this->upperLevelNodesNumber_.push_back(xbt_str_parse_int(tmp[i].c_str(), "Invalid upper level node number: %s")); + try { + this->upperLevelNodesNumber_.push_back(std::stoi(tmp[i])); + } catch (std::invalid_argument& ia) { + throw std::invalid_argument(std::string("Invalid upper level node number:") + tmp[i]); + } } // Finally, a l-sized vector standing for the ports number with the lower level boost::split(tmp, parameters[3], boost::is_any_of(",")); if (tmp.size() != this->levels_) { - surf_parse_error("Fat trees are defined by the levels number and 3 vectors" - ", see the documentation for more information"); + surf_parse_error(error_msg); } for (size_t i = 0; i < tmp.size(); i++) { - this->lowerLevelPortsNumber_.push_back(xbt_str_parse_int(tmp[i].c_str(), "Invalid lower level node number: %s")); + try { + this->lowerLevelPortsNumber_.push_back(std::stoi(tmp[i])); + } catch (std::invalid_argument& ia) { + throw std::invalid_argument(std::string("Invalid lower level port number:") + tmp[i]); + } } this->cluster_ = cluster; } -void AsClusterFatTree::generateDotFile(const std::string& filename) const +void FatTreeZone::generateDotFile(const std::string& filename) const { std::ofstream file; file.open(filename, std::ios::out | std::ios::trunc); @@ -428,59 +438,50 @@ void AsClusterFatTree::generateDotFile(const std::string& filename) const file.close(); } -FatTreeNode::FatTreeNode(sg_platf_cluster_cbarg_t cluster, int id, int level, int position) +FatTreeNode::FatTreeNode(ClusterCreationArgs* cluster, int id, int level, int position) : id(id), level(level), position(position) { - s_sg_platf_link_cbarg_t linkTemplate; + LinkCreationArgs linkTemplate; if (cluster->limiter_link) { - memset(&linkTemplate, 0, sizeof(linkTemplate)); linkTemplate.bandwidth = cluster->limiter_link; linkTemplate.latency = 0; linkTemplate.policy = SURF_LINK_SHARED; - linkTemplate.id = bprintf("limiter_%d", id); + linkTemplate.id = "limiter_"+std::to_string(id); sg_platf_new_link(&linkTemplate); - this->limiterLink = Link::byName(linkTemplate.id); - free((void*)linkTemplate.id); + this->limiterLink = surf::LinkImpl::byName(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.policy = SURF_LINK_FATPIPE; - linkTemplate.id = bprintf("loopback_%d", id); + linkTemplate.id = "loopback_"+ std::to_string(id); sg_platf_new_link(&linkTemplate); - this->loopback = Link::byName(linkTemplate.id); - free((void*)linkTemplate.id); + this->loopback = surf::LinkImpl::byName(linkTemplate.id); } } -FatTreeLink::FatTreeLink(sg_platf_cluster_cbarg_t cluster, FatTreeNode* downNode, FatTreeNode* upNode) +FatTreeLink::FatTreeLink(ClusterCreationArgs* cluster, FatTreeNode* downNode, FatTreeNode* upNode) : upNode(upNode), downNode(downNode) { static int uniqueId = 0; - s_sg_platf_link_cbarg_t linkTemplate; - memset(&linkTemplate, 0, sizeof(linkTemplate)); + LinkCreationArgs linkTemplate; linkTemplate.bandwidth = cluster->bw; linkTemplate.latency = cluster->lat; linkTemplate.policy = cluster->sharing_policy; // sthg to do with that ? - linkTemplate.id = bprintf("link_from_%d_to_%d_%d", downNode->id, upNode->id, uniqueId); + linkTemplate.id = + "link_from_" + std::to_string(downNode->id) + "_" + std::to_string(upNode->id) + "_" + std::to_string(uniqueId); sg_platf_new_link(&linkTemplate); - Link* link; - std::string tmpID; - if (cluster->sharing_policy == SURF_LINK_FULLDUPLEX) { - tmpID = std::string(linkTemplate.id) + "_UP"; - link = Link::byName(tmpID.c_str()); - this->upLink = link; // check link? + + if (cluster->sharing_policy == SURF_LINK_SPLITDUPLEX) { + std::string tmpID = std::string(linkTemplate.id) + "_UP"; + this->upLink = surf::LinkImpl::byName(tmpID); // check link? tmpID = std::string(linkTemplate.id) + "_DOWN"; - link = Link::byName(tmpID.c_str()); - this->downLink = link; // check link ? + this->downLink = surf::LinkImpl::byName(tmpID); // check link ? } else { - link = Link::byName(linkTemplate.id); - this->upLink = link; - this->downLink = link; + this->upLink = surf::LinkImpl::byName(linkTemplate.id); + this->downLink = this->upLink; } uniqueId++; - free((void*)linkTemplate.id); } } }