void do_seal() override;
void generate_routers();
void generate_links();
- void generate_link(const std::string& id, int numlinks, resource::LinkImpl** linkup,
- resource::LinkImpl** linkdown) const;
+ void generate_link(const std::string& id, int numlinks, resource::LinkImpl** linkup, resource::LinkImpl** linkdown);
simgrid::s4u::Link::SharingPolicy sharing_policy_ = simgrid::s4u::Link::SharingPolicy::SHARED;
double bw_ = 0;
/** If present, communications from this node to this node will pass through it
* instead of passing by an upper level switch.
*/
- resource::LinkImpl* loopback;
- FatTreeNode(const ClusterCreationArgs* cluster, int id, int level, int position);
+ resource::LinkImpl* loopback_;
+ FatTreeNode(int id, int level, int position, resource::LinkImpl* limiter, resource::LinkImpl* loopback)
+ : id(id), level(level), position(position), limiter_link_(limiter), loopback_(loopback)
+ {
+ }
};
/** @brief Link in a fat tree (@ref FatTreeZone).
*/
class FatTreeLink {
public:
- FatTreeLink(const ClusterCreationArgs* cluster, FatTreeNode* source, FatTreeNode* destination);
- /** Link going up in the tree */
- resource::LinkImpl* up_link_;
- /** Link going down in the tree */
- resource::LinkImpl* down_link_;
+ FatTreeLink(FatTreeNode* src, FatTreeNode* dst, resource::LinkImpl* linkup, resource::LinkImpl* linkdown)
+ : up_node_(dst), down_node_(src), up_link_(linkup), down_link_(linkdown)
+ {
+ }
/** Upper end of the link */
FatTreeNode* up_node_;
/** Lower end of the link */
FatTreeNode* down_node_;
+ /** Link going up in the tree */
+ resource::LinkImpl* up_link_;
+ /** Link going down in the tree */
+ resource::LinkImpl* down_link_;
};
/** @ingroup ROUTING_API
* It will also store the cluster for future use.
*/
void parse_specific_arguments(ClusterCreationArgs* cluster) override;
- void add_processing_node(int id);
+ void add_processing_node(int id, resource::LinkImpl* limiter, resource::LinkImpl* loopback);
void generate_dot_file(const std::string& filename = "fat_tree.dot") const;
};
} // namespace routing
{
std::string link_id = cluster->id + "_link_" + std::to_string(id);
- LinkCreationArgs link;
- link.id = link_id;
- link.bandwidths.push_back(cluster->bw);
- link.latency = cluster->lat;
- link.policy = cluster->sharing_policy;
- sg_platf_new_link(&link);
-
const s4u::Link* linkUp;
const s4u::Link* linkDown;
- if (link.policy == simgrid::s4u::Link::SharingPolicy::SPLITDUPLEX) {
- linkUp = s4u::Link::by_name(link_id + "_UP");
- linkDown = s4u::Link::by_name(link_id + "_DOWN");
+ if (cluster->sharing_policy == simgrid::s4u::Link::SharingPolicy::SPLITDUPLEX) {
+ linkUp = create_link(link_id + "_UP", std::vector<double>{cluster->bw})->set_latency(cluster->lat)->seal();
+ linkDown = create_link(link_id + "_DOWN", std::vector<double>{cluster->bw})->set_latency(cluster->lat)->seal();
} else {
- linkUp = s4u::Link::by_name(link_id);
+ linkUp = create_link(link_id, std::vector<double>{cluster->bw})->set_latency(cluster->lat)->seal();
linkDown = linkUp;
}
private_links_.insert({position, {linkUp->get_impl(), linkDown->get_impl()}});
}
void DragonflyZone::generate_link(const std::string& id, int numlinks, resource::LinkImpl** linkup,
- resource::LinkImpl** linkdown) const
+ resource::LinkImpl** linkdown)
{
+ XBT_DEBUG("Generating link %s", id.c_str());
*linkup = nullptr;
*linkdown = nullptr;
- LinkCreationArgs linkTemplate;
- linkTemplate.bandwidths.push_back(this->bw_ * numlinks);
- linkTemplate.latency = this->lat_;
- linkTemplate.policy = this->sharing_policy_;
- linkTemplate.id = id;
- sg_platf_new_link(&linkTemplate);
- XBT_DEBUG("Generating link %s", linkTemplate.id.c_str());
- resource::LinkImpl* link;
- if (this->sharing_policy_ == s4u::Link::SharingPolicy::SPLITDUPLEX) {
- *linkup = s4u::Link::by_name(linkTemplate.id + "_UP")->get_impl(); // check link?
- *linkdown = s4u::Link::by_name(linkTemplate.id + "_DOWN")->get_impl(); // check link ?
+ if (sharing_policy_ == s4u::Link::SharingPolicy::SPLITDUPLEX) {
+ *linkup = create_link(id + "_UP", std::vector<double>{bw_ * numlinks})->set_latency(lat_)->seal()->get_impl();
+ *linkdown = create_link(id + "_DOWN", std::vector<double>{bw_ * numlinks})->set_latency(lat_)->seal()->get_impl();
+
} else {
- link = s4u::Link::by_name(linkTemplate.id)->get_impl();
- *linkup = link;
- *linkdown = link;
+ *linkup = create_link(id, std::vector<double>{bw_ * numlinks})->set_latency(lat_)->seal()->get_impl();
+ *linkdown = *linkup;
}
}
/* 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 && has_loopback()) {
- into->link_list.push_back(source->loopback);
+ into->link_list.push_back(source->loopback_);
if (latency)
- *latency += source->loopback->get_latency();
+ *latency += source->loopback_->get_latency();
return;
}
int k = 0;
for (unsigned int i = 0; i < this->levels_; i++) {
for (unsigned int j = 0; j < this->nodes_by_level_[i + 1]; j++) {
- auto* newNode = new FatTreeNode(this->cluster_, --k, i + 1, j);
+ auto* newNode = new FatTreeNode(--k, i + 1, j, nullptr, nullptr);
XBT_DEBUG("We create the switch %d(%u,%u)", newNode->id, newNode->level, newNode->position);
newNode->children.resize(this->num_children_per_node_[i] * this->num_port_lower_level_[i]);
if (i != this->levels_ - 1) {
return tempPosition;
}
-void FatTreeZone::add_processing_node(int id)
+void FatTreeZone::add_processing_node(int id, resource::LinkImpl* limiter, resource::LinkImpl* loopback)
{
using std::make_pair;
static int position = 0;
FatTreeNode* newNode;
- newNode = new FatTreeNode(this->cluster_, id, 0, position++);
+ newNode = new FatTreeNode(id, 0, position++, limiter, loopback);
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));
void FatTreeZone::add_link(FatTreeNode* parent, unsigned int parentPort, FatTreeNode* child, unsigned int childPort)
{
- FatTreeLink* newLink;
- newLink = new FatTreeLink(this->cluster_, child, parent);
+ static int uniqueId = 0;
+ s4u::Link* linkup;
+ s4u::Link* linkdown;
+ std::string id =
+ "link_from_" + std::to_string(child->id) + "_" + std::to_string(parent->id) + "_" + std::to_string(uniqueId);
+
+ if (cluster_->sharing_policy == s4u::Link::SharingPolicy::SPLITDUPLEX) {
+ linkup = create_link(id + "_UP", std::vector<double>{cluster_->bw})->set_latency(cluster_->lat)->seal();
+ linkdown = create_link(id + "_DOWN", std::vector<double>{cluster_->bw})->set_latency(cluster_->lat)->seal();
+ } else {
+ linkup = create_link(id, std::vector<double>{cluster_->bw})->set_latency(cluster_->lat)->seal();
+ linkdown = linkup;
+ }
+ uniqueId++;
+
+ FatTreeLink* newLink = new FatTreeLink(child, parent, linkup->get_impl(), linkdown->get_impl());
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;
file << "}";
file.close();
}
-
-FatTreeNode::FatTreeNode(const ClusterCreationArgs* cluster, int id, int level, int position)
- : id(id), level(level), position(position)
-{
- LinkCreationArgs linkTemplate;
- if (cluster->limiter_link != 0.0) {
- 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_ = s4u::Link::by_name(linkTemplate.id)->get_impl();
- }
- if (cluster->loopback_bw != 0.0 || cluster->loopback_lat != 0.0) {
- 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 = s4u::Link::by_name(linkTemplate.id)->get_impl();
- }
-}
-
-FatTreeLink::FatTreeLink(const ClusterCreationArgs* cluster, FatTreeNode* downNode, FatTreeNode* upNode)
- : up_node_(upNode), down_node_(downNode)
-{
- static int uniqueId = 0;
- LinkCreationArgs linkTemplate;
- 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 == 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_ = s4u::Link::by_name(linkTemplate.id)->get_impl();
- this->down_link_ = this->up_link_;
- }
- uniqueId++;
-}
} // namespace routing
} // namespace kernel
// name of neighbor is not right for non contiguous cluster radicals (as id != rank in this case)
std::string link_id =
std::string(cluster->id) + "_link_from_" + std::to_string(id) + "_to_" + std::to_string(neighbor_rank_id);
- link.id = link_id;
- link.bandwidths.push_back(cluster->bw);
- link.latency = cluster->lat;
- link.policy = cluster->sharing_policy;
- sg_platf_new_link(&link);
- resource::LinkImpl* linkUp;
- resource::LinkImpl* linkDown;
- if (link.policy == s4u::Link::SharingPolicy::SPLITDUPLEX) {
- linkUp = s4u::Link::by_name(link_id + "_UP")->get_impl();
- linkDown = s4u::Link::by_name(link_id + "_DOWN")->get_impl();
+ s4u::Link* linkup;
+ s4u::Link* linkdown;
+ if (cluster->sharing_policy == s4u::Link::SharingPolicy::SPLITDUPLEX) {
+ linkup = create_link(link_id + "_UP", std::vector<double>{cluster->bw})->set_latency(cluster->lat)->seal();
+ linkdown = create_link(link_id + "_DOWN", std::vector<double>{cluster->bw})->set_latency(cluster->lat)->seal();
+
} else {
- linkUp = s4u::Link::by_name(link_id)->get_impl();
- linkDown = linkUp;
+ linkup = create_link(link_id, std::vector<double>{cluster->bw})->set_latency(cluster->lat)->seal();
+ linkdown = linkup;
}
/*
* Add the link to its appropriate position.
* Note that position rankId*(xbt_dynar_length(dimensions)+has_loopback?+has_limiter?)
* holds the link "rankId->rankId"
*/
- add_private_link_at(position + j, {linkUp, linkDown});
+ add_private_link_at(position + j, {linkup->get_impl(), linkdown->get_impl()});
dim_product *= current_dimension;
}
}
// other columns are to store one or more link for the node
// add a loopback link
+ simgrid::kernel::resource::LinkImpl* loopback = nullptr;
if (cluster->loopback_bw > 0 || cluster->loopback_lat > 0) {
std::string loopback_name = link_id + "_loopback";
XBT_DEBUG("<loopback\tid=\"%s\"\tbw=\"%f\"/>", loopback_name.c_str(), cluster->loopback_bw);
- auto* loopback = current_zone->create_link(loopback_name, std::vector<double>{cluster->loopback_bw})
- ->set_sharing_policy(simgrid::s4u::Link::SharingPolicy::FATPIPE)
- ->set_latency(cluster->loopback_lat)
- ->seal()
- ->get_impl();
+ loopback = current_zone->create_link(loopback_name, std::vector<double>{cluster->loopback_bw})
+ ->set_sharing_policy(simgrid::s4u::Link::SharingPolicy::FATPIPE)
+ ->set_latency(cluster->loopback_lat)
+ ->seal()
+ ->get_impl();
current_zone->add_private_link_at(current_zone->node_pos(rankId), {loopback, loopback});
}
// add a limiter link (shared link to account for maximal bandwidth of the node)
+ simgrid::kernel::resource::LinkImpl* limiter = nullptr;
if (cluster->limiter_link > 0) {
std::string limiter_name = std::string(link_id) + "_limiter";
XBT_DEBUG("<limiter\tid=\"%s\"\tbw=\"%f\"/>", limiter_name.c_str(), cluster->limiter_link);
- auto* limiter =
- current_zone->create_link(limiter_name, std::vector<double>{cluster->limiter_link})->seal()->get_impl();
+ limiter = current_zone->create_link(limiter_name, std::vector<double>{cluster->limiter_link})->seal()->get_impl();
current_zone->add_private_link_at(current_zone->node_pos_with_loopback(rankId), {limiter, limiter});
}
// call the cluster function that adds the others links
if (cluster->topology == simgrid::kernel::routing::ClusterTopology::FAT_TREE) {
- static_cast<FatTreeZone*>(current_zone)->add_processing_node(i);
+ static_cast<FatTreeZone*>(current_zone)->add_processing_node(i, limiter, loopback);
} else {
current_zone->create_links_for_node(cluster, i, rankId, current_zone->node_pos_with_loopback_limiter(rankId));
}
