X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/84c998f37a79bac94865047e272a49baa48985de..0ef25bc8b50d2820e612d6f416bf2c8657b0658e:/src/surf/surf_routing.cpp diff --git a/src/surf/surf_routing.cpp b/src/surf/surf_routing.cpp index 4e5b860411..237c4ed7c3 100644 --- a/src/surf/surf_routing.cpp +++ b/src/surf/surf_routing.cpp @@ -14,18 +14,42 @@ #include "src/surf/platform.hpp" #include "surf/surfxml_parse_values.h" -/************* - * Callbacks * - *************/ +#include "src/surf/surf_routing_cluster_torus.hpp" +#include "src/surf/surf_routing_cluster_fat_tree.hpp" +#include "src/surf/surf_routing_dijkstra.hpp" +#include "src/surf/surf_routing_floyd.hpp" +#include "src/surf/surf_routing_full.hpp" +#include "src/surf/surf_routing_vivaldi.hpp" + +XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_route, surf, "Routing part of surf"); namespace simgrid { namespace surf { -simgrid::xbt::signal netcardCreatedCallbacks; -simgrid::xbt::signal asCreatedCallbacks; + /* Callbacks */ + simgrid::xbt::signal netcardCreatedCallbacks; + simgrid::xbt::signal asCreatedCallbacks; + + As::As(const char*name) + : name_(xbt_strdup(name)) + {} + As::~As() + { + xbt_dict_free(&sons_); + xbt_dynar_free(&p_indexNetworkElm); + xbt_dynar_free(&upDownLinks); + xbt_free(name_); + if (netcard_) + delete netcard_; + } -} -} + int As::addComponent(NetCard *elm) { + XBT_DEBUG("Load component \"%s\"", elm->getName()); + xbt_dynar_push_as(p_indexNetworkElm, NetCard*, elm); + return xbt_dynar_length(p_indexNetworkElm)-1; + } + +}} // namespace simgrid::surf /** * @ingroup SURF_build_api @@ -46,9 +70,6 @@ int COORD_ASR_LEVEL; //Coordinates level int NS3_ASR_LEVEL; //host node for ns3 int ROUTING_PROP_ASR_LEVEL; //Where the properties are stored -static xbt_dict_t random_value = NULL; - - /** @brief Retrieve a netcard from its name * * Netcards are the thing that connect host or routers to the network @@ -65,10 +86,6 @@ simgrid::surf::NetCard *sg_netcard_by_name_or_null(const char *name) /* Global vars */ simgrid::surf::RoutingPlatf *routing_platf = NULL; -/* global parse functions */ -extern xbt_dynar_t mount_list; - -XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_route, surf, "Routing part of surf"); /** The current AS in the parsing */ static simgrid::surf::As *current_routing = NULL; @@ -77,76 +94,29 @@ simgrid::surf::As* routing_get_current() return current_routing; } -static void routing_parse_postparse(void); - -/* this lines are only for replace use like index in the model table */ -typedef enum { - SURF_MODEL_FULL = 0, - SURF_MODEL_FLOYD, - SURF_MODEL_DIJKSTRA, - SURF_MODEL_DIJKSTRACACHE, - SURF_MODEL_NONE, - SURF_MODEL_VIVALDI, - SURF_MODEL_CLUSTER, - SURF_MODEL_TORUS_CLUSTER, - SURF_MODEL_FAT_TREE_CLUSTER, -} e_routing_types; - -struct s_model_type routing_models[] = { - {"Full", - "Full routing data (fast, large memory requirements, fully expressive)", - model_full_create, model_full_end}, - {"Floyd", - "Floyd routing data (slow initialization, fast lookup, lesser memory requirements, shortest path routing only)", - model_floyd_create, model_floyd_end}, - {"Dijkstra", - "Dijkstra routing data (fast initialization, slow lookup, small memory requirements, shortest path routing only)", - model_dijkstra_create, model_dijkstra_both_end}, - {"DijkstraCache", - "Dijkstra routing data (fast initialization, fast lookup, small memory requirements, shortest path routing only)", - model_dijkstracache_create, model_dijkstra_both_end}, - {"none", "No routing (Unless you know what you are doing, avoid using this mode in combination with a non Constant network model).", - model_none_create, NULL}, - {"Vivaldi", "Vivaldi routing", - model_vivaldi_create, NULL}, - {"Cluster", "Cluster routing", - model_cluster_create, NULL}, - {"Torus_Cluster", "Torus Cluster routing", - model_torus_cluster_create, NULL}, - {"Fat_Tree_Cluster", "Fat Tree Cluster routing", - model_fat_tree_cluster_create, NULL}, - {NULL, NULL, NULL, NULL} -}; - -/** - * \brief Add a netcard connecting an host to the network element list - * FIXME: integrate into host constructor - */ -void sg_platf_new_netcard(sg_platf_host_link_cbarg_t netcard) +/** @brief Add a link connecting an host to the rest of its AS (which must be cluster or vivaldi) */ +void sg_platf_new_hostlink(sg_platf_host_link_cbarg_t netcard_arg) { - simgrid::surf::NetCard *info = sg_host_by_name(netcard->id)->pimpl_netcard; - xbt_assert(info, "Host '%s' not found!", netcard->id); - xbt_assert(current_routing->p_modelDesc == &routing_models[SURF_MODEL_CLUSTER] || - current_routing->p_modelDesc == &routing_models[SURF_MODEL_VIVALDI], - "You have to be in model Cluster to use tag host_link!"); + simgrid::surf::NetCard *netcard = sg_host_by_name(netcard_arg->id)->pimpl_netcard; + xbt_assert(netcard, "Host '%s' not found!", netcard_arg->id); + xbt_assert(dynamic_cast(current_routing) || + dynamic_cast(current_routing), + "Only hosts from Cluster and Vivaldi ASes can get a host_link."); s_surf_parsing_link_up_down_t link_up_down; - link_up_down.link_up = Link::byName(netcard->link_up); - link_up_down.link_down = Link::byName(netcard->link_down); - - xbt_assert(link_up_down.link_up, "Link '%s' not found!",netcard->link_up); - xbt_assert(link_up_down.link_down, "Link '%s' not found!",netcard->link_down); + link_up_down.link_up = Link::byName(netcard_arg->link_up); + link_up_down.link_down = Link::byName(netcard_arg->link_down); - if(!current_routing->p_linkUpDownList) - current_routing->p_linkUpDownList = xbt_dynar_new(sizeof(s_surf_parsing_link_up_down_t),NULL); + xbt_assert(link_up_down.link_up, "Link '%s' not found!",netcard_arg->link_up); + xbt_assert(link_up_down.link_down, "Link '%s' not found!",netcard_arg->link_down); // If dynar is is greater than netcard id and if the host_link is already defined - if((int)xbt_dynar_length(current_routing->p_linkUpDownList) > info->getId() && - xbt_dynar_get_as(current_routing->p_linkUpDownList, info->getId(), void*)) - surf_parse_error("Host_link for '%s' is already defined!",netcard->id); + if((int)xbt_dynar_length(current_routing->upDownLinks) > netcard->getId() && + xbt_dynar_get_as(current_routing->upDownLinks, netcard->getId(), void*)) + surf_parse_error("Host_link for '%s' is already defined!",netcard_arg->id); - XBT_DEBUG("Push Host_link for host '%s' to position %d", info->getName(), info->getId()); - xbt_dynar_set_as(current_routing->p_linkUpDownList, info->getId(), s_surf_parsing_link_up_down_t, link_up_down); + XBT_DEBUG("Push Host_link for host '%s' to position %d", netcard->getName(), netcard->getId()); + xbt_dynar_set_as(current_routing->upDownLinks, netcard->getId(), s_surf_parsing_link_up_down_t, link_up_down); } void sg_platf_new_trace(sg_platf_trace_cbarg_t trace) @@ -178,77 +148,64 @@ void sg_platf_new_trace(sg_platf_trace_cbarg_t trace) void routing_AS_begin(sg_platf_AS_cbarg_t AS) { XBT_DEBUG("routing_AS_begin"); - routing_model_description_t model = NULL; - xbt_assert(!xbt_lib_get_or_null - (as_router_lib, AS->id, ROUTING_ASR_LEVEL), - "The AS \"%s\" already exists", AS->id); + xbt_assert(NULL == xbt_lib_get_or_null(as_router_lib, AS->id, ROUTING_ASR_LEVEL), + "Refusing to create a second AS called \"%s\".", AS->id); + + _sg_cfg_init_status = 2; /* HACK: direct access to the global controlling the level of configuration to prevent + * any further config now that we created some real content */ - _sg_cfg_init_status = 2; /* horrible hack: direct access to the global - * controlling the level of configuration to prevent - * any further config */ /* search the routing model */ + simgrid::surf::As *new_as = NULL; switch(AS->routing){ - case A_surfxml_AS_routing_Cluster: model = &routing_models[SURF_MODEL_CLUSTER];break; - case A_surfxml_AS_routing_Cluster___torus: model = &routing_models[SURF_MODEL_TORUS_CLUSTER];break; - case A_surfxml_AS_routing_Cluster___fat___tree: model = &routing_models[SURF_MODEL_FAT_TREE_CLUSTER];break; - case A_surfxml_AS_routing_Dijkstra: model = &routing_models[SURF_MODEL_DIJKSTRA];break; - case A_surfxml_AS_routing_DijkstraCache: model = &routing_models[SURF_MODEL_DIJKSTRACACHE];break; - case A_surfxml_AS_routing_Floyd: model = &routing_models[SURF_MODEL_FLOYD];break; - case A_surfxml_AS_routing_Full: model = &routing_models[SURF_MODEL_FULL];break; - case A_surfxml_AS_routing_None: model = &routing_models[SURF_MODEL_NONE];break; - case A_surfxml_AS_routing_Vivaldi: model = &routing_models[SURF_MODEL_VIVALDI];break; - default: xbt_die("Not a valid model!!!"); - break; + case A_surfxml_AS_routing_Cluster: new_as = new simgrid::surf::AsCluster(AS->id); break; + case A_surfxml_AS_routing_ClusterTorus: new_as = new simgrid::surf::AsClusterTorus(AS->id); break; + case A_surfxml_AS_routing_ClusterFatTree: new_as = new simgrid::surf::AsClusterFatTree(AS->id); break; + case A_surfxml_AS_routing_Dijkstra: new_as = new simgrid::surf::AsDijkstra(AS->id, 0); break; + case A_surfxml_AS_routing_DijkstraCache: new_as = new simgrid::surf::AsDijkstra(AS->id, 1); break; + case A_surfxml_AS_routing_Floyd: new_as = new simgrid::surf::AsFloyd(AS->id); break; + case A_surfxml_AS_routing_Full: new_as = new simgrid::surf::AsFull(AS->id); break; + case A_surfxml_AS_routing_None: new_as = new simgrid::surf::AsNone(AS->id); break; + case A_surfxml_AS_routing_Vivaldi: new_as = new simgrid::surf::AsVivaldi(AS->id); break; + default: xbt_die("Not a valid model!"); break; } /* make a new routing component */ - simgrid::surf::As *new_as = model->create(); - - new_as->p_modelDesc = model; - new_as->p_hierarchy = SURF_ROUTING_NULL; - new_as->p_name = xbt_strdup(AS->id); + simgrid::surf::NetCard *netcard = new simgrid::surf::NetCardImpl(new_as->name_, SURF_NETWORK_ELEMENT_AS, current_routing); - simgrid::surf::NetCard *info = - new simgrid::surf::NetCardImpl(xbt_strdup(new_as->p_name), - -1, - SURF_NETWORK_ELEMENT_AS, - current_routing); if (current_routing == NULL && routing_platf->p_root == NULL) { - /* it is the first one */ - new_as->p_routingFather = NULL; + new_as->father_ = NULL; routing_platf->p_root = new_as; - info->setId(-1); + netcard->setId(-1); } else if (current_routing != NULL && routing_platf->p_root != NULL) { - xbt_assert(!xbt_dict_get_or_null - (current_routing->p_routingSons, AS->id), + xbt_assert(!xbt_dict_get_or_null(current_routing->sons_, AS->id), "The AS \"%s\" already exists", AS->id); /* it is a part of the tree */ - new_as->p_routingFather = current_routing; + new_as->father_ = current_routing; /* set the father behavior */ - if (current_routing->p_hierarchy == SURF_ROUTING_NULL) - current_routing->p_hierarchy = SURF_ROUTING_RECURSIVE; + if (current_routing->hierarchy_ == SURF_ROUTING_NULL) + current_routing->hierarchy_ = SURF_ROUTING_RECURSIVE; /* add to the sons dictionary */ - xbt_dict_set(current_routing->p_routingSons, AS->id, + xbt_dict_set(current_routing->sons_, AS->id, (void *) new_as, NULL); /* add to the father element list */ - info->setId(current_routing->parseAS(info)); + netcard->setId(current_routing->addComponent(netcard)); } else { THROWF(arg_error, 0, "All defined components must belong to a AS"); } - xbt_lib_set(as_router_lib, info->getName(), ROUTING_ASR_LEVEL, - (void *) info); - XBT_DEBUG("Having set name '%s' id '%d'", new_as->p_name, info->getId()); + xbt_lib_set(as_router_lib, netcard->getName(), ROUTING_ASR_LEVEL, + (void *) netcard); + XBT_DEBUG("Having set name '%s' id '%d'", new_as->name_, netcard->getId()); /* set the new current component of the tree */ current_routing = new_as; - current_routing->p_netcard = info; + current_routing->netcard_ = netcard; - simgrid::surf::netcardCreatedCallbacks(info); + simgrid::surf::netcardCreatedCallbacks(netcard); simgrid::surf::asCreatedCallbacks(new_as); } @@ -265,14 +222,9 @@ void routing_AS_begin(sg_platf_AS_cbarg_t AS) */ void routing_AS_end() { - - if (current_routing == NULL) { - THROWF(arg_error, 0, "Close an AS, but none was under construction"); - } else { - if (current_routing->p_modelDesc->end) - current_routing->p_modelDesc->end(current_routing); - current_routing = current_routing->p_routingFather; - } + xbt_assert(current_routing, "Cannot seal the current AS: none under construction"); + current_routing->Seal(); + current_routing = current_routing->father_; } /* Aux Business methods */ @@ -317,12 +269,12 @@ static void elements_father(sg_netcard_t src, sg_netcard_t dst, "Ask for route \"from\"(%s) or \"to\"(%s) no found", src_name, dst_name); /* (2) find the path to the root routing component */ - for (current = src_as; current != NULL; current = current->p_routingFather) { + for (current = src_as; current != NULL; current = current->father_) { if (index_src >= ELEMENTS_FATHER_MAXDEPTH) xbt_die("ELEMENTS_FATHER_MAXDEPTH should be increased for path_src"); path_src[index_src++] = current; } - for (current = dst_as; current != NULL; current = current->p_routingFather) { + for (current = dst_as; current != NULL; current = current->father_) { if (index_dst >= ELEMENTS_FATHER_MAXDEPTH) xbt_die("ELEMENTS_FATHER_MAXDEPTH should be increased for path_dst"); path_dst[index_dst++] = current; @@ -375,7 +327,7 @@ static void _get_route_and_latency( simgrid::surf::As *common_father, *src_father, *dst_father; elements_father(src, dst, &common_father, &src_father, &dst_father); XBT_DEBUG("elements_father: common father '%s' src_father '%s' dst_father '%s'", - common_father->p_name, src_father->p_name, dst_father->p_name); + common_father->name_, src_father->name_, dst_father->name_); /* Check whether a direct bypass is defined */ sg_platf_route_cbarg_t e_route_bypass = NULL; @@ -386,7 +338,7 @@ static void _get_route_and_latency( /* Common ancestor is kind enough to declare a bypass route from src to dst -- use it and bail out */ if (e_route_bypass) { xbt_dynar_merge(links, &e_route_bypass->link_list); - generic_free_route(e_route_bypass); + routing_route_free(e_route_bypass); return; } @@ -402,8 +354,8 @@ static void _get_route_and_latency( route.link_list = xbt_dynar_new(sizeof(sg_routing_link_t), NULL); // Find the net_card corresponding to father - simgrid::surf::NetCard *src_father_netcard = src_father->p_netcard; - simgrid::surf::NetCard *dst_father_netcard = dst_father->p_netcard; + simgrid::surf::NetCard *src_father_netcard = src_father->netcard_; + simgrid::surf::NetCard *dst_father_netcard = dst_father->netcard_; common_father->getRouteAndLatency(src_father_netcard, dst_father_netcard, &route, latency); @@ -481,7 +433,7 @@ xbt_dynar_t RoutingPlatf::recursiveGetOneLinkRoutes(As *rc) char *key; xbt_dict_cursor_t cursor = NULL; AS_t rc_child; - xbt_dict_foreach(rc->p_routingSons, cursor, key, rc_child) { + xbt_dict_foreach(rc->sons_, cursor, key, rc_child) { xbt_dynar_t onelink_child = recursiveGetOneLinkRoutes(rc_child); if (onelink_child) xbt_dynar_merge(&ret,&onelink_child); @@ -501,76 +453,23 @@ e_surf_network_element_type_t routing_get_network_element_type(const char *name) return SURF_NETWORK_ELEMENT_NULL; } -/** - * \brief Generic method: create the global routing schema - * - * Make a global routing structure and set all the parsing functions. - */ +/** @brief create the root AS */ void routing_model_create( void *loopback) { - /* config the uniq global routing */ - routing_platf = new simgrid::surf::RoutingPlatf(); - routing_platf->p_root = NULL; - routing_platf->p_loopback = loopback; - routing_platf->p_lastRoute = xbt_dynar_new(sizeof(sg_routing_link_t),NULL); - /* no current routing at moment */ - current_routing = NULL; + routing_platf = new simgrid::surf::RoutingPlatf(loopback); } - -/* ************************************************** */ -/* ********** PATERN FOR NEW ROUTING **************** */ - -/* The minimal configuration of a new routing model need the next functions, - * also you need to set at the start of the file, the new model in the model - * list. Remember keep the null ending of the list. - */ -/*** Routing model structure ***/ -// typedef struct { -// s_routing_component_t generic_routing; -// /* things that your routing model need */ -// } s_routing_component_NEW_t,*routing_component_NEW_t; - -/*** Parse routing model functions ***/ -// static void model_NEW_set_processing_unit(routing_component_t rc, const char* name) {} -// static void model_NEW_set_autonomous_system(routing_component_t rc, const char* name) {} -// static void model_NEW_set_route(routing_component_t rc, const char* src, const char* dst, route_t route) {} -// static void model_NEW_set_ASroute(routing_component_t rc, const char* src, const char* dst, route_extended_t route) {} -// static void model_NEW_set_bypassroute(routing_component_t rc, const char* src, const char* dst, route_extended_t e_route) {} - -/*** Business methods ***/ -// static route_extended_t NEW_get_route(routing_component_t rc, const char* src,const char* dst) {return NULL;} -// static route_extended_t NEW_get_bypass_route(routing_component_t rc, const char* src,const char* dst) {return NULL;} -// static void NEW_finalize(routing_component_t rc) { xbt_free(rc);} - -/*** Creation routing model functions ***/ -// static void* model_NEW_create(void) { -// routing_component_NEW_t new_component = xbt_new0(s_routing_component_NEW_t,1); -// new_component->generic_routing.set_processing_unit = model_NEW_set_processing_unit; -// new_component->generic_routing.set_autonomous_system = model_NEW_set_autonomous_system; -// new_component->generic_routing.set_route = model_NEW_set_route; -// new_component->generic_routing.set_ASroute = model_NEW_set_ASroute; -// new_component->generic_routing.set_bypassroute = model_NEW_set_bypassroute; -// new_component->generic_routing.get_route = NEW_get_route; -// new_component->generic_routing.get_bypass_route = NEW_get_bypass_route; -// new_component->generic_routing.finalize = NEW_finalize; -// /* initialization of internal structures */ -// return new_component; -// } /* mandatory */ -// static void model_NEW_load(void) {} /* mandatory */ -// static void model_NEW_unload(void) {} /* mandatory */ -// static void model_NEW_end(void) {} /* mandatory */ - /* ************************************************************************** */ /* ************************* GENERIC PARSE FUNCTIONS ************************ */ -void routing_cluster_add_backbone(void* bb) { - xbt_assert(current_routing->p_modelDesc == &routing_models[SURF_MODEL_CLUSTER], - "You have to be in model Cluster to use tag backbone!"); - xbt_assert(!static_cast(current_routing)->p_backbone, "The backbone link is already defined!"); - static_cast(current_routing)->p_backbone = - static_cast(bb); - XBT_DEBUG("Add a backbone to AS '%s'", current_routing->p_name); +void routing_cluster_add_backbone(simgrid::surf::Link* bb) { + simgrid::surf::AsCluster *cluster = dynamic_cast(current_routing); + + xbt_assert(cluster, "Only hosts from Cluster can get a backbone."); + xbt_assert(nullptr == cluster->p_backbone, "Cluster %s already has a backbone link!", cluster->name_); + + cluster->p_backbone = bb; + XBT_DEBUG("Add a backbone to AS '%s'", current_routing->name_); } void sg_platf_new_cabinet(sg_platf_cabinet_cbarg_t cabinet) @@ -632,7 +531,7 @@ void sg_platf_new_cabinet(sg_platf_cabinet_cbarg_t cabinet) host_link.id = host_id; host_link.link_up = link_up; host_link.link_down = link_down; - sg_platf_new_netcard(&host_link); + sg_platf_new_hostlink(&host_link); free(host_id); free(link_id); @@ -645,10 +544,6 @@ void sg_platf_new_cabinet(sg_platf_cabinet_cbarg_t cabinet) xbt_dynar_free(&radical_elements); } -static void routing_parse_postparse(void) { - xbt_dict_free(&random_value); -} - void sg_platf_new_peer(sg_platf_peer_cbarg_t peer) { using simgrid::surf::NetCard; @@ -669,8 +564,6 @@ void sg_platf_new_peer(sg_platf_peer_cbarg_t peer) AS.routing = A_surfxml_AS_routing_Cluster; sg_platf_new_AS_begin(&AS); - current_routing->p_linkUpDownList = xbt_dynar_new(sizeof(s_surf_parsing_link_up_down_t),NULL); - XBT_DEBUG("", host_id, peer->speed); s_sg_platf_host_cbarg_t host = SG_PLATF_HOST_INITIALIZER; memset(&host, 0, sizeof(host)); @@ -714,7 +607,7 @@ void sg_platf_new_peer(sg_platf_peer_cbarg_t peer) host_link.id = host_id; host_link.link_up = link_up; host_link.link_down = link_down; - sg_platf_new_netcard(&host_link); + sg_platf_new_hostlink(&host_link); XBT_DEBUG("", router_id); s_sg_platf_router_cbarg_t router = SG_PLATF_ROUTER_INITIALIZER; @@ -874,7 +767,6 @@ static void check_disk_attachment() void routing_register_callbacks() { - simgrid::surf::on_postparse.connect(routing_parse_postparse); simgrid::surf::on_postparse.connect(check_disk_attachment); instr_routing_define_callbacks(); @@ -893,7 +785,7 @@ static void finalize_rec(simgrid::surf::As *as) { char *key; AS_t elem; - xbt_dict_foreach(as->p_routingSons, cursor, key, elem) { + xbt_dict_foreach(as->sons_, cursor, key, elem) { finalize_rec(elem); } @@ -908,11 +800,15 @@ void routing_exit(void) { namespace simgrid { namespace surf { -RoutingPlatf::~RoutingPlatf() -{ - xbt_dynar_free(&p_lastRoute); - finalize_rec(p_root); -} + RoutingPlatf::RoutingPlatf(void *loopback) + : p_loopback(loopback) + { + } + RoutingPlatf::~RoutingPlatf() + { + xbt_dynar_free(&p_lastRoute); + finalize_rec(p_root); + } } } @@ -922,7 +818,7 @@ AS_t surf_AS_get_routing_root() { } const char *surf_AS_get_name(simgrid::surf::As *as) { - return as->p_name; + return as->name_; } static simgrid::surf::As *surf_AS_recursive_get_by_name( @@ -933,10 +829,10 @@ static simgrid::surf::As *surf_AS_recursive_get_by_name( AS_t elem; simgrid::surf::As *tmp = NULL; - if(!strcmp(current->p_name, name)) + if(!strcmp(current->name_, name)) return current; - xbt_dict_foreach(current->p_routingSons, cursor, key, elem) { + xbt_dict_foreach(current->sons_, cursor, key, elem) { tmp = surf_AS_recursive_get_by_name(elem, name); if(tmp != NULL ) { break; @@ -955,12 +851,7 @@ simgrid::surf::As *surf_AS_get_by_name(const char * name) xbt_dict_t surf_AS_get_routing_sons(simgrid::surf::As *as) { - return as->p_routingSons; -} - -const char *surf_AS_get_model(simgrid::surf::As *as) -{ - return as->p_modelDesc->name; + return as->sons_; } xbt_dynar_t surf_AS_get_hosts(simgrid::surf::As *as)