if (! src->isRouter()) { // No specific link for router
- if((src->id() == dst->id()) && has_loopback_ ){
- info = xbt_dynar_get_as(privateLinks_, src->id() * nb_links_per_node_, s_surf_parsing_link_up_down_t);
- route->link_list->push_back(info.link_up);
+ if((src->id() == dst->id()) && hasLoopback_ ){
+ info = xbt_dynar_get_as(privateLinks_, src->id() * linkCountPerNode_, s_surf_parsing_link_up_down_t);
+ route->link_list->push_back(info.linkUp);
if (lat)
- *lat += info.link_up->getLatency();
+ *lat += info.linkUp->getLatency();
return;
}
- if (has_limiter_){ // limiter for sender
- info = xbt_dynar_get_as(privateLinks_, src->id() * nb_links_per_node_ + has_loopback_, s_surf_parsing_link_up_down_t);
- route->link_list->push_back((Link*)info.link_up);
+ if (hasLimiter_){ // limiter for sender
+ info = xbt_dynar_get_as(privateLinks_, src->id() * linkCountPerNode_ + (hasLoopback_?1:0), s_surf_parsing_link_up_down_t);
+ route->link_list->push_back((Link*)info.linkUp);
}
- info = xbt_dynar_get_as(privateLinks_, src->id() * nb_links_per_node_ + has_loopback_ + has_limiter_, s_surf_parsing_link_up_down_t);
- if (info.link_up) { // link up
- route->link_list->push_back(info.link_up);
+ info = xbt_dynar_get_as(privateLinks_, src->id() * linkCountPerNode_ + (hasLoopback_?1:0) + (hasLimiter_?1:0), s_surf_parsing_link_up_down_t);
+ if (info.linkUp) { // link up
+ route->link_list->push_back(info.linkUp);
if (lat)
- *lat += info.link_up->getLatency();
+ *lat += info.linkUp->getLatency();
}
}
}
if (! dst->isRouter()) { // No specific link for router
- info = xbt_dynar_get_as(privateLinks_, dst->id() * nb_links_per_node_ + has_loopback_ + has_limiter_, s_surf_parsing_link_up_down_t);
+ info = xbt_dynar_get_as(privateLinks_, dst->id() * linkCountPerNode_ + hasLoopback_ + hasLimiter_, s_surf_parsing_link_up_down_t);
- if (info.link_down) { // link down
- route->link_list->push_back(info.link_down);
+ if (info.linkDown) { // link down
+ route->link_list->push_back(info.linkDown);
if (lat)
- *lat += info.link_down->getLatency();
+ *lat += info.linkDown->getLatency();
}
- if (has_limiter_){ // limiter for receiver
- info = xbt_dynar_get_as(privateLinks_, dst->id() * nb_links_per_node_ + has_loopback_, s_surf_parsing_link_up_down_t);
- route->link_list->push_back(info.link_up);
+ if (hasLimiter_){ // limiter for receiver
+ info = xbt_dynar_get_as(privateLinks_, dst->id() * linkCountPerNode_ + hasLoopback_, s_surf_parsing_link_up_down_t);
+ route->link_list->push_back(info.linkUp);
}
}
}
info = xbt_dynar_get_as(privateLinks_, src->id(), s_surf_parsing_link_up_down_t);
- if (info.link_up) { // link up
+ if (info.linkUp) { // link up
const char *link_name = static_cast<simgrid::surf::Resource*>(
- info.link_up)->getName();
+ info.linkUp)->getName();
current = new_xbt_graph_node(graph, link_name, nodes);
new_xbt_graph_edge(graph, previous, current, edges);
}
- if (info.link_down) { // link down
+ if (info.linkDown) { // link down
const char *link_name = static_cast<simgrid::surf::Resource*>(
- info.link_down)->getName();
+ info.linkDown)->getName();
current = new_xbt_graph_node(graph, link_name, nodes);
new_xbt_graph_edge(graph, previous, current, edges);
if (link.policy == SURF_LINK_FULLDUPLEX) {
char *tmp_link = bprintf("%s_UP", link_id);
- info.link_up = Link::byName(tmp_link);
+ info.linkUp = Link::byName(tmp_link);
xbt_free(tmp_link);
tmp_link = bprintf("%s_DOWN", link_id);
- info.link_down = Link::byName(tmp_link);
+ info.linkDown = Link::byName(tmp_link);
xbt_free(tmp_link);
} else {
- info.link_up = info.link_down = Link::byName(link_id);
+ info.linkUp = Link::byName(link_id);
+ info.linkDown = info.linkUp;
}
xbt_dynar_set(privateLinks_, position, &info);
xbt_free(link_id);
Link* backbone_ = nullptr;
void *loopback_ = nullptr;
NetCard *router_ = nullptr;
- int has_limiter_ = 0; /* O or 1. must be an int since it's used to shift the considered index */
- int has_loopback_ = 0; /* O or 1. must be an int since it's used to shift the considered index */
- int nb_links_per_node_ = 1; /* may be 1 (if only a private link), 2 or 3 (if limiter and loopback) */
+ bool hasLimiter_ = false;
+ bool hasLoopback_ = false;
+ int linkCountPerNode_ = 1; /* may be 1 (if only a private link), 2 or 3 (if limiter and loopback) */
};
/* 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->has_loopback_) {
+ if(source->id == destination->id && this->hasLoopback_) {
into->link_list->push_back(source->loopback);
if(latency) {
*latency += source->loopback->getLatency();
*latency += currentNode->parents[d]->upLink->getLatency();
}
- if (this->has_limiter_) {
+ if (this->hasLimiter_) {
into->link_list->push_back(currentNode->limiterLink);
}
currentNode = currentNode->parents[d]->upNode;
*latency += currentNode->children[i]->downLink->getLatency();
}
currentNode = currentNode->children[i]->downNode;
- if (this->has_limiter_) {
+ if (this->hasLimiter_) {
into->link_list->push_back(currentNode->limiterLink);
}
XBT_DEBUG("%d(%u,%u) is accessible through %d(%u,%u)", destination->id,
s_surf_parsing_link_up_down_t info;
if (link.policy == SURF_LINK_FULLDUPLEX) {
char *tmp_link = bprintf("%s_UP", link_id);
- info.link_up = Link::byName(tmp_link);
+ info.linkUp = Link::byName(tmp_link);
free(tmp_link);
tmp_link = bprintf("%s_DOWN", link_id);
- info.link_down = Link::byName(tmp_link);
+ info.linkDown = Link::byName(tmp_link);
free(tmp_link);
} else {
- info.link_up = Link::byName(link_id);
- info.link_down = info.link_up;
+ info.linkUp = Link::byName(link_id);
+ info.linkDown = info.linkUp;
}
/*
* Add the link to its appropriate position;
xbt_dynar_set_as(dimensions_, iter, int, tmp);
}
- nb_links_per_node_ = xbt_dynar_length(dimensions_);
+ linkCountPerNode_ = xbt_dynar_length(dimensions_);
}
xbt_dynar_free(&dimensions);
if (dst->isRouter() || src->isRouter())
return;
- if ((src->id() == dst->id()) && has_loopback_) {
- s_surf_parsing_link_up_down_t info = xbt_dynar_get_as(privateLinks_, src->id() * nb_links_per_node_, s_surf_parsing_link_up_down_t);
+ if ((src->id() == dst->id()) && hasLoopback_) {
+ s_surf_parsing_link_up_down_t info = xbt_dynar_get_as(privateLinks_, src->id() * linkCountPerNode_, s_surf_parsing_link_up_down_t);
- route->link_list->push_back(info.link_up);
+ route->link_list->push_back(info.linkUp);
if (lat)
- *lat += info.link_up->getLatency();
+ *lat += info.linkUp->getLatency();
return;
}
next_node = (current_node + dim_product);
// HERE: We use *CURRENT* node for calculation (as opposed to next_node)
- nodeOffset = current_node * (nb_links_per_node_);
- linkOffset = nodeOffset + has_loopback_ + has_limiter_ + j;
+ nodeOffset = current_node * (linkCountPerNode_);
+ linkOffset = nodeOffset + (hasLoopback_?1:0) + (hasLimiter_?1:0) + j;
use_lnk_up = true;
assert(linkOffset >= 0);
} else { // Route to the left
next_node = (current_node - dim_product);
// HERE: We use *next* node for calculation (as opposed to current_node!)
- nodeOffset = next_node * (nb_links_per_node_);
- linkOffset = nodeOffset + j + has_loopback_ + has_limiter_;
+ nodeOffset = next_node * (linkCountPerNode_);
+ linkOffset = nodeOffset + j + (hasLoopback_?1:0) + (hasLimiter_?1:0) ;
use_lnk_up = false;
assert(linkOffset >= 0);
s_surf_parsing_link_up_down_t info;
- if (has_limiter_) { // limiter for sender
- info = xbt_dynar_get_as(privateLinks_, nodeOffset + has_loopback_, s_surf_parsing_link_up_down_t);
- route->link_list->push_back(info.link_up);
+ if (hasLimiter_) { // limiter for sender
+ info = xbt_dynar_get_as(privateLinks_, nodeOffset + hasLoopback_, s_surf_parsing_link_up_down_t);
+ route->link_list->push_back(info.linkUp);
}
info = xbt_dynar_get_as(privateLinks_, linkOffset, s_surf_parsing_link_up_down_t);
if (use_lnk_up == false) {
- route->link_list->push_back(info.link_down);
+ route->link_list->push_back(info.linkDown);
if (lat)
- *lat += info.link_down->getLatency();
+ *lat += info.linkDown->getLatency();
} else {
- route->link_list->push_back(info.link_up);
+ route->link_list->push_back(info.linkUp);
if (lat)
- *lat += info.link_up->getLatency();
+ *lat += info.linkUp->getLatency();
}
current_node = next_node;
next_node = 0;
/* Retrieve the private links */
if ((int)xbt_dynar_length(privateLinks_) > src->id()) {
s_surf_parsing_link_up_down_t info = xbt_dynar_get_as(privateLinks_, src->id(), s_surf_parsing_link_up_down_t);
- if(info.link_up) {
- route->link_list->push_back(info.link_up);
+ if(info.linkUp) {
+ route->link_list->push_back(info.linkUp);
if (lat)
- *lat += info.link_up->getLatency();
+ *lat += info.linkUp->getLatency();
}
}
if ((int)xbt_dynar_length(privateLinks_)>dst->id()) {
s_surf_parsing_link_up_down_t info = xbt_dynar_get_as(privateLinks_, dst->id(), s_surf_parsing_link_up_down_t);
- if(info.link_down) {
- route->link_list->push_back(info.link_down);
+ if(info.linkDown) {
+ route->link_list->push_back(info.linkDown);
if (lat)
- *lat += info.link_down->getLatency();
+ *lat += info.linkDown->getLatency();
}
}
current_as->parse_specific_arguments(cluster);
if(cluster->loopback_bw!=0 || cluster->loopback_lat!=0){
- current_as->nb_links_per_node_++;
- current_as->has_loopback_ = 1;
+ current_as->linkCountPerNode_++;
+ current_as->hasLoopback_ = 1;
}
if(cluster->limiter_link!=0){
- current_as->nb_links_per_node_++;
- current_as->has_limiter_ = 1;
+ current_as->linkCountPerNode_++;
+ current_as->hasLimiter_ = 1;
}
std::vector<int> *radicals = explodesRadical(cluster->radical);
link.latency = cluster->loopback_lat;
link.policy = SURF_LINK_FATPIPE;
sg_platf_new_link(&link);
- info_loop.link_up = info_loop.link_down = Link::byName(tmp_link);
+ info_loop.linkUp = info_loop.linkDown = Link::byName(tmp_link);
free(tmp_link);
auto as_cluster = static_cast<AsCluster*>(current_as);
- xbt_dynar_set(as_cluster->privateLinks_, rankId*as_cluster->nb_links_per_node_, &info_loop);
+ xbt_dynar_set(as_cluster->privateLinks_, rankId*as_cluster->linkCountPerNode_, &info_loop);
}
//add a limiter link (shared link to account for maximal bandwidth of the node)
link.latency = 0;
link.policy = SURF_LINK_SHARED;
sg_platf_new_link(&link);
- info_lim.link_up = info_lim.link_down = Link::byName(tmp_link);
+ info_lim.linkUp = info_lim.linkDown = Link::byName(tmp_link);
free(tmp_link);
- xbt_dynar_set(current_as->privateLinks_, rankId * current_as->nb_links_per_node_ + current_as->has_loopback_ , &info_lim);
+ xbt_dynar_set(current_as->privateLinks_, rankId * current_as->linkCountPerNode_ + current_as->hasLoopback_ , &info_lim);
}
//call the cluster function that adds the others links
}
else {
current_as->create_links_for_node(cluster, i, rankId,
- rankId*current_as->nb_links_per_node_ + current_as->has_loopback_ + current_as->has_limiter_ );
+ rankId*current_as->linkCountPerNode_ + current_as->hasLoopback_ + current_as->hasLimiter_ );
}
xbt_free(link_id);
xbt_free(host_id);
"Only hosts from Cluster and Vivaldi ASes can get an host_link.");
s_surf_parsing_link_up_down_t link_up_down;
- link_up_down.link_up = Link::byName(hostlink->link_up);
- link_up_down.link_down = Link::byName(hostlink->link_down);
+ link_up_down.linkUp = Link::byName(hostlink->link_up);
+ link_up_down.linkDown = Link::byName(hostlink->link_down);
- xbt_assert(link_up_down.link_up, "Link '%s' not found!",hostlink->link_up);
- xbt_assert(link_up_down.link_down, "Link '%s' not found!",hostlink->link_down);
+ xbt_assert(link_up_down.linkUp, "Link '%s' not found!",hostlink->link_up);
+ xbt_assert(link_up_down.linkDown, "Link '%s' not found!",hostlink->link_down);
// If dynar is is greater than netcard id and if the host_link is already defined
auto as_cluster = static_cast<simgrid::surf::AsCluster*>(current_routing);
typedef struct s_surf_parsing_link_up_down *surf_parsing_link_up_down_t;
typedef struct s_surf_parsing_link_up_down {
- Link* link_up;
- Link* link_down;
+ Link* linkUp;
+ Link* linkDown;
} s_surf_parsing_link_up_down_t;