From: Martin Quinson Date: Thu, 11 Feb 2016 14:26:20 +0000 (+0100) Subject: Merge branch 'master' of scm.gforge.inria.fr:/gitroot/simgrid/simgrid X-Git-Tag: v3_13~874 X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/commitdiff_plain/ea7dcd482958d0b2316519f22f754e0074295388?hp=8704bd70e399d9254c97a1b082bc874db2a0a97e Merge branch 'master' of scm.gforge.inria.fr:/gitroot/simgrid/simgrid --- diff --git a/src/surf/network_cm02.cpp b/src/surf/network_cm02.cpp index db6d3ab00e..4ab3280636 100644 --- a/src/surf/network_cm02.cpp +++ b/src/surf/network_cm02.cpp @@ -158,8 +158,7 @@ NetworkCm02Model::NetworkCm02Model() :NetworkModel() { char *optim = xbt_cfg_get_string(_sg_cfg_set, "network/optim"); - int select = - xbt_cfg_get_boolean(_sg_cfg_set, "network/maxmin_selective_update"); + int select = xbt_cfg_get_boolean(_sg_cfg_set, "network/maxmin_selective_update"); if (!strcmp(optim, "Full")) { p_updateMechanism = UM_FULL; @@ -174,7 +173,7 @@ NetworkCm02Model::NetworkCm02Model() } if (!p_maxminSystem) - p_maxminSystem = lmm_system_new(m_selectiveUpdate); + p_maxminSystem = lmm_system_new(m_selectiveUpdate); routing_model_create(createLink("__loopback__", 498000000, NULL, 0.000015, NULL, diff --git a/src/surf/sg_platf.cpp b/src/surf/sg_platf.cpp index 0c7df96202..b324147864 100644 --- a/src/surf/sg_platf.cpp +++ b/src/surf/sg_platf.cpp @@ -11,14 +11,19 @@ #include "xbt/RngStream.h" #include #include "simgrid/platf_interface.h" -#include "surf/surf_routing.h" #include "surf/surf.h" #include "src/simix/smx_private.h" #include "src/surf/platform.hpp" -#include "cpu_interface.hpp" -#include "host_interface.hpp" +#include "src/surf/platform.hpp" +#include "src/surf/cpu_interface.hpp" +#include "src/surf/host_interface.hpp" +#include "src/surf/network_interface.hpp" +#include "surf/surf_routing.h" // FIXME: brain dead public header +#include "src/surf/surf_routing_cluster.hpp" +#include "src/surf/surf_routing_cluster_torus.hpp" +#include "src/surf/surf_routing_cluster_fat_tree.hpp" XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(surf_parse); @@ -156,7 +161,260 @@ void sg_platf_new_link(sg_platf_link_cbarg_t link){ void sg_platf_new_cluster(sg_platf_cluster_cbarg_t cluster) { - routing_new_cluster(cluster); + using simgrid::surf::AsCluster; + using simgrid::surf::AsClusterTorus; + using simgrid::surf::AsClusterFatTree; + + char *host_id, *groups, *link_id = NULL; + xbt_dict_t patterns = NULL; + int rankId=0; + + s_sg_platf_host_cbarg_t host = SG_PLATF_HOST_INITIALIZER; + s_sg_platf_link_cbarg_t link = SG_PLATF_LINK_INITIALIZER; + + unsigned int iter; + int start, end, i; + xbt_dynar_t radical_elements; + xbt_dynar_t radical_ends; + + if ((cluster->availability_trace && strcmp(cluster->availability_trace, "")) + || (cluster->state_trace && strcmp(cluster->state_trace, ""))) { + patterns = xbt_dict_new_homogeneous(xbt_free_f); + xbt_dict_set(patterns, "id", xbt_strdup(cluster->id), NULL); + xbt_dict_set(patterns, "prefix", xbt_strdup(cluster->prefix), NULL); + xbt_dict_set(patterns, "suffix", xbt_strdup(cluster->suffix), NULL); + } + + /* Parse the topology attributes. + * Nothing to do in a vanilla cluster, but that's another story for torus and flat_trees */ + s_sg_platf_AS_cbarg_t AS = SG_PLATF_AS_INITIALIZER; + AS.id = cluster->id; + + switch (cluster->topology) { + case SURF_CLUSTER_TORUS: + XBT_DEBUG("", cluster->id); + AS.routing = A_surfxml_AS_routing_Cluster___torus; + break; + case SURF_CLUSTER_FAT_TREE: + XBT_DEBUG("", cluster->id); + AS.routing = A_surfxml_AS_routing_Cluster___fat___tree; + break; + default: + XBT_DEBUG("", cluster->id); + AS.routing = A_surfxml_AS_routing_Cluster; + break; + } + + // What an inventive way of initializing the AS that I have as ancestor :-( + sg_platf_new_AS_begin(&AS); + simgrid::surf::As *current_routing = routing_get_current(); + static_cast(current_routing)->parse_specific_arguments(cluster); + + if(cluster->loopback_bw!=0 || cluster->loopback_lat!=0){ + ((AsCluster*)current_routing)->p_nb_links_per_node++; + ((AsCluster*)current_routing)->p_has_loopback=1; + } + + if(cluster->limiter_link!=0){ + ((AsCluster*)current_routing)->p_nb_links_per_node++; + ((AsCluster*)current_routing)->p_has_limiter=1; + } + + + current_routing->p_linkUpDownList + = xbt_dynar_new(sizeof(s_surf_parsing_link_up_down_t),NULL); + + //Make all hosts + radical_elements = xbt_str_split(cluster->radical, ","); + xbt_dynar_foreach(radical_elements, iter, groups) { + + radical_ends = xbt_str_split(groups, "-"); + start = surf_parse_get_int(xbt_dynar_get_as(radical_ends, 0, char *)); + + switch (xbt_dynar_length(radical_ends)) { + case 1: + end = start; + break; + case 2: + end = surf_parse_get_int(xbt_dynar_get_as(radical_ends, 1, char *)); + break; + default: + surf_parse_error("Malformed radical"); + break; + } + for (i = start; i <= end; i++) { + host_id = + bprintf("%s%d%s", cluster->prefix, i, cluster->suffix); + link_id = bprintf("%s_link_%d", cluster->id, i); + + XBT_DEBUG("", host_id, cluster->speed); + + memset(&host, 0, sizeof(host)); + host.id = host_id; + if ((cluster->properties != NULL) && (!xbt_dict_is_empty(cluster->properties))) { + xbt_dict_cursor_t cursor=NULL; + char *key,*data; + host.properties = xbt_dict_new(); + + xbt_dict_foreach(cluster->properties,cursor,key,data) { + xbt_dict_set(host.properties, key, xbt_strdup(data),free); + } + } + if (cluster->availability_trace && strcmp(cluster->availability_trace, "")) { + xbt_dict_set(patterns, "radical", bprintf("%d", i), NULL); + char *avail_file = xbt_str_varsubst(cluster->availability_trace, patterns); + XBT_DEBUG("\tavailability_file=\"%s\"", avail_file); + host.speed_trace = tmgr_trace_new_from_file(avail_file); + xbt_free(avail_file); + } else { + XBT_DEBUG("\tavailability_file=\"\""); + } + + if (cluster->state_trace && strcmp(cluster->state_trace, "")) { + char *avail_file = xbt_str_varsubst(cluster->state_trace, patterns); + XBT_DEBUG("\tstate_file=\"%s\"", avail_file); + host.state_trace = tmgr_trace_new_from_file(avail_file); + xbt_free(avail_file); + } else { + XBT_DEBUG("\tstate_file=\"\""); + } + + host.speed_peak = xbt_dynar_new(sizeof(double), NULL); + xbt_dynar_push(host.speed_peak,&cluster->speed); + host.pstate = 0; + + //host.power_peak = cluster->power; + host.speed_scale = 1.0; + host.core_amount = cluster->core_amount; + host.initiallyOn = 1; + host.coord = ""; + sg_platf_new_host(&host); + xbt_dynar_free(&host.speed_peak); + XBT_DEBUG(""); + + XBT_DEBUG("", link_id, + cluster->bw, cluster->lat); + + + s_surf_parsing_link_up_down_t info_lim, 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 + // the second column may store a limiter link if p_has_limiter is set + // other columns are to store one or more link for the node + + //add a loopback link + if(cluster->loopback_bw!=0 || cluster->loopback_lat!=0){ + char *tmp_link = bprintf("%s_loopback", link_id); + XBT_DEBUG("", tmp_link, + cluster->limiter_link); + + + memset(&link, 0, sizeof(link)); + link.id = tmp_link; + link.bandwidth = cluster->loopback_bw; + link.latency = cluster->loopback_lat; + link.initiallyOn = 1; + link.policy = SURF_LINK_FATPIPE; + sg_platf_new_link(&link); + info_loop.link_up = Link::byName(tmp_link); + info_loop.link_down = info_loop.link_up; + free(tmp_link); + xbt_dynar_set(current_routing->p_linkUpDownList, + rankId*(static_cast(current_routing))->p_nb_links_per_node, &info_loop); + } + + //add a limiter link (shared link to account for maximal bandwidth of the node) + if(cluster->limiter_link!=0){ + char *tmp_link = bprintf("%s_limiter", link_id); + XBT_DEBUG("", tmp_link, + cluster->limiter_link); + + + memset(&link, 0, sizeof(link)); + link.id = tmp_link; + link.bandwidth = cluster->limiter_link; + link.latency = 0; + link.initiallyOn = 1; + link.policy = SURF_LINK_SHARED; + sg_platf_new_link(&link); + info_lim.link_up = Link::byName(tmp_link); + info_lim.link_down = info_lim.link_up; + free(tmp_link); + auto as_cluster = static_cast(current_routing); + xbt_dynar_set(current_routing->p_linkUpDownList, + rankId*(as_cluster)->p_nb_links_per_node + as_cluster->p_has_loopback , + &info_lim); + + } + + + //call the cluster function that adds the others links + if (cluster->topology == SURF_CLUSTER_FAT_TREE) { + ((AsClusterFatTree*) current_routing)->addProcessingNode(i); + } + else { + static_cast(current_routing)->create_links_for_node(cluster, i, rankId, rankId* + static_cast(current_routing)->p_nb_links_per_node + + static_cast(current_routing)->p_has_loopback + + static_cast(current_routing)->p_has_limiter ); + } + xbt_free(link_id); + xbt_free(host_id); + rankId++; + } + + xbt_dynar_free(&radical_ends); + } + xbt_dynar_free(&radical_elements); + + // For fat trees, the links must be created once all nodes have been added + if(cluster->topology == SURF_CLUSTER_FAT_TREE) { + static_cast(current_routing)->create_links(); + } + // Add a router. It is magically used thanks to the way in which surf_routing_cluster is written, + // and it's very useful to connect clusters together + XBT_DEBUG(" "); + XBT_DEBUG("", cluster->router_id); + char *newid = NULL; + s_sg_platf_router_cbarg_t router = SG_PLATF_ROUTER_INITIALIZER; + memset(&router, 0, sizeof(router)); + router.id = cluster->router_id; + router.coord = ""; + if (!router.id || !strcmp(router.id, "")) + router.id = newid = + bprintf("%s%s_router%s", cluster->prefix, cluster->id, + cluster->suffix); + sg_platf_new_router(&router); + ((AsCluster*)current_routing)->p_router = (simgrid::surf::NetCard*) xbt_lib_get_or_null(as_router_lib, router.id, ROUTING_ASR_LEVEL); + free(newid); + + //Make the backbone + if ((cluster->bb_bw != 0) || (cluster->bb_lat != 0)) { + char *link_backbone = bprintf("%s_backbone", cluster->id); + XBT_DEBUG("", link_backbone, + cluster->bb_bw, cluster->bb_lat); + + memset(&link, 0, sizeof(link)); + link.id = link_backbone; + link.bandwidth = cluster->bb_bw; + link.latency = cluster->bb_lat; + link.initiallyOn = 1; + link.policy = cluster->bb_sharing_policy; + + sg_platf_new_link(&link); + + routing_cluster_add_backbone(Link::byName(link_backbone)); + + free(link_backbone); + } + + XBT_DEBUG(""); + sg_platf_new_AS_end(); + XBT_DEBUG(" "); + xbt_dict_free(&patterns); // no op if it were never set + simgrid::surf::on_cluster(cluster); } diff --git a/src/surf/surf_private.h b/src/surf/surf_private.h index e2ecdcbd9e..df6151d23c 100644 --- a/src/surf/surf_private.h +++ b/src/surf/surf_private.h @@ -55,7 +55,6 @@ typedef struct s_model_type { const char *name; const char *desc; AS_t (*create) (); - void (*end) (AS_t as); } s_routing_model_description_t, *routing_model_description_t; /* This enum used in the routing structure helps knowing in which situation we are. */ @@ -72,11 +71,8 @@ XBT_PUBLIC(void) routing_model_create(void *loopback); XBT_PUBLIC(void) routing_exit(void); XBT_PUBLIC(void) storage_register_callbacks(void); -XBT_PRIVATE void routing_new_cluster(sg_platf_cluster_cbarg_t cluster); - XBT_PUBLIC(void) routing_register_callbacks(void); -XBT_PUBLIC(void) generic_free_route(sg_platf_route_cbarg_t route); // FIXME rename to routing_route_free - // FIXME: make previous function private to routing again? +XBT_PUBLIC(void) routing_route_free(sg_platf_route_cbarg_t route); // FIXME: make previous function private to routing again? XBT_PUBLIC(void) generic_get_graph(xbt_graph_t graph, xbt_dict_t nodes, xbt_dict_t edges, AS_t rc); /** diff --git a/src/surf/surf_routing.cpp b/src/surf/surf_routing.cpp index b196348bc7..66f1972b80 100644 --- a/src/surf/surf_routing.cpp +++ b/src/surf/surf_routing.cpp @@ -7,8 +7,6 @@ #include "surf_routing.hpp" #include "surf_routing_private.hpp" #include "surf_routing_cluster.hpp" -#include "surf_routing_cluster_torus.hpp" -#include "surf_routing_cluster_fat_tree.hpp" #include "simgrid/platf_interface.h" // platform creation API internal interface #include "simgrid/sg_config.h" @@ -48,9 +46,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 @@ -67,9 +62,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 */ @@ -79,8 +71,6 @@ 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, @@ -97,27 +87,23 @@ typedef enum { struct s_model_type routing_models[] = { {"Full", "Full routing data (fast, large memory requirements, fully expressive)", - model_full_create, model_full_end}, + model_full_create}, {"Floyd", "Floyd routing data (slow initialization, fast lookup, lesser memory requirements, shortest path routing only)", - model_floyd_create, model_floyd_end}, + model_floyd_create}, {"Dijkstra", "Dijkstra routing data (fast initialization, slow lookup, small memory requirements, shortest path routing only)", - model_dijkstra_create, model_dijkstra_both_end}, + model_dijkstra_create}, {"DijkstraCache", "Dijkstra routing data (fast initialization, fast lookup, small memory requirements, shortest path routing only)", - model_dijkstracache_create, model_dijkstra_both_end}, + 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, 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} + 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} }; /** @@ -271,8 +257,7 @@ 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->Seal(); current_routing = current_routing->p_routingFather; } } @@ -388,7 +373,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; } @@ -503,66 +488,12 @@ 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 ************************ */ @@ -647,265 +578,6 @@ void sg_platf_new_cabinet(sg_platf_cabinet_cbarg_t cabinet) xbt_dynar_free(&radical_elements); } -void routing_new_cluster(sg_platf_cluster_cbarg_t cluster) -{ - using simgrid::surf::AsCluster; - using simgrid::surf::AsClusterTorus; - using simgrid::surf::AsClusterFatTree; - - char *host_id, *groups, *link_id = NULL; - xbt_dict_t patterns = NULL; - int rankId=0; - - s_sg_platf_host_cbarg_t host = SG_PLATF_HOST_INITIALIZER; - s_sg_platf_link_cbarg_t link = SG_PLATF_LINK_INITIALIZER; - - unsigned int iter; - int start, end, i; - xbt_dynar_t radical_elements; - xbt_dynar_t radical_ends; - - if ((cluster->availability_trace && strcmp(cluster->availability_trace, "")) - || (cluster->state_trace && strcmp(cluster->state_trace, ""))) { - patterns = xbt_dict_new_homogeneous(xbt_free_f); - xbt_dict_set(patterns, "id", xbt_strdup(cluster->id), NULL); - xbt_dict_set(patterns, "prefix", xbt_strdup(cluster->prefix), NULL); - xbt_dict_set(patterns, "suffix", xbt_strdup(cluster->suffix), NULL); - } - - /* Parse the topology attributes. - * Nothing to do in a vanilla cluster, but that's another story for torus and flat_trees */ - s_sg_platf_AS_cbarg_t AS = SG_PLATF_AS_INITIALIZER; - AS.id = cluster->id; - - switch (cluster->topology) { - case SURF_CLUSTER_TORUS: - XBT_DEBUG("", cluster->id); - AS.routing = A_surfxml_AS_routing_Cluster___torus; - break; - case SURF_CLUSTER_FAT_TREE: - XBT_DEBUG("", cluster->id); - AS.routing = A_surfxml_AS_routing_Cluster___fat___tree; - break; - default: - XBT_DEBUG("", cluster->id); - AS.routing = A_surfxml_AS_routing_Cluster; - break; - } - - sg_platf_new_AS_begin(&AS); - static_cast(current_routing)->parse_specific_arguments(cluster); - - if(cluster->loopback_bw!=0 || cluster->loopback_lat!=0){ - ((AsCluster*)current_routing)->p_nb_links_per_node++; - ((AsCluster*)current_routing)->p_has_loopback=1; - } - - if(cluster->limiter_link!=0){ - ((AsCluster*)current_routing)->p_nb_links_per_node++; - ((AsCluster*)current_routing)->p_has_limiter=1; - } - - - current_routing->p_linkUpDownList - = xbt_dynar_new(sizeof(s_surf_parsing_link_up_down_t),NULL); - - //Make all hosts - radical_elements = xbt_str_split(cluster->radical, ","); - xbt_dynar_foreach(radical_elements, iter, groups) { - - radical_ends = xbt_str_split(groups, "-"); - start = surf_parse_get_int(xbt_dynar_get_as(radical_ends, 0, char *)); - - switch (xbt_dynar_length(radical_ends)) { - case 1: - end = start; - break; - case 2: - end = surf_parse_get_int(xbt_dynar_get_as(radical_ends, 1, char *)); - break; - default: - surf_parse_error("Malformed radical"); - break; - } - for (i = start; i <= end; i++) { - host_id = - bprintf("%s%d%s", cluster->prefix, i, cluster->suffix); - link_id = bprintf("%s_link_%d", cluster->id, i); - - XBT_DEBUG("", host_id, cluster->speed); - - memset(&host, 0, sizeof(host)); - host.id = host_id; - if ((cluster->properties != NULL) && (!xbt_dict_is_empty(cluster->properties))) { - xbt_dict_cursor_t cursor=NULL; - char *key,*data; - host.properties = xbt_dict_new(); - - xbt_dict_foreach(cluster->properties,cursor,key,data) { - xbt_dict_set(host.properties, key, xbt_strdup(data),free); - } - } - if (cluster->availability_trace && strcmp(cluster->availability_trace, "")) { - xbt_dict_set(patterns, "radical", bprintf("%d", i), NULL); - char *avail_file = xbt_str_varsubst(cluster->availability_trace, patterns); - XBT_DEBUG("\tavailability_file=\"%s\"", avail_file); - host.speed_trace = tmgr_trace_new_from_file(avail_file); - xbt_free(avail_file); - } else { - XBT_DEBUG("\tavailability_file=\"\""); - } - - if (cluster->state_trace && strcmp(cluster->state_trace, "")) { - char *avail_file = xbt_str_varsubst(cluster->state_trace, patterns); - XBT_DEBUG("\tstate_file=\"%s\"", avail_file); - host.state_trace = tmgr_trace_new_from_file(avail_file); - xbt_free(avail_file); - } else { - XBT_DEBUG("\tstate_file=\"\""); - } - - host.speed_peak = xbt_dynar_new(sizeof(double), NULL); - xbt_dynar_push(host.speed_peak,&cluster->speed); - host.pstate = 0; - - //host.power_peak = cluster->power; - host.speed_scale = 1.0; - host.core_amount = cluster->core_amount; - host.initiallyOn = 1; - host.coord = ""; - sg_platf_new_host(&host); - xbt_dynar_free(&host.speed_peak); - XBT_DEBUG(""); - - XBT_DEBUG("", link_id, - cluster->bw, cluster->lat); - - - s_surf_parsing_link_up_down_t info_lim, 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 - // the second column may store a limiter link if p_has_limiter is set - // other columns are to store one or more link for the node - - //add a loopback link - if(cluster->loopback_bw!=0 || cluster->loopback_lat!=0){ - char *tmp_link = bprintf("%s_loopback", link_id); - XBT_DEBUG("", tmp_link, - cluster->limiter_link); - - - memset(&link, 0, sizeof(link)); - link.id = tmp_link; - link.bandwidth = cluster->loopback_bw; - link.latency = cluster->loopback_lat; - link.initiallyOn = 1; - link.policy = SURF_LINK_FATPIPE; - sg_platf_new_link(&link); - info_loop.link_up = Link::byName(tmp_link); - info_loop.link_down = info_loop.link_up; - free(tmp_link); - xbt_dynar_set(current_routing->p_linkUpDownList, - rankId*(static_cast(current_routing))->p_nb_links_per_node, &info_loop); - } - - //add a limiter link (shared link to account for maximal bandwidth of the node) - if(cluster->limiter_link!=0){ - char *tmp_link = bprintf("%s_limiter", link_id); - XBT_DEBUG("", tmp_link, - cluster->limiter_link); - - - memset(&link, 0, sizeof(link)); - link.id = tmp_link; - link.bandwidth = cluster->limiter_link; - link.latency = 0; - link.initiallyOn = 1; - link.policy = SURF_LINK_SHARED; - sg_platf_new_link(&link); - info_lim.link_up = Link::byName(tmp_link); - info_lim.link_down = info_lim.link_up; - free(tmp_link); - auto as_cluster = static_cast(current_routing); - xbt_dynar_set(current_routing->p_linkUpDownList, - rankId*(as_cluster)->p_nb_links_per_node + as_cluster->p_has_loopback , - &info_lim); - - } - - - //call the cluster function that adds the others links - if (cluster->topology == SURF_CLUSTER_FAT_TREE) { - ((AsClusterFatTree*) current_routing)->addProcessingNode(i); - } - else { - static_cast(current_routing)->create_links_for_node(cluster, i, rankId, rankId* - static_cast(current_routing)->p_nb_links_per_node - + static_cast(current_routing)->p_has_loopback - + static_cast(current_routing)->p_has_limiter ); - } - xbt_free(link_id); - xbt_free(host_id); - rankId++; - } - - xbt_dynar_free(&radical_ends); - } - xbt_dynar_free(&radical_elements); - - // For fat trees, the links must be created once all nodes have been added - if(cluster->topology == SURF_CLUSTER_FAT_TREE) { - static_cast(current_routing)->create_links(); - } - // Add a router. It is magically used thanks to the way in which surf_routing_cluster is written, - // and it's very useful to connect clusters together - XBT_DEBUG(" "); - XBT_DEBUG("", cluster->router_id); - char *newid = NULL; - s_sg_platf_router_cbarg_t router = SG_PLATF_ROUTER_INITIALIZER; - memset(&router, 0, sizeof(router)); - router.id = cluster->router_id; - router.coord = ""; - if (!router.id || !strcmp(router.id, "")) - router.id = newid = - bprintf("%s%s_router%s", cluster->prefix, cluster->id, - cluster->suffix); - sg_platf_new_router(&router); - ((AsCluster*)current_routing)->p_router = (simgrid::surf::NetCard*) xbt_lib_get_or_null(as_router_lib, router.id, ROUTING_ASR_LEVEL); - free(newid); - - //Make the backbone - if ((cluster->bb_bw != 0) || (cluster->bb_lat != 0)) { - char *link_backbone = bprintf("%s_backbone", cluster->id); - XBT_DEBUG("", link_backbone, - cluster->bb_bw, cluster->bb_lat); - - memset(&link, 0, sizeof(link)); - link.id = link_backbone; - link.bandwidth = cluster->bb_bw; - link.latency = cluster->bb_lat; - link.initiallyOn = 1; - link.policy = cluster->bb_sharing_policy; - - sg_platf_new_link(&link); - - routing_cluster_add_backbone(Link::byName(link_backbone)); - - free(link_backbone); - } - - XBT_DEBUG(""); - sg_platf_new_AS_end(); - XBT_DEBUG(" "); - xbt_dict_free(&patterns); // no op if it were never set -} - -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; @@ -1131,7 +803,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(); @@ -1165,11 +836,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); + } } } diff --git a/src/surf/surf_routing.hpp b/src/surf/surf_routing.hpp index c3801295dd..6096197350 100644 --- a/src/surf/surf_routing.hpp +++ b/src/surf/surf_routing.hpp @@ -58,14 +58,10 @@ public: NetCard *p_netcard; xbt_dynar_t p_linkUpDownList = NULL; - /** - * @brief The As constructor - */ As(){}; + /* Close that AS: no more content can be added to it */ + virtual void Seal()=0; - /** - * @brief The As destructor - */ virtual ~As(){ xbt_dict_free(&p_routingSons); xbt_dynar_free(&p_indexNetworkElm); @@ -148,10 +144,11 @@ public: */ XBT_PUBLIC_CLASS RoutingPlatf { public: + RoutingPlatf(void *loopback); ~RoutingPlatf(); - As *p_root; + As *p_root = nullptr; void *p_loopback; - xbt_dynar_t p_lastRoute; + xbt_dynar_t p_lastRoute = xbt_dynar_new(sizeof(sg_routing_link_t),NULL); xbt_dynar_t getOneLinkRoutes(void); xbt_dynar_t recursiveGetOneLinkRoutes(As *rc); void getRouteAndLatency(NetCard *src, NetCard *dst, xbt_dynar_t * links, double *latency); diff --git a/src/surf/surf_routing_cluster.hpp b/src/surf/surf_routing_cluster.hpp index c1962f0c28..5d7123192c 100644 --- a/src/surf/surf_routing_cluster.hpp +++ b/src/surf/surf_routing_cluster.hpp @@ -27,6 +27,7 @@ class XBT_PRIVATE AsCluster; class AsCluster: public AsNone { public: AsCluster() {} + void Seal() override {}; // nothing to do virtual void getRouteAndLatency(NetCard *src, NetCard *dst, sg_platf_route_cbarg_t into, double *latency) override; void getGraph(xbt_graph_t graph, xbt_dict_t nodes, xbt_dict_t edges) override; @@ -36,6 +37,7 @@ public: 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) {} + Link* p_backbone = nullptr; void *p_loopback = nullptr; NetCard *p_router = nullptr; diff --git a/src/surf/surf_routing_dijkstra.cpp b/src/surf/surf_routing_dijkstra.cpp index dbf3931623..ccdeaadbcd 100644 --- a/src/surf/surf_routing_dijkstra.cpp +++ b/src/surf/surf_routing_dijkstra.cpp @@ -44,41 +44,36 @@ AS_t model_dijkstracache_create(void){ return new simgrid::surf::AsDijkstra(1); } -void model_dijkstra_both_end(AS_t as) -{ - simgrid::surf::AsDijkstra *THIS_AS - = static_cast(as); - xbt_node_t node = NULL; - unsigned int cursor2; - xbt_dynar_t nodes = NULL; +/* Utility functions */ +namespace simgrid { +namespace surf { +void AsDijkstra::Seal() +{ /* Create the topology graph */ - if(!THIS_AS->p_routeGraph) - THIS_AS->p_routeGraph = xbt_graph_new_graph(1, NULL); - if(!THIS_AS->p_graphNodeMap) - THIS_AS->p_graphNodeMap = xbt_dict_new_homogeneous(&graph_node_map_elem_free); + if(!p_routeGraph) + p_routeGraph = xbt_graph_new_graph(1, NULL); + if(!p_graphNodeMap) + p_graphNodeMap = xbt_dict_new_homogeneous(&graph_node_map_elem_free); - if (THIS_AS->m_cached && !THIS_AS->p_routeCache) - THIS_AS->p_routeCache = xbt_dict_new_homogeneous(&route_cache_elem_free); + if (m_cached && !p_routeCache) + p_routeCache = xbt_dict_new_homogeneous(&route_cache_elem_free); /* Add the loopback if needed */ - if (routing_platf->p_loopback && as->p_hierarchy == SURF_ROUTING_BASE) - THIS_AS->addLoopback(); + if (routing_platf->p_loopback && p_hierarchy == SURF_ROUTING_BASE) + addLoopback(); /* initialize graph indexes in nodes after graph has been built */ - nodes = xbt_graph_get_nodes(THIS_AS->p_routeGraph); + xbt_dynar_t nodes = xbt_graph_get_nodes(p_routeGraph); + xbt_node_t node = NULL; + unsigned int cursor2; xbt_dynar_foreach(nodes, cursor2, node) { graph_node_data_t data = (graph_node_data_t) xbt_graph_node_get_data(node); data->graph_id = cursor2; } } -/* Utility functions */ - -namespace simgrid { -namespace surf { - xbt_node_t AsDijkstra::routeGraphNewNode(int id, int graph_id) { xbt_node_t node = NULL; diff --git a/src/surf/surf_routing_dijkstra.hpp b/src/surf/surf_routing_dijkstra.hpp index bcae26f09f..7f6e4b8c26 100644 --- a/src/surf/surf_routing_dijkstra.hpp +++ b/src/surf/surf_routing_dijkstra.hpp @@ -37,6 +37,8 @@ class XBT_PRIVATE AsDijkstra; class AsDijkstra : public AsGeneric { public: AsDijkstra(); + void Seal() override; + AsDijkstra(bool cached); ~AsDijkstra(); xbt_node_t routeGraphNewNode(int id, int graph_id); diff --git a/src/surf/surf_routing_floyd.cpp b/src/surf/surf_routing_floyd.cpp index 7f2c653bb8..ffe8e5a623 100644 --- a/src/surf/surf_routing_floyd.cpp +++ b/src/surf/surf_routing_floyd.cpp @@ -19,11 +19,6 @@ AS_t model_floyd_create(void) return new simgrid::surf::AsFloyd(); } -void model_floyd_end(AS_t current_routing) -{ - static_cast(current_routing)->end(); -} - namespace simgrid { namespace surf { @@ -42,7 +37,7 @@ AsFloyd::~AsFloyd(){ /* Delete link_table */ for (i = 0; i < table_size; i++) for (j = 0; j < table_size; j++) { - generic_free_route(TO_FLOYD_LINK(i, j)); + routing_route_free(TO_FLOYD_LINK(i, j)); } xbt_free(p_linkTable); /* Delete bypass dict */ @@ -269,7 +264,7 @@ void AsFloyd::parseRoute(sg_platf_route_cbarg_t route) xbt_dynar_free(&route->link_list); } -void AsFloyd::end(){ +void AsFloyd::Seal(){ unsigned int i, j, a, b, c; /* set the size of table routing */ diff --git a/src/surf/surf_routing_floyd.hpp b/src/surf/surf_routing_floyd.hpp index 5f498f4357..c9ab30ba2f 100644 --- a/src/surf/surf_routing_floyd.hpp +++ b/src/surf/surf_routing_floyd.hpp @@ -29,7 +29,7 @@ public: xbt_dynar_t getOneLinkRoutes() override; void parseASroute(sg_platf_route_cbarg_t route) override; void parseRoute(sg_platf_route_cbarg_t route) override; - void end(); + void Seal() override; private: /* vars to compute the Floyd algorithm. */ diff --git a/src/surf/surf_routing_full.cpp b/src/surf/surf_routing_full.cpp index 67363d71e9..f80b2f6440 100644 --- a/src/surf/surf_routing_full.cpp +++ b/src/surf/surf_routing_full.cpp @@ -17,38 +17,35 @@ AS_t model_full_create(void) return new simgrid::surf::AsFull(); } -void model_full_end(AS_t _routing) -{ +namespace simgrid { +namespace surf { +void AsFull::Seal() { int i; sg_platf_route_cbarg_t e_route; /* set utils vars */ - simgrid::surf::AsFull *routing = static_cast(_routing); - int table_size = (int)xbt_dynar_length(routing->p_indexNetworkElm); + int table_size = (int)xbt_dynar_length(p_indexNetworkElm); /* Create table if necessary */ - if (!routing->p_routingTable) - routing->p_routingTable = xbt_new0(sg_platf_route_cbarg_t, table_size * table_size); + if (!p_routingTable) + p_routingTable = xbt_new0(sg_platf_route_cbarg_t, table_size * table_size); /* Add the loopback if needed */ - if (routing_platf->p_loopback && routing->p_hierarchy == SURF_ROUTING_BASE) { + if (routing_platf->p_loopback && p_hierarchy == SURF_ROUTING_BASE) { for (i = 0; i < table_size; i++) { - e_route = routing->TO_ROUTE_FULL(i, i); + e_route = TO_ROUTE_FULL(i, i); if (!e_route) { e_route = xbt_new0(s_sg_platf_route_cbarg_t, 1); e_route->gw_src = NULL; e_route->gw_dst = NULL; e_route->link_list = xbt_dynar_new(sizeof(sg_routing_link_t), NULL); xbt_dynar_push(e_route->link_list, &routing_platf->p_loopback); - routing->TO_ROUTE_FULL(i, i) = e_route; + TO_ROUTE_FULL(i, i) = e_route; } } } } -namespace simgrid { -namespace surf { - AsFull::~AsFull(){ if (p_routingTable) { int table_size = (int)xbt_dynar_length(p_indexNetworkElm); diff --git a/src/surf/surf_routing_full.hpp b/src/surf/surf_routing_full.hpp index c7b662421a..77debc1acb 100644 --- a/src/surf/surf_routing_full.hpp +++ b/src/surf/surf_routing_full.hpp @@ -23,6 +23,7 @@ class AsFull: public AsGeneric { public: AsFull() {} + void Seal() override; ~AsFull(); void getRouteAndLatency(NetCard *src, NetCard *dst, sg_platf_route_cbarg_t into, double *latency) override; diff --git a/src/surf/surf_routing_generic.cpp b/src/surf/surf_routing_generic.cpp index fb94ab5d70..c455405087 100644 --- a/src/surf/surf_routing_generic.cpp +++ b/src/surf/surf_routing_generic.cpp @@ -24,7 +24,7 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_routing_generic, surf_route, "Generic imple static int no_bypassroute_declared = 1; -void generic_free_route(sg_platf_route_cbarg_t route) +void routing_route_free(sg_platf_route_cbarg_t route) { if (route) { xbt_dynar_free(&route->link_list); @@ -48,7 +48,7 @@ void AsGeneric::getRouteAndLatency(NetCard */*src*/, NetCard */*dst*/, sg_platf_ } AsGeneric::AsGeneric() { - p_bypassRoutes = xbt_dict_new_homogeneous((void (*)(void *)) generic_free_route); + p_bypassRoutes = xbt_dict_new_homogeneous((void (*)(void *)) routing_route_free); } AsGeneric::~AsGeneric() { diff --git a/src/surf/surf_routing_none.hpp b/src/surf/surf_routing_none.hpp index b706f89832..a81babf4dd 100644 --- a/src/surf/surf_routing_none.hpp +++ b/src/surf/surf_routing_none.hpp @@ -17,6 +17,7 @@ namespace surf { class XBT_PRIVATE AsNone : public As { public: AsNone() {} + void Seal() override {}; // nothing to do ~AsNone() {} void getRouteAndLatency(NetCard *src, NetCard *dst, sg_platf_route_cbarg_t into, double *latency) override; diff --git a/src/surf/surf_routing_private.hpp b/src/surf/surf_routing_private.hpp index d3caf8d681..36c6f731b8 100644 --- a/src/surf/surf_routing_private.hpp +++ b/src/surf/surf_routing_private.hpp @@ -60,7 +60,6 @@ void generic_src_dst_check(AS_t rc, sg_netcard_t src, /* ************************************************************************** */ /* *************************** FLOYD ROUTING ******************************** */ XBT_PRIVATE AS_t model_floyd_create(void); /* create structures for floyd routing model */ -XBT_PRIVATE void model_floyd_end(AS_t as); /* finalize the creation of floyd routing model */ XBT_PRIVATE void model_floyd_parse_route(AS_t rc, sg_platf_route_cbarg_t route); /* ************************************************** */ @@ -82,13 +81,11 @@ XBT_PRIVATE AS_t model_vivaldi_create(void); /* create structures for vival XBT_PRIVATE AS_t model_dijkstra_both_create(int cached); /* create by calling dijkstra or dijkstracache */ XBT_PRIVATE AS_t model_dijkstra_create(void); /* create structures for dijkstra routing model */ XBT_PRIVATE AS_t model_dijkstracache_create(void); /* create structures for dijkstracache routing model */ -XBT_PRIVATE void model_dijkstra_both_end(AS_t as); /* finalize the creation of dijkstra routing model */ XBT_PRIVATE void model_dijkstra_both_parse_route (AS_t rc, sg_platf_route_cbarg_t route); /* ************************************************************************** */ /* *************************** FULL ROUTING ********************************* */ XBT_PRIVATE AS_t model_full_create(void); /* create structures for full routing model */ -XBT_PRIVATE void model_full_end(AS_t as); /* finalize the creation of full routing model */ XBT_PRIVATE void model_full_set_route( /* Set the route and ASroute between src and dst */ AS_t rc, sg_platf_route_cbarg_t route); /* ************************************************************************** */ diff --git a/src/surf/surf_routing_vivaldi.hpp b/src/surf/surf_routing_vivaldi.hpp index 3641a13960..43192be62a 100644 --- a/src/surf/surf_routing_vivaldi.hpp +++ b/src/surf/surf_routing_vivaldi.hpp @@ -26,6 +26,7 @@ class XBT_PRIVATE AsVivaldi; class AsVivaldi: public AsGeneric { public: AsVivaldi() : AsGeneric() {}; + void Seal() override {}; // nothing to do ~AsVivaldi() {}; void getRouteAndLatency(NetCard *src, NetCard *dst, sg_platf_route_cbarg_t into, double *latency) override;