-/* 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);
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++)
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_);
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;
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->nodes_by_level_[i]; j++) {
- this->connectNodeToParents(this->nodes_[k]);
+ 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);
+ currentParentNode += this->get_level_position(level + 1);
for (unsigned int i = 0; i < this->nodes_by_level_[level + 1]; i++) {
- if (this->areRelated(*currentParentNode, node)) {
+ 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,
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->nodes_by_level_.resize(this->levels_ + 1, 0);
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->nodes_by_level_[0]) +
"nodes, we got " + std::to_string(this->nodes_.size()));
- return;
}
for (unsigned int i = 0; i < this->levels_; i++) {
}
}
-void FatTreeZone::generateLabels()
+void FatTreeZone::generate_labels()
{
XBT_DEBUG("Generating labels.");
// TODO : check if nodesByLevel and nodes are filled
}
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;
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->num_children_per_node_.push_back(std::stoi(tmp[i]));
- } catch (std::invalid_argument& ia) {
- throw std::invalid_argument(std::string("Invalid lower level node number:") + 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->num_parents_per_node_.push_back(std::stoi(tmp[i]));
- } catch (std::invalid_argument& ia) {
- throw std::invalid_argument(std::string("Invalid upper level node number:") + 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->num_port_lower_level_.push_back(std::stoi(tmp[i]));
- } catch (std::invalid_argument& ia) {
+ } catch (const std::invalid_argument&) {
throw std::invalid_argument(std::string("Invalid lower level port number:") + tmp[i]);
}
}
{
LinkCreationArgs linkTemplate;
if (cluster->limiter_link) {
- linkTemplate.bandwidth = cluster->limiter_link;
+ linkTemplate.bandwidths.push_back(cluster->limiter_link);
linkTemplate.latency = 0;
linkTemplate.policy = s4u::Link::SharingPolicy::SHARED;
linkTemplate.id = "limiter_"+std::to_string(id);
sg_platf_new_link(&linkTemplate);
- this->limiter_link_ = resource::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 = s4u::Link::SharingPolicy::FATPIPE;
linkTemplate.id = "loopback_"+ std::to_string(id);
sg_platf_new_link(&linkTemplate);
- this->loopback = resource::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 =
sg_platf_new_link(&linkTemplate);
if (cluster->sharing_policy == s4u::Link::SharingPolicy::SPLITDUPLEX) {
- std::string tmpID = std::string(linkTemplate.id) + "_UP";
- this->up_link_ = resource::LinkImpl::byName(tmpID); // check link?
- tmpID = std::string(linkTemplate.id) + "_DOWN";
- this->down_link_ = resource::LinkImpl::byName(tmpID); // check link ?
+ 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_ = resource::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
