-/* Copyright (c) 2014-2018. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2014-2019. 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. */
namespace kernel {
namespace routing {
-FatTreeZone::FatTreeZone(NetZone* father, std::string name) : ClusterZone(father, name)
+FatTreeZone::FatTreeZone(NetZoneImpl* father, const std::string& name, resource::NetworkModel* netmodel)
+ : ClusterZone(father, name, netmodel)
{
XBT_DEBUG("Creating a new fat tree.");
}
}
}
-bool FatTreeZone::isInSubTree(FatTreeNode* root, FatTreeNode* node)
+bool FatTreeZone::is_in_sub_tree(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);
return true;
}
-void FatTreeZone::getLocalRoute(NetPoint* src, NetPoint* dst, RouteCreationArgs* into, double* latency)
+void FatTreeZone::get_local_route(NetPoint* src, NetPoint* dst, RouteCreationArgs* into, double* latency)
{
- if (dst->isRouter() || src->isRouter())
+ if (dst->is_router() || src->is_router())
return;
/* Let's find the source and the destination in our internal structure */
auto searchedNode = this->compute_nodes_.find(src->id());
xbt_assert(searchedNode != this->compute_nodes_.end(), "Could not find the source %s [%u] in the fat tree",
- src->getCname(), src->id());
+ src->get_cname(), src->id());
FatTreeNode* source = searchedNode->second;
searchedNode = this->compute_nodes_.find(dst->id());
xbt_assert(searchedNode != this->compute_nodes_.end(), "Could not find the destination %s [%u] in the fat tree",
- dst->getCname(), dst->id());
+ dst->get_cname(), dst->id());
FatTreeNode* destination = searchedNode->second;
- XBT_VERB("Get route and latency from '%s' [%u] to '%s' [%u] in a fat tree", src->getCname(), src->id(),
- dst->getCname(), dst->id());
+ XBT_VERB("Get route and latency from '%s' [%u] to '%s' [%u] in a fat tree", src->get_cname(), src->id(),
+ dst->get_cname(), 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->has_loopback_) {
into->link_list.push_back(source->loopback);
if (latency)
- *latency += source->loopback->latency();
+ *latency += source->loopback->get_latency();
return;
}
FatTreeNode* currentNode = source;
// up part
- while (not isInSubTree(currentNode, destination)) {
+ while (not is_in_sub_tree(currentNode, destination)) {
int d = destination->position; // as in d-mod-k
for (unsigned int i = 0; i < currentNode->level; i++)
- d /= this->upperLevelNodesNumber_[i];
+ d /= this->num_parents_per_node_[i];
- int k = this->upperLevelNodesNumber_[currentNode->level];
+ int k = this->num_parents_per_node_[currentNode->level];
d = d % k;
into->link_list.push_back(currentNode->parents[d]->up_link_);
if (latency)
- *latency += currentNode->parents[d]->up_link_->latency();
+ *latency += currentNode->parents[d]->up_link_->get_latency();
if (this->has_limiter_)
into->link_list.push_back(currentNode->limiter_link_);
// 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]) {
+ if (i % this->num_children_per_node_[currentNode->level - 1] == destination->label[currentNode->level - 1]) {
into->link_list.push_back(currentNode->children[i]->down_link_);
if (latency)
- *latency += currentNode->children[i]->down_link_->latency();
+ *latency += currentNode->children[i]->down_link_->get_latency();
currentNode = currentNode->children[i]->down_node_;
if (this->has_limiter_)
into->link_list.push_back(currentNode->limiter_link_);
if (this->levels_ == 0) {
return;
}
- this->generateSwitches();
+ this->generate_switches();
if (XBT_LOG_ISENABLED(surf_route_fat_tree, xbt_log_priority_debug)) {
std::stringstream msgBuffer;
msgBuffer << "We are creating a fat tree of " << this->levels_ << " levels "
- << "with " << this->nodesByLevel_[0] << " processing nodes";
+ << "with " << this->nodes_by_level_[0] << " processing nodes";
for (unsigned int i = 1; i <= this->levels_; i++) {
- msgBuffer << ", " << this->nodesByLevel_[i] << " switches at level " << i;
+ msgBuffer << ", " << this->nodes_by_level_[i] << " switches at level " << i;
}
XBT_DEBUG("%s", msgBuffer.str().c_str());
msgBuffer.str("");
XBT_DEBUG("%s", msgBuffer.str().c_str());
}
- this->generateLabels();
+ this->generate_labels();
unsigned int k = 0;
// 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(this->nodes_[k]);
+ for (unsigned int j = 0; j < this->nodes_by_level_[i]; j++) {
+ this->connect_node_to_parents(this->nodes_[k]);
k++;
}
}
}
}
-int FatTreeZone::connectNodeToParents(FatTreeNode* node)
+int FatTreeZone::connect_node_to_parents(FatTreeNode* node)
{
std::vector<FatTreeNode*>::iterator currentParentNode = this->nodes_.begin();
int connectionsNumber = 0;
const int level = node->level;
XBT_DEBUG("We are connecting node %d(%u,%u) to his parents.", node->id, node->level, node->position);
- currentParentNode += this->getLevelPosition(level + 1);
- for (unsigned int i = 0; i < this->nodesByLevel_[level + 1]; i++) {
- if (this->areRelated(*currentParentNode, node)) {
+ currentParentNode += this->get_level_position(level + 1);
+ for (unsigned int i = 0; i < this->nodes_by_level_[level + 1]; i++) {
+ if (this->are_related(*currentParentNode, node)) {
XBT_DEBUG("%d(%u,%u) and %d(%u,%u) are related,"
" with %u links between them.",
node->id, 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(*currentParentNode, node->label[level] + j * this->lowerLevelNodesNumber_[level], node,
- (*currentParentNode)->label[level] + j * this->upperLevelNodesNumber_[level]);
+ (*currentParentNode)->position, this->num_port_lower_level_[level]);
+ for (unsigned int j = 0; j < this->num_port_lower_level_[level]; j++) {
+ this->add_link(*currentParentNode, node->label[level] + j * this->num_children_per_node_[level], node,
+ (*currentParentNode)->label[level] + j * this->num_parents_per_node_[level]);
}
connectionsNumber++;
}
return connectionsNumber;
}
-bool FatTreeZone::areRelated(FatTreeNode* parent, FatTreeNode* child)
+bool FatTreeZone::are_related(FatTreeNode* parent, FatTreeNode* child)
{
std::stringstream msgBuffer;
return true;
}
-void FatTreeZone::generateSwitches()
+void FatTreeZone::generate_switches()
{
XBT_DEBUG("Generating switches.");
- this->nodesByLevel_.resize(this->levels_ + 1, 0);
+ this->nodes_by_level_.resize(this->levels_ + 1, 0);
// Take care of the number of nodes by level
- this->nodesByLevel_[0] = 1;
+ this->nodes_by_level_[0] = 1;
for (unsigned int i = 0; i < this->levels_; i++)
- this->nodesByLevel_[0] *= this->lowerLevelNodesNumber_[i];
+ this->nodes_by_level_[0] *= this->num_children_per_node_[i];
- if (this->nodesByLevel_[0] != this->nodes_.size()) {
+ if (this->nodes_by_level_[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]) +
+ " Please check your platform description (We need " + std::to_string(this->nodes_by_level_[0]) +
"nodes, we got " + std::to_string(this->nodes_.size()));
- return;
}
for (unsigned int i = 0; i < this->levels_; i++) {
int nodesInThisLevel = 1;
for (unsigned int j = 0; j <= i; j++)
- nodesInThisLevel *= this->upperLevelNodesNumber_[j];
+ nodesInThisLevel *= this->num_parents_per_node_[j];
for (unsigned int j = i + 1; j < this->levels_; j++)
- nodesInThisLevel *= this->lowerLevelNodesNumber_[j];
+ nodesInThisLevel *= this->num_children_per_node_[j];
- this->nodesByLevel_[i + 1] = nodesInThisLevel;
+ this->nodes_by_level_[i + 1] = nodesInThisLevel;
}
// 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++) {
+ for (unsigned int j = 0; j < this->nodes_by_level_[i + 1]; j++) {
FatTreeNode* newNode = new FatTreeNode(this->cluster_, --k, i + 1, j);
XBT_DEBUG("We create the switch %d(%u,%u)", newNode->id, newNode->level, newNode->position);
- newNode->children.resize(this->lowerLevelNodesNumber_[i] * this->lowerLevelPortsNumber_[i]);
+ newNode->children.resize(this->num_children_per_node_[i] * this->num_port_lower_level_[i]);
if (i != this->levels_ - 1) {
- newNode->parents.resize(this->upperLevelNodesNumber_[i + 1] * this->lowerLevelPortsNumber_[i + 1]);
+ newNode->parents.resize(this->num_parents_per_node_[i + 1] * this->num_port_lower_level_[i + 1]);
}
newNode->label.resize(this->levels_);
this->nodes_.push_back(newNode);
}
}
-void FatTreeZone::generateLabels()
+void FatTreeZone::generate_labels()
{
XBT_DEBUG("Generating labels.");
// TODO : check if nodesByLevel and nodes are filled
for (unsigned int i = 0; i <= this->levels_; i++) {
currentLabel.assign(this->levels_, 0);
for (unsigned int j = 0; j < this->levels_; j++) {
- maxLabel[j] = j + 1 > i ? this->lowerLevelNodesNumber_[j] : this->upperLevelNodesNumber_[j];
+ maxLabel[j] = j + 1 > i ? this->num_children_per_node_[j] : this->num_parents_per_node_[j];
}
- for (unsigned int j = 0; j < this->nodesByLevel_[i]; j++) {
-
+ for (unsigned int j = 0; j < this->nodes_by_level_[i]; j++) {
if (XBT_LOG_ISENABLED(surf_route_fat_tree, xbt_log_priority_debug)) {
std::stringstream msgBuffer;
}
}
-int FatTreeZone::getLevelPosition(const unsigned int level)
+int FatTreeZone::get_level_position(const unsigned int level)
{
xbt_assert(level <= this->levels_, "The impossible did happen. Yet again.");
int tempPosition = 0;
for (unsigned int i = 0; i < level; i++)
- tempPosition += this->nodesByLevel_[i];
+ tempPosition += this->nodes_by_level_[i];
return tempPosition;
}
-void FatTreeZone::addProcessingNode(int id)
+void FatTreeZone::add_processing_node(int id)
{
using std::make_pair;
static int position = 0;
FatTreeNode* newNode;
newNode = new FatTreeNode(this->cluster_, id, 0, position++);
- newNode->parents.resize(this->upperLevelNodesNumber_[0] * this->lowerLevelPortsNumber_[0]);
+ newNode->parents.resize(this->num_parents_per_node_[0] * this->num_port_lower_level_[0]);
newNode->label.resize(this->levels_);
this->compute_nodes_.insert(make_pair(id, newNode));
this->nodes_.push_back(newNode);
}
-void FatTreeZone::addLink(FatTreeNode* parent, unsigned int parentPort, FatTreeNode* child, unsigned int childPort)
+void FatTreeZone::add_link(FatTreeNode* parent, unsigned int parentPort, FatTreeNode* child, unsigned int childPort)
{
FatTreeLink* newLink;
newLink = new FatTreeLink(this->cluster_, child, parent);
std::vector<std::string> parameters;
std::vector<std::string> 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(error_msg);
- }
+ surf_parse_assert(
+ parameters.size() == 4,
+ "Fat trees are defined by the levels number and 3 vectors, see the documentation for more information.");
// The first parts of topo_parameters should be the levels number
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]);
+ } catch (const std::invalid_argument&) {
+ surf_parse_error(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(error_msg);
- }
+ surf_parse_assert(tmp.size() == this->levels_, std::string("You specified ") + std::to_string(this->levels_) +
+ " levels but the child count vector (the first one) contains " +
+ std::to_string(tmp.size()) + " levels.");
+
for (size_t i = 0; i < tmp.size(); i++) {
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]);
+ this->num_children_per_node_.push_back(std::stoi(tmp[i]));
+ } catch (const std::invalid_argument&) {
+ surf_parse_error(std::string("Invalid child count: ") + 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(error_msg);
- }
+ surf_parse_assert(tmp.size() == this->levels_, std::string("You specified ") + std::to_string(this->levels_) +
+ " levels but the parent count vector (the second one) contains " +
+ std::to_string(tmp.size()) + " levels.");
for (size_t i = 0; i < tmp.size(); i++) {
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]);
+ this->num_parents_per_node_.push_back(std::stoi(tmp[i]));
+ } catch (const std::invalid_argument&) {
+ surf_parse_error(std::string("Invalid parent count: ") + 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(error_msg);
- }
+ surf_parse_assert(tmp.size() == this->levels_, std::string("You specified ") + std::to_string(this->levels_) +
+ " levels but the port count vector (the third one) contains " +
+ std::to_string(tmp.size()) + " levels.");
for (size_t i = 0; i < tmp.size(); i++) {
try {
- this->lowerLevelPortsNumber_.push_back(std::stoi(tmp[i]));
- } catch (std::invalid_argument& ia) {
+ this->num_port_lower_level_.push_back(std::stoi(tmp[i]));
+ } catch (const std::invalid_argument&) {
throw std::invalid_argument(std::string("Invalid lower level port number:") + tmp[i]);
}
}
this->cluster_ = cluster;
}
-void FatTreeZone::generateDotFile(const std::string& filename) const
+void FatTreeZone::generate_dot_file(const std::string& filename) const
{
std::ofstream file;
file.open(filename, std::ios::out | std::ios::trunc);
{
LinkCreationArgs linkTemplate;
if (cluster->limiter_link) {
- linkTemplate.bandwidth = cluster->limiter_link;
+ linkTemplate.bandwidths.push_back(cluster->limiter_link);
linkTemplate.latency = 0;
- linkTemplate.policy = SURF_LINK_SHARED;
+ linkTemplate.policy = s4u::Link::SharingPolicy::SHARED;
linkTemplate.id = "limiter_"+std::to_string(id);
sg_platf_new_link(&linkTemplate);
- this->limiter_link_ = surf::LinkImpl::byName(linkTemplate.id);
+ this->limiter_link_ = s4u::Link::by_name(linkTemplate.id)->get_impl();
}
if (cluster->loopback_bw || cluster->loopback_lat) {
- linkTemplate.bandwidth = cluster->loopback_bw;
+ linkTemplate.bandwidths.push_back(cluster->loopback_bw);
linkTemplate.latency = cluster->loopback_lat;
- linkTemplate.policy = SURF_LINK_FATPIPE;
+ linkTemplate.policy = s4u::Link::SharingPolicy::FATPIPE;
linkTemplate.id = "loopback_"+ std::to_string(id);
sg_platf_new_link(&linkTemplate);
- this->loopback = surf::LinkImpl::byName(linkTemplate.id);
+ this->loopback = s4u::Link::by_name(linkTemplate.id)->get_impl();
}
}
{
static int uniqueId = 0;
LinkCreationArgs linkTemplate;
- linkTemplate.bandwidth = cluster->bw;
+ linkTemplate.bandwidths.push_back(cluster->bw);
linkTemplate.latency = cluster->lat;
linkTemplate.policy = cluster->sharing_policy; // sthg to do with that ?
linkTemplate.id =
"link_from_" + std::to_string(downNode->id) + "_" + std::to_string(upNode->id) + "_" + std::to_string(uniqueId);
sg_platf_new_link(&linkTemplate);
- if (cluster->sharing_policy == SURF_LINK_SPLITDUPLEX) {
- std::string tmpID = std::string(linkTemplate.id) + "_UP";
- this->up_link_ = surf::LinkImpl::byName(tmpID); // check link?
- tmpID = std::string(linkTemplate.id) + "_DOWN";
- this->down_link_ = surf::LinkImpl::byName(tmpID); // check link ?
+ if (cluster->sharing_policy == s4u::Link::SharingPolicy::SPLITDUPLEX) {
+ this->up_link_ = s4u::Link::by_name(linkTemplate.id + "_UP")->get_impl(); // check link?
+ this->down_link_ = s4u::Link::by_name(linkTemplate.id + "_DOWN")->get_impl(); // check link ?
} else {
- this->up_link_ = surf::LinkImpl::byName(linkTemplate.id);
+ this->up_link_ = s4u::Link::by_name(linkTemplate.id)->get_impl();
this->down_link_ = this->up_link_;
}
uniqueId++;
}
-}
-}
-} // namespace
+} // namespace routing
+} // namespace kernel
+} // namespace simgrid
