X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/6a20b94eaec32fb5224c18d21e141bef70da15d8..0ef25bc8b50d2820e612d6f416bf2c8657b0658e:/src/surf/surf_routing.cpp diff --git a/src/surf/surf_routing.cpp b/src/surf/surf_routing.cpp index 5928147380..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 @@ -62,7 +86,6 @@ simgrid::surf::NetCard *sg_netcard_by_name_or_null(const char *name) /* Global vars */ simgrid::surf::RoutingPlatf *routing_platf = NULL; -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; @@ -71,70 +94,29 @@ simgrid::surf::As* routing_get_current() return current_routing; } -/* 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}, - {"Floyd", - "Floyd routing data (slow initialization, fast lookup, lesser memory requirements, shortest path routing only)", - model_floyd_create}, - {"Dijkstra", - "Dijkstra routing data (fast initialization, slow lookup, small memory requirements, shortest path routing only)", - model_dijkstra_create}, - {"DijkstraCache", - "Dijkstra routing data (fast initialization, fast lookup, small memory requirements, shortest path routing only)", - model_dijkstracache_create}, - {"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}, - {"Vivaldi", "Vivaldi routing", model_vivaldi_create}, - {"Cluster", "Cluster routing", model_cluster_create}, - {"Torus_Cluster", "Torus Cluster routing", model_torus_cluster_create}, - {"Fat_Tree_Cluster", "Fat Tree Cluster routing", model_fat_tree_cluster_create}, - {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) @@ -166,76 +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(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; /* horrible hack: direct access to the global - * controlling the level of configuration to prevent - * any further config */ + _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 */ + /* 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(); + simgrid::surf::NetCard *netcard = new simgrid::surf::NetCardImpl(new_as->name_, SURF_NETWORK_ELEMENT_AS, current_routing); - new_as->p_modelDesc = model; - new_as->p_hierarchy = SURF_ROUTING_NULL; - new_as->p_name = xbt_strdup(AS->id); - - 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); } @@ -254,7 +224,7 @@ void routing_AS_end() { xbt_assert(current_routing, "Cannot seal the current AS: none under construction"); current_routing->Seal(); - current_routing = current_routing->p_routingFather; + current_routing = current_routing->father_; } /* Aux Business methods */ @@ -299,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; @@ -357,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; @@ -384,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); @@ -463,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); @@ -492,13 +462,14 @@ void routing_model_create( void *loopback) /* ************************************************************************** */ /* ************************* 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) @@ -560,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); @@ -593,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)); @@ -638,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; @@ -816,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); } @@ -849,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( @@ -860,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; @@ -882,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)