protected:
char *name_ = nullptr;
xbt_dict_t children_ = xbt_dict_new_homogeneous(nullptr); // sub-ASes
- xbt_dynar_t vertices_ = xbt_dynar_new(sizeof(char*),nullptr); // our content, as known to our graph routing algorithm (maps vertexId -> vertex)
+ std::vector<kernel::routing::NetCard*> vertices_; // our content, as known to our graph routing algorithm (maps vertexId -> vertex)
std::map<std::pair<std::string, std::string>, std::vector<surf::Link*>*> bypassRoutes_; // srcName x dstName -> route
AsCluster::AsCluster(const char*name)
: AsImpl(name)
{}
- AsCluster::~AsCluster()
- {
- xbt_dynar_free(&privateLinks_);
- }
+ AsCluster::~AsCluster()=default;
void AsCluster::getRouteAndLatency(NetCard *src, NetCard *dst, sg_platf_route_cbarg_t route, double *lat)
{
s_surf_parsing_link_up_down_t info;
XBT_VERB("cluster_get_route_and_latency from '%s'[%d] to '%s'[%d]",
src->name(), src->id(), dst->name(), dst->id());
- xbt_assert(!xbt_dynar_is_empty(privateLinks_), "Cluster routing : no links attached to the source node - did you use host_link tag?");
+ xbt_assert(!privateLinks_.empty(), "Cluster routing : no links attached to the source node - did you use host_link tag?");
if (! src->isRouter()) { // No specific link for router
if((src->id() == dst->id()) && hasLoopback_ ){
- info = xbt_dynar_get_as(privateLinks_, src->id() * linkCountPerNode_, s_surf_parsing_link_up_down_t);
+ info = privateLinks_.at(src->id() * linkCountPerNode_);
route->link_list->push_back(info.linkUp);
if (lat)
*lat += info.linkUp->getLatency();
if (hasLimiter_){ // limiter for sender
- info = xbt_dynar_get_as(privateLinks_, src->id() * linkCountPerNode_ + (hasLoopback_?1:0), s_surf_parsing_link_up_down_t);
+ info = privateLinks_.at(src->id() * linkCountPerNode_ + (hasLoopback_?1:0));
route->link_list->push_back((Link*)info.linkUp);
}
- info = xbt_dynar_get_as(privateLinks_, src->id() * linkCountPerNode_ + (hasLoopback_?1:0) + (hasLimiter_?1:0), s_surf_parsing_link_up_down_t);
+ info = privateLinks_.at(src->id() * linkCountPerNode_ + (hasLoopback_?1:0) + (hasLimiter_?1:0));
if (info.linkUp) { // link up
route->link_list->push_back(info.linkUp);
if (lat)
}
if (! dst->isRouter()) { // No specific link for router
- info = xbt_dynar_get_as(privateLinks_, dst->id() * linkCountPerNode_ + hasLoopback_ + hasLimiter_, s_surf_parsing_link_up_down_t);
+ info = privateLinks_.at(dst->id() * linkCountPerNode_ + hasLoopback_ + hasLimiter_);
if (info.linkDown) { // link down
route->link_list->push_back(info.linkDown);
*lat += info.linkDown->getLatency();
}
if (hasLimiter_){ // limiter for receiver
- info = xbt_dynar_get_as(privateLinks_, dst->id() * linkCountPerNode_ + hasLoopback_, s_surf_parsing_link_up_down_t);
+ info = privateLinks_.at(dst->id() * linkCountPerNode_ + hasLoopback_);
route->link_list->push_back(info.linkUp);
}
}
void AsCluster::getGraph(xbt_graph_t graph, xbt_dict_t nodes, xbt_dict_t edges)
{
- int isrc;
- int table_size = xbt_dynar_length(vertices_);
-
- NetCard *src;
xbt_node_t current, previous, backboneNode = nullptr, routerNode;
s_surf_parsing_link_up_down_t info;
new_xbt_graph_edge(graph, routerNode, backboneNode, edges);
}
- for (isrc = 0; isrc < table_size; isrc++) {
- src = xbt_dynar_get_as(vertices_, isrc, NetCard*);
-
+ for (auto src: vertices_){
if (! src->isRouter()) {
previous = new_xbt_graph_node(graph, src->name(), nodes);
- info = xbt_dynar_get_as(privateLinks_, src->id(), s_surf_parsing_link_up_down_t);
+ info = privateLinks_.at(src->id());
if (info.linkUp) { // link up
-
- const char *link_name = static_cast<simgrid::surf::Resource*>(
- info.linkUp)->getName();
+ const char *link_name = static_cast<simgrid::surf::Resource*>(info.linkUp)->getName();
current = new_xbt_graph_node(graph, link_name, nodes);
new_xbt_graph_edge(graph, previous, current, edges);
} else {
new_xbt_graph_edge(graph, current, routerNode, edges);
}
-
}
if (info.linkDown) { // link down
}
}
}
-
}
}
info.linkUp = Link::byName(link_id);
info.linkDown = info.linkUp;
}
- xbt_dynar_set(privateLinks_, position, &info);
+ privateLinks_.insert(privateLinks_.begin()+position, info);
xbt_free(link_id);
}
virtual void create_links_for_node(sg_platf_cluster_cbarg_t cluster, int id, int rank, int position);
virtual void parse_specific_arguments(sg_platf_cluster_cbarg_t cluster) {}
- xbt_dynar_t privateLinks_ = xbt_dynar_new(sizeof(s_surf_parsing_link_up_down_t),nullptr);
+ std::vector<s_surf_parsing_link_up_down_t> privateLinks_;
Link* backbone_ = nullptr;
void *loopback_ = nullptr;
XBT_VERB("dragonfly_get_route_and_latency from '%s'[%d] to '%s'[%d]", src->name(), src->id(), dst->name(), dst->id());
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);
+ s_surf_parsing_link_up_down_t info = privateLinks_.at(src->id() * linkCountPerNode_);
route->link_list->push_back(info.linkUp);
if (latency)
if (hasLimiter_) { // limiter for sender
s_surf_parsing_link_up_down_t info;
- info = xbt_dynar_get_as(privateLinks_, src->id() * linkCountPerNode_ + hasLoopback_, s_surf_parsing_link_up_down_t);
+ info = privateLinks_.at(src->id() * linkCountPerNode_ + hasLoopback_);
route->link_list->push_back(info.linkUp);
}
if (hasLimiter_) { // limiter for receiver
s_surf_parsing_link_up_down_t info;
- info = xbt_dynar_get_as(privateLinks_, dst->id() * linkCountPerNode_ + hasLoopback_, s_surf_parsing_link_up_down_t);
+ info = privateLinks_.at(dst->id() * linkCountPerNode_ + hasLoopback_);
route->link_list->push_back(info.linkUp);
}
* note that position rankId*(xbt_dynar_length(dimensions)+has_loopack?+has_limiter?)
* holds the link "rankId->rankId"
*/
- xbt_dynar_set(privateLinks_, position + j, &info);
+ privateLinks_.insert(privateLinks_.begin() + position + j, info);
dim_product *= current_dimension;
xbt_free(link_id);
}
return;
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);
+ s_surf_parsing_link_up_down_t info = privateLinks_.at(src->id() * linkCountPerNode_);
route->link_list->push_back(info.linkUp);
if (lat)
s_surf_parsing_link_up_down_t info;
if (hasLimiter_) { // limiter for sender
- info = xbt_dynar_get_as(privateLinks_, nodeOffset + hasLoopback_, s_surf_parsing_link_up_down_t);
+ info = privateLinks_.at(nodeOffset + hasLoopback_);
route->link_list->push_back(info.linkUp);
}
- info = xbt_dynar_get_as(privateLinks_, linkOffset, s_surf_parsing_link_up_down_t);
+ info = privateLinks_.at(linkOffset);
if (use_lnk_up == false) {
route->link_list->push_back(info.linkDown);
}
AsFloyd::~AsFloyd(){
- int table_size = static_cast<int>(xbt_dynar_length(vertices_));
+ int table_size = static_cast<int>(vertices_.size());
if (linkTable_ == nullptr) // Dealing with a parse error in the file?
return;
/* Delete link_table */
void AsFloyd::getRouteAndLatency(NetCard *src, NetCard *dst, sg_platf_route_cbarg_t route, double *lat)
{
- size_t table_size = xbt_dynar_length(vertices_);
+ size_t table_size = vertices_.size();
getRouteCheckParams(src, dst);
void AsFloyd::addRoute(sg_platf_route_cbarg_t route)
{
/* set the size of table routing */
- int table_size = static_cast<int>(xbt_dynar_length(vertices_));
+ int table_size = static_cast<int>(vertices_.size());
addRouteCheckParams(route);
}
void AsFloyd::seal(){
-
/* set the size of table routing */
- size_t table_size = xbt_dynar_length(vertices_);
+ size_t table_size = vertices_.size();
if(!linkTable_) {
/* Create Cost, Predecessor and Link tables */
sg_platf_route_cbarg_t e_route;
/* set utils vars */
- int table_size = (int)xbt_dynar_length(vertices_);
+ int table_size = static_cast<int>(vertices_.size());
/* Create table if necessary */
if (!routingTable_)
AsFull::~AsFull(){
if (routingTable_) {
- int table_size = (int)xbt_dynar_length(vertices_);
- int i, j;
+ int table_size = static_cast<int>(vertices_.size());
/* Delete routing table */
- for (i = 0; i < table_size; i++)
- for (j = 0; j < table_size; j++) {
+ for (int i = 0; i < table_size; i++)
+ for (int j = 0; j < table_size; j++) {
if (TO_ROUTE_FULL(i,j)){
delete TO_ROUTE_FULL(i,j)->link_list;
xbt_free(TO_ROUTE_FULL(i,j));
src->name(), src->id(), dst->name(), dst->id());
/* set utils vars */
- size_t table_size = xbt_dynar_length(vertices_);
+ size_t table_size = vertices_.size();
sg_platf_route_cbarg_t e_route = nullptr;
addRouteCheckParams(route);
- size_t table_size = xbt_dynar_length(vertices_);
+ size_t table_size = vertices_.size();
if (!routingTable_)
routingTable_ = xbt_new0(sg_platf_route_cbarg_t, table_size * table_size);
{
}
-AsRoutedGraph::~AsRoutedGraph()
-{
-}
-
+AsRoutedGraph::~AsRoutedGraph()=default;
}}} // namespace simgrid::kernel::routing
int len = strlen(sn) + strlen(dn) + 1;
char *name = (char *) xbt_malloc(len * sizeof(char));
-
snprintf(name, len, "%s%s", sn, dn);
xbt_edge_t ret = (xbt_edge_t) xbt_dict_get_or_null(edges, name);
if (ret == nullptr) {
sg_platf_route_cbarg_t route = xbt_new0(s_sg_platf_route_cbarg_t,1);
route->link_list = new std::vector<Link*>();
- int table_size = (int)xbt_dynar_length(vertices_);
+ int table_size = static_cast<int>(vertices_.size());
for(int src=0; src < table_size; src++) {
for(int dst=0; dst< table_size; dst++) {
route->link_list->clear();
- NetCard *src_elm = xbt_dynar_get_as(vertices_, src, NetCard*);
- NetCard *dst_elm = xbt_dynar_get_as(vertices_, dst, NetCard*);
+ NetCard *src_elm = vertices_.at(src);
+ NetCard *dst_elm = vertices_.at(dst);
this->getRouteAndLatency(src_elm, dst_elm,route, nullptr);
if (route->link_list->size() == 1) {
void AsRoutedGraph::getGraph(xbt_graph_t graph, xbt_dict_t nodes, xbt_dict_t edges)
{
- int src, dst;
- int table_size = xbt_dynar_length(vertices_);
-
-
- for (src = 0; src < table_size; src++) {
- NetCard *my_src =
- xbt_dynar_get_as(vertices_, src, NetCard*);
- for (dst = 0; dst < table_size; dst++) {
- if (src == dst)
+ for (auto my_src: vertices_){
+ for (auto my_dst: vertices_){
+ if (my_src == my_dst)
continue;
- NetCard *my_dst =
- xbt_dynar_get_as(vertices_, dst, NetCard*);
sg_platf_route_cbarg_t route = xbt_new0(s_sg_platf_route_cbarg_t, 1);
route->link_list = new std::vector<Link*>();
}
}
-
/* ************************************************************************** */
/* ************************* GENERIC AUX FUNCTIONS ************************** */
/* change a route containing link names into a route containing link entities */
}
/* 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 (static_cast<int>(privateLinks_.size()) > src->id()) {
+ s_surf_parsing_link_up_down_t info = privateLinks_.at(src->id());
if(info.linkUp) {
route->link_list->push_back(info.linkUp);
if (lat)
*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 (static_cast<int>(privateLinks_.size()) >dst->id()) {
+ s_surf_parsing_link_up_down_t info = privateLinks_.at(dst->id());
if(info.linkDown) {
route->link_list->push_back(info.linkDown);
if (lat)
xbt_dict_free(&children_);
- xbt_dynar_free(&vertices_);
for (auto &kv : bypassRoutes_)
delete kv.second;
xbt_free(name_);
{
xbt_dynar_t res = xbt_dynar_new(sizeof(sg_host_t), nullptr);
- for (unsigned int index = 0; index < xbt_dynar_length(vertices_); index++) {
- kernel::routing::NetCard *card = xbt_dynar_get_as(vertices_, index, kernel::routing::NetCard*);
- s4u::Host *host = simgrid::s4u::Host::by_name_or_null(card->name());
+ for (auto card : vertices_) {
+ s4u::Host *host = simgrid::s4u::Host::by_name_or_null(card->name());
if (host!=nullptr)
xbt_dynar_push(res, &host);
}
}
int As::addComponent(kernel::routing::NetCard *elm) {
- xbt_dynar_push_as(vertices_, kernel::routing::NetCard*, elm);
- return xbt_dynar_length(vertices_)-1;
+ vertices_.push_back(elm);
+ return vertices_.size()-1; //FIXME -1 ?
}
void As::addRoute(sg_platf_route_cbarg_t /*route*/){
XBT_DEBUG("<link\tid=\"%s\"\tbw=\"%f\"\tlat=\"%f\"/>", link_id, cluster->bw, cluster->lat);
- s_surf_parsing_link_up_down_t info_lim, info_loop;
+ s_surf_parsing_link_up_down_t info_lim;
+ s_surf_parsing_link_up_down_t info_loop;
// All links are saved in a matrix;
// every row describes a single node; every node may have multiple links.
// the first column may store a link from x to x if p_has_loopback is set
link.latency = cluster->loopback_lat;
link.policy = SURF_LINK_FATPIPE;
sg_platf_new_link(&link);
- info_loop.linkUp = info_loop.linkDown = Link::byName(tmp_link);
+ info_loop.linkUp = Link::byName(tmp_link);
+ 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->linkCountPerNode_, &info_loop);
+ if (rankId*as_cluster->linkCountPerNode_ >= static_cast<int>(as_cluster->privateLinks_.size())){
+ s_surf_parsing_link_up_down_t dummy;
+ dummy.linkUp = nullptr;
+ dummy.linkDown = nullptr;
+ as_cluster->privateLinks_.resize(rankId*as_cluster->linkCountPerNode_,dummy);
+ }
+ as_cluster->privateLinks_.insert(as_cluster->privateLinks_.begin() + rankId*as_cluster->linkCountPerNode_,
+ info_loop);
}
//add a limiter link (shared link to account for maximal bandwidth of the node)
sg_platf_new_link(&link);
info_lim.linkUp = info_lim.linkDown = Link::byName(tmp_link);
free(tmp_link);
- xbt_dynar_set(current_as->privateLinks_, rankId * current_as->linkCountPerNode_ + current_as->hasLoopback_ , &info_lim);
+ current_as->privateLinks_.insert(current_as->privateLinks_.begin() + rankId * current_as->linkCountPerNode_ +
+ current_as->hasLoopback_ , info_lim);
}
//call the cluster function that adds the others links
// If dynar is is greater than netcard id and if the host_link is already defined
auto as_cluster = static_cast<simgrid::kernel::routing::AsCluster*>(current_routing);
- if((int)xbt_dynar_length(as_cluster->privateLinks_) > netcard->id() &&
- xbt_dynar_get_as(as_cluster->privateLinks_, netcard->id(), void*))
- surf_parse_error("Host_link for '%s' is already defined!",hostlink->id);
-
+ if(static_cast<int>(as_cluster->privateLinks_.size()) > netcard->id()){
+ if (as_cluster->privateLinks_.at(netcard->id()).linkUp != nullptr)
+ surf_parse_error("Host_link for '%s' is already defined!",hostlink->id);
+ } else {
+ s_surf_parsing_link_up_down_t dummy;
+ dummy.linkUp = nullptr;
+ dummy.linkDown = nullptr;
+ as_cluster->privateLinks_.resize(netcard->id(), dummy);
+ }
XBT_DEBUG("Push Host_link for host '%s' to position %d", netcard->name(), netcard->id());
- xbt_dynar_set_as(as_cluster->privateLinks_, netcard->id(), s_surf_parsing_link_up_down_t, link_up_down);
+ as_cluster->privateLinks_.insert(as_cluster->privateLinks_.begin() + netcard->id(), link_up_down);
}
for (auto link_name: parsed_link_list) {
simgrid::surf::Link *link = Link::byName(link_name);
route.link_list->push_back(link);
+ xbt_free(link_name);
}
parsed_link_list.clear();
for (auto link_name: parsed_link_list) {
simgrid::surf::Link *link = Link::byName(link_name);
ASroute.link_list->push_back(link);
+ xbt_free(link_name);
}
parsed_link_list.clear();
for (auto link_name: parsed_link_list) {
simgrid::surf::Link *link = Link::byName(link_name);
route.link_list->push_back(link);
+ xbt_free(link_name);
}
parsed_link_list.clear();
for (auto link_name: parsed_link_list) {
simgrid::surf::Link *link = Link::byName(link_name);
ASroute.link_list->push_back(link);
+ xbt_free(link_name);
}
parsed_link_list.clear();
