X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/192462d51b69f727a7f16cf83223831f75ed254b..65f020ece2b5a393e49f4a8a7bdb4dc392d2ff32:/src/surf/surf_routing.cpp diff --git a/src/surf/surf_routing.cpp b/src/surf/surf_routing.cpp index 8600c449e8..a4bbe30144 100644 --- a/src/surf/surf_routing.cpp +++ b/src/surf/surf_routing.cpp @@ -1,7 +1,21 @@ +/* Copyright (c) 2009-2011, 2013-2014. The SimGrid Team. + * All rights reserved. */ + +/* This program is free software; you can redistribute it and/or modify it + * under the terms of the license (GNU LGPL) which comes with this package. */ + #include "surf_routing.hpp" #include "surf_routing_private.hpp" +#include "surf_routing_cluster.hpp" +#include "surf_routing_cluster_torus.hpp" + + +#include "simgrid/platf_interface.h" // platform creation API internal interface +#include "simgrid/sg_config.h" +#include "storage_interface.hpp" + #include "surf/surfxml_parse_values.h" -#include "surf/random_mgr.h" + /** * @ingroup SURF_build_api @@ -12,14 +26,16 @@ xbt_lib_t host_lib; int ROUTING_HOST_LEVEL; //Routing level int SURF_CPU_LEVEL; //Surf cpu level int SURF_WKS_LEVEL; //Surf workstation level -int SIMIX_HOST_LEVEL; //Simix level -int MSG_HOST_LEVEL; //Msg level -int SD_HOST_LEVEL; //Simdag level +int SIMIX_HOST_LEVEL; //Simix host level +int SIMIX_STORAGE_LEVEL; //Simix storage level +int MSG_HOST_LEVEL; //Msg host level +int MSG_STORAGE_LEVEL; //Msg storage level +int MSG_FILE_LEVEL; //Msg file level +int SD_HOST_LEVEL; //Simdag host level +int SD_STORAGE_LEVEL; //Simdag storage level int COORD_HOST_LEVEL=0; //Coordinates level int NS3_HOST_LEVEL; //host node for ns3 -xbt_dict_t watched_hosts_lib; - /** * @ingroup SURF_build_api * @brief A library containing all known links @@ -56,12 +72,10 @@ AsPtr current_routing = NULL; /* global parse functions */ extern xbt_dynar_t mount_list; -extern "C" { XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_route, surf, "Routing part of surf"); -} static void routing_parse_peer(sg_platf_peer_cbarg_t peer); /* peer bypass */ -static void routing_parse_Srandom(void); /* random bypass */ +// static void routing_parse_Srandom(void); /* random bypass */ static void routing_parse_postparse(void); @@ -73,7 +87,9 @@ typedef enum { SURF_MODEL_DIJKSTRACACHE, SURF_MODEL_NONE, SURF_MODEL_VIVALDI, - SURF_MODEL_CLUSTER + SURF_MODEL_CLUSTER, + SURF_MODEL_TORUS_CLUSTER, + } e_routing_types; struct s_model_type routing_models[] = { @@ -95,6 +111,8 @@ struct s_model_type routing_models[] = { model_vivaldi_create, NULL}, {"Cluster", "Cluster routing", model_cluster_create, NULL}, + {"Torus_Cluster", "Torus Cluster routing", + model_torus_cluster_create, NULL}, {NULL, NULL, NULL, NULL} }; @@ -112,8 +130,6 @@ static void parse_S_host_link(sg_platf_host_link_cbarg_t host) s_surf_parsing_link_up_down_t link_up_down; link_up_down.link_up = xbt_lib_get_or_null(link_lib, host->link_up, SURF_LINK_LEVEL); link_up_down.link_down = xbt_lib_get_or_null(link_lib, host->link_down, SURF_LINK_LEVEL); - link_up_down.limiter_link = NULL; - link_up_down.loopback_link = NULL; xbt_assert(link_up_down.link_up, "Link '%s' not found!",host->link_up); xbt_assert(link_up_down.link_down, "Link '%s' not found!",host->link_down); @@ -122,12 +138,12 @@ static void parse_S_host_link(sg_platf_host_link_cbarg_t host) current_routing->p_linkUpDownList = xbt_dynar_new(sizeof(s_surf_parsing_link_up_down_t),NULL); // If dynar is is greater than edge id and if the host_link is already defined - if(xbt_dynar_length(current_routing->p_linkUpDownList) > info->m_id && - xbt_dynar_get_as(current_routing->p_linkUpDownList, info->m_id, void*)) - xbt_die("Host_link for '%s' is already defined!",host->id); + 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!",host->id); - XBT_DEBUG("Push Host_link for host '%s' to position %d", info->p_name, info->m_id); - xbt_dynar_set_as(current_routing->p_linkUpDownList, info->m_id, s_surf_parsing_link_up_down_t, link_up_down); + 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); } /** @@ -140,13 +156,13 @@ static void parse_S_host(sg_platf_host_cbarg_t host) xbt_assert(!xbt_lib_get_or_null(host_lib, host->id, ROUTING_HOST_LEVEL), "Reading a host, processing unit \"%s\" already exists", host->id); - RoutingEdgePtr info = new RoutingEdge(); - info->p_rcComponent = current_routing; - info->p_rcType = SURF_NETWORK_ELEMENT_HOST; - info->p_name = xbt_strdup(host->id); - info->m_id = current_routing->parsePU(info); + RoutingEdgePtr info = new RoutingEdgeImpl(xbt_strdup(host->id), + -1, + SURF_NETWORK_ELEMENT_HOST, + current_routing); + info->setId(current_routing->parsePU(info)); xbt_lib_set(host_lib, host->id, ROUTING_HOST_LEVEL, (void *) info); - XBT_DEBUG("Having set name '%s' id '%d'", host->id, info->m_id); + XBT_DEBUG("Having set name '%s' id '%d'", host->id, info->getId()); if(mount_list){ xbt_lib_set(storage_lib, host->id, ROUTING_STORAGE_HOST_LEVEL, (void *) mount_list); @@ -184,13 +200,13 @@ static void parse_S_router(sg_platf_router_cbarg_t router) "Reading a router, processing unit \"%s\" already exists", router->id); - RoutingEdgePtr info = new RoutingEdge(); - info->p_rcComponent = current_routing; - info->p_rcType = SURF_NETWORK_ELEMENT_ROUTER; - info->p_name = xbt_strdup(router->id); - info->m_id = current_routing->parsePU(info); + RoutingEdgePtr info = new RoutingEdgeImpl(xbt_strdup(router->id), + -1, + SURF_NETWORK_ELEMENT_ROUTER, + current_routing); + info->setId(current_routing->parsePU(info)); xbt_lib_set(as_router_lib, router->id, ROUTING_ASR_LEVEL, (void *) info); - XBT_DEBUG("Having set name '%s' id '%d'", router->id, info->m_id); + XBT_DEBUG("Having set name '%s' id '%d'", router->id, info->getId()); if (router->coord && strcmp(router->coord, "")) { unsigned int cursor; @@ -306,14 +322,12 @@ static void routing_parse_trace_connect(sg_platf_trace_connect_cbarg_t trace_con xbt_strdup(trace_connect->element), NULL); break; default: - xbt_die("Cannot connect trace %s to %s: kind of trace unknown", + surf_parse_error("Cannot connect trace %s to %s: kind of trace unknown", trace_connect->trace, trace_connect->element); break; } } -extern int _sg_init_status; /* yay, this is an horrible hack */ - /** * \brief Make a new routing component to the platform * @@ -336,17 +350,20 @@ void routing_AS_begin(sg_platf_AS_cbarg_t AS) (as_router_lib, AS->id, ROUTING_ASR_LEVEL), "The AS \"%s\" already exists", AS->id); - _sg_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; /* horrible hack: direct access to the global + * controlling the level of configuration to prevent + * any further config */ /* search the routing model */ switch(AS->routing){ - case A_surfxml_AS_routing_Cluster: model = &routing_models[SURF_MODEL_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; + 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_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; } @@ -358,14 +375,16 @@ void routing_AS_begin(sg_platf_AS_cbarg_t AS) new_as->p_hierarchy = SURF_ROUTING_NULL; new_as->p_name = xbt_strdup(AS->id); - RoutingEdgePtr info = new RoutingEdge(); - + RoutingEdgePtr info = new RoutingEdgeImpl(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; routing_platf->p_root = new_as; - info->m_id = -1; + info->setId(-1); } else if (current_routing != NULL && routing_platf->p_root != NULL) { xbt_assert(!xbt_dict_get_or_null @@ -380,18 +399,14 @@ void routing_AS_begin(sg_platf_AS_cbarg_t AS) xbt_dict_set(current_routing->p_routingSons, AS->id, (void *) new_as, NULL); /* add to the father element list */ - info->m_id = current_routing->parseAS(info); + info->setId(current_routing->parseAS(info)); } else { THROWF(arg_error, 0, "All defined components must be belong to a AS"); } - info->p_rcComponent = new_as->p_routingFather; - info->p_rcType = SURF_NETWORK_ELEMENT_AS; - info->p_name = new_as->p_name; - - xbt_lib_set(as_router_lib, info->p_name, ROUTING_ASR_LEVEL, + 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->m_id); + XBT_DEBUG("Having set name '%s' id '%d'", new_as->p_name, info->getId()); /* set the new current component of the tree */ current_routing = new_as; @@ -410,7 +425,7 @@ void routing_AS_begin(sg_platf_AS_cbarg_t AS) * even if you add stuff to a closed AS * */ -void routing_AS_end(sg_platf_AS_cbarg_t AS) +void routing_AS_end(sg_platf_AS_cbarg_t /*AS*/) { if (current_routing == NULL) { @@ -440,24 +455,24 @@ static void elements_father(sg_routing_edge_t src, sg_routing_edge_t dst, { xbt_assert(src && dst, "bad parameters for \"elements_father\" method"); #define ELEMENTS_FATHER_MAXDEPTH 16 /* increase if it is not enough */ - AS_t src_as, dst_as; - AS_t path_src[ELEMENTS_FATHER_MAXDEPTH]; - AS_t path_dst[ELEMENTS_FATHER_MAXDEPTH]; + AsPtr src_as, dst_as; + AsPtr path_src[ELEMENTS_FATHER_MAXDEPTH]; + AsPtr path_dst[ELEMENTS_FATHER_MAXDEPTH]; int index_src = 0; int index_dst = 0; - AS_t current; - AS_t current_src; - AS_t current_dst; - AS_t father; + AsPtr current; + AsPtr current_src; + AsPtr current_dst; + AsPtr father; /* (1) find the as where the src and dst are located */ sg_routing_edge_t src_data = src; sg_routing_edge_t dst_data = dst; - src_as = src_data->p_rcComponent; - dst_as = dst_data->p_rcComponent; + src_as = src_data->getRcComponent(); + dst_as = dst_data->getRcComponent(); #ifndef NDEBUG - char* src_name = src_data->p_name; - char* dst_name = dst_data->p_name; + char* src_name = src_data->getName(); + char* dst_name = dst_data->getName(); #endif xbt_assert(src_as && dst_as, @@ -515,7 +530,7 @@ static void _get_route_and_latency(RoutingEdgePtr src, RoutingEdgePtr dst, memset(&route,0,sizeof(route)); xbt_assert(src && dst, "bad parameters for \"_get_route_latency\" method"); - XBT_DEBUG("Solve route/latency \"%s\" to \"%s\"", src->p_name, dst->p_name); + XBT_DEBUG("Solve route/latency \"%s\" to \"%s\"", src->getName(), dst->getName()); /* Find how src and dst are interconnected */ AsPtr common_father, src_father, dst_father; @@ -532,7 +547,7 @@ static void _get_route_and_latency(RoutingEdgePtr src, RoutingEdgePtr dst, /* 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); - //FIXME:generic_free_route(e_route_bypass); + generic_free_route(e_route_bypass); return; } @@ -555,7 +570,7 @@ static void _get_route_and_latency(RoutingEdgePtr src, RoutingEdgePtr dst, &route, latency); xbt_assert((route.gw_src != NULL) && (route.gw_dst != NULL), - "bad gateways for route from \"%s\" to \"%s\"", src->p_name, dst->p_name); + "bad gateways for route from \"%s\" to \"%s\"", src->getName(), dst->getName()); sg_routing_edge_t src_gateway_net_elm = route.gw_src; sg_routing_edge_t dst_gateway_net_elm = route.gw_dst; @@ -577,7 +592,7 @@ AS_t surf_platf_get_root(routing_platf_t platf){ } e_surf_network_element_type_t surf_routing_edge_get_rc_type(sg_routing_edge_t edge){ - return edge->p_rcType; + return edge->getRcType(); } @@ -598,7 +613,7 @@ e_surf_network_element_type_t surf_routing_edge_get_rc_type(sg_routing_edge_t ed void RoutingPlatf::getRouteAndLatency(RoutingEdgePtr src, RoutingEdgePtr dst, xbt_dynar_t* route, double *latency) { - XBT_DEBUG("routing_get_route_and_latency from %s to %s", src->p_name, dst->p_name); + XBT_DEBUG("routing_get_route_and_latency from %s to %s", src->getName(), dst->getName()); if (!*route) { xbt_dynar_reset(routing_platf->p_lastRoute); *route = routing_platf->p_lastRoute; @@ -607,7 +622,7 @@ void RoutingPlatf::getRouteAndLatency(RoutingEdgePtr src, RoutingEdgePtr dst, _get_route_and_latency(src, dst, route, latency); xbt_assert(!latency || *latency >= 0.0, - "negative latency on route between \"%s\" and \"%s\"", src->p_name, dst->p_name); + "negative latency on route between \"%s\" and \"%s\"", src->getName(), dst->getName()); } xbt_dynar_t RoutingPlatf::getOneLinkRoutes(){ @@ -639,7 +654,7 @@ e_surf_network_element_type_t routing_get_network_element_type(const char *name) { RoutingEdgePtr rc = sg_routing_edge_by_name_or_null(name); if (rc) - return rc->p_rcType; + return rc->getRcType(); return SURF_NETWORK_ELEMENT_NULL; } @@ -744,7 +759,7 @@ static void routing_parse_cabinet(sg_platf_cabinet_cbarg_t cabinet) s_sg_platf_host_cbarg_t host; memset(&host, 0, sizeof(host)); host.initial_state = SURF_RESOURCE_ON; - host.power_peak = cabinet->power; + host.pstate = 0; host.power_scale = 1.0; host.core_amount = 1; @@ -763,6 +778,9 @@ static void routing_parse_cabinet(sg_platf_cabinet_cbarg_t cabinet) link_id = bprintf("link_%s%d%s",cabinet->prefix,i,cabinet->suffix); host.id = host_id; link.id = link_id; + xbt_dynar_t power_state_list = xbt_dynar_new(sizeof(double), NULL); + xbt_dynar_push(power_state_list,&cabinet->power); + host.power_peak = power_state_list; sg_platf_new_host(&host); sg_platf_new_link(&link); @@ -788,6 +806,7 @@ static void routing_parse_cluster(sg_platf_cluster_cbarg_t cluster) { char *host_id, *groups, *link_id = NULL; xbt_dict_t patterns = NULL; + int rankId=0; s_sg_platf_host_cbarg_t host; s_sg_platf_link_cbarg_t link; @@ -805,11 +824,35 @@ static void routing_parse_cluster(sg_platf_cluster_cbarg_t cluster) xbt_dict_set(patterns, "suffix", xbt_strdup(cluster->suffix), NULL); } - XBT_DEBUG("", cluster->id); + /* parse the topology attribute. If we are not in a flat cluster, + * switch to the right mode and initialize the routing with + * the parameters in topo_parameters attribute + */ s_sg_platf_AS_cbarg_t AS = SG_PLATF_AS_INITIALIZER; AS.id = cluster->id; - AS.routing = A_surfxml_AS_routing_Cluster; - sg_platf_new_AS_begin(&AS); + + if(cluster->topology == SURF_CLUSTER_TORUS){ + XBT_DEBUG("", cluster->id); + AS.routing = A_surfxml_AS_routing_Cluster___torus; + sg_platf_new_AS_begin(&AS); + ((AsClusterTorusPtr)current_routing)->parse_specific_arguments(cluster); + }else{ + XBT_DEBUG("", cluster->id); + AS.routing = A_surfxml_AS_routing_Cluster; + sg_platf_new_AS_begin(&AS); + } + + if(cluster->loopback_bw!=0 || cluster->loopback_lat!=0){ + ((AsClusterPtr)current_routing)->p_nb_links_per_node++; + ((AsClusterPtr)current_routing)->p_has_loopback=1; + } + + if(cluster->limiter_link!=0){ + ((AsClusterPtr)current_routing)->p_nb_links_per_node++; + ((AsClusterPtr)current_routing)->p_has_limiter=1; + } + + current_routing->p_linkUpDownList = xbt_dynar_new(sizeof(s_surf_parsing_link_up_down_t),NULL); @@ -860,7 +903,12 @@ static void routing_parse_cluster(sg_platf_cluster_cbarg_t cluster) XBT_DEBUG("\tstate_file=\"\""); } - host.power_peak = cluster->power; + xbt_dynar_t power_state_list = xbt_dynar_new(sizeof(double), NULL); + xbt_dynar_push(power_state_list,&cluster->power); + host.power_peak = power_state_list; + host.pstate = 0; + + //host.power_peak = cluster->power; host.power_scale = 1.0; host.core_amount = cluster->core_amount; host.initial_state = SURF_RESOURCE_ON; @@ -871,30 +919,37 @@ static void routing_parse_cluster(sg_platf_cluster_cbarg_t cluster) XBT_DEBUG("", link_id, cluster->bw, cluster->lat); - memset(&link, 0, sizeof(link)); - link.id = link_id; - link.bandwidth = cluster->bw; - link.latency = cluster->lat; - link.state = SURF_RESOURCE_ON; - link.policy = cluster->sharing_policy; - sg_platf_new_link(&link); - s_surf_parsing_link_up_down_t info; + 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 - if (link.policy == SURF_LINK_FULLDUPLEX) { - char *tmp_link = bprintf("%s_UP", link_id); - info.link_up = - xbt_lib_get_or_null(link_lib, tmp_link, SURF_LINK_LEVEL); - free(tmp_link); - tmp_link = bprintf("%s_DOWN", link_id); - info.link_down = + //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.state = SURF_RESOURCE_ON; + link.policy = SURF_LINK_FATPIPE; + sg_platf_new_link(&link); + info_loop.link_up = xbt_lib_get_or_null(link_lib, tmp_link, SURF_LINK_LEVEL); + info_loop.link_down = info_loop.link_up; free(tmp_link); - } else { - info.link_up = xbt_lib_get_or_null(link_lib, link_id, SURF_LINK_LEVEL); - info.link_down = info.link_up; + xbt_dynar_set(current_routing->p_linkUpDownList, rankId*((AsClusterPtr)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, @@ -908,36 +963,27 @@ static void routing_parse_cluster(sg_platf_cluster_cbarg_t cluster) link.state = SURF_RESOURCE_ON; link.policy = SURF_LINK_SHARED; sg_platf_new_link(&link); - info.limiter_link = + info_lim.link_up = xbt_lib_get_or_null(link_lib, tmp_link, SURF_LINK_LEVEL); + info_lim.link_down = info_lim.link_up; free(tmp_link); - }else{ - info.limiter_link =NULL; + xbt_dynar_set(current_routing->p_linkUpDownList, + rankId*((AsClusterPtr)current_routing)->p_nb_links_per_node + ((AsClusterPtr)current_routing)->p_has_loopback , + &info_lim); + } - if(cluster->loopback_bw!=0 || cluster->loopback_lat!=0){ - char *tmp_link = bprintf("%s_loopback", link_id); - XBT_DEBUG("", tmp_link, - cluster->limiter_link); + //call the cluster function that adds the others links - memset(&link, 0, sizeof(link)); - link.id = tmp_link; - link.bandwidth = cluster->loopback_bw; - link.latency = cluster->loopback_lat; - link.state = SURF_RESOURCE_ON; - link.policy = SURF_LINK_FATPIPE; - sg_platf_new_link(&link); - info.loopback_link = - xbt_lib_get_or_null(link_lib, tmp_link, SURF_LINK_LEVEL); - free(tmp_link); - }else{ - info.loopback_link =NULL; - } + ((AsClusterPtr)current_routing)->create_links_for_node(cluster, i, rankId, rankId* + ((AsClusterPtr)current_routing)->p_nb_links_per_node + + ((AsClusterPtr)current_routing)->p_has_loopback + + ((AsClusterPtr)current_routing)->p_has_limiter ); - xbt_dynar_push(current_routing->p_linkUpDownList, &info); xbt_free(link_id); xbt_free(host_id); + rankId++; } xbt_dynar_free(&radical_ends); @@ -994,23 +1040,37 @@ static void routing_parse_postparse(void) { static void routing_parse_peer(sg_platf_peer_cbarg_t peer) { char *host_id = NULL; - char *link_id; + char *link_id = NULL; + char *router_id = NULL; XBT_DEBUG(" "); host_id = HOST_PEER(peer->id); link_id = LINK_PEER(peer->id); + router_id = ROUTER_PEER(peer->id); + + XBT_DEBUG("", peer->id); + s_sg_platf_AS_cbarg_t AS = SG_PLATF_AS_INITIALIZER; + AS.id = peer->id; + 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->power); s_sg_platf_host_cbarg_t host; memset(&host, 0, sizeof(host)); host.initial_state = SURF_RESOURCE_ON; host.id = host_id; - host.power_peak = peer->power; + + xbt_dynar_t power_state_list = xbt_dynar_new(sizeof(double), NULL); + xbt_dynar_push(power_state_list,&peer->power); + host.power_peak = power_state_list; + host.pstate = 0; + //host.power_peak = peer->power; host.power_scale = 1.0; host.power_trace = peer->availability_trace; host.state_trace = peer->state_trace; host.core_amount = 1; - host.coord = peer->coord; sg_platf_new_host(&host); s_sg_platf_link_cbarg_t link; @@ -1041,132 +1101,159 @@ static void routing_parse_peer(sg_platf_peer_cbarg_t peer) host_link.link_down= link_down; sg_platf_new_host_link(&host_link); + XBT_DEBUG("", router_id); + s_sg_platf_router_cbarg_t router; + memset(&router, 0, sizeof(router)); + router.id = router_id; + router.coord = peer->coord; + sg_platf_new_router(&router); + static_cast(current_routing)->p_router = static_cast(xbt_lib_get_or_null(as_router_lib, router.id, ROUTING_ASR_LEVEL)); + + XBT_DEBUG(""); + sg_platf_new_AS_end(); XBT_DEBUG(" "); //xbt_dynar_free(&tab_elements_num); + free(router_id); free(host_id); free(link_id); free(link_up); free(link_down); } -static void routing_parse_Srandom(void) +// static void routing_parse_Srandom(void) +// { +// double mean, std, min, max, seed; +// char *random_id = A_surfxml_random_id; +// char *random_radical = A_surfxml_random_radical; +// char *rd_name = NULL; +// char *rd_value; +// mean = surf_parse_get_double(A_surfxml_random_mean); +// std = surf_parse_get_double(A_surfxml_random_std___deviation); +// min = surf_parse_get_double(A_surfxml_random_min); +// max = surf_parse_get_double(A_surfxml_random_max); +// seed = surf_parse_get_double(A_surfxml_random_seed); + +// double res = 0; +// int i = 0; +// random_data_t random = xbt_new0(s_random_data_t, 1); +// char *tmpbuf; + +// xbt_dynar_t radical_elements; +// unsigned int iter; +// char *groups; +// int start, end; +// xbt_dynar_t radical_ends; + +// switch (A_surfxml_random_generator) { +// case AU_surfxml_random_generator: +// case A_surfxml_random_generator_NONE: +// random->generator = NONE; +// break; +// case A_surfxml_random_generator_DRAND48: +// random->generator = DRAND48; +// break; +// case A_surfxml_random_generator_RAND: +// random->generator = RAND; +// break; +// case A_surfxml_random_generator_RNGSTREAM: +// random->generator = RNGSTREAM; +// break; +// default: +// surf_parse_error("Invalid random generator"); +// break; +// } +// random->seed = seed; +// random->min = min; +// random->max = max; + +// /* Check user stupidities */ +// if (max < min) +// THROWF(arg_error, 0, "random->max < random->min (%f < %f)", max, min); +// if (mean < min) +// THROWF(arg_error, 0, "random->mean < random->min (%f < %f)", mean, min); +// if (mean > max) +// THROWF(arg_error, 0, "random->mean > random->max (%f > %f)", mean, max); + +// /* normalize the mean and standard deviation before storing */ +// random->mean = (mean - min) / (max - min); +// random->std = std / (max - min); + +// if (random->mean * (1 - random->mean) < random->std * random->std) +// THROWF(arg_error, 0, "Invalid mean and standard deviation (%f and %f)", +// random->mean, random->std); + +// XBT_DEBUG +// ("id = '%s' min = '%f' max = '%f' mean = '%f' std_deviatinon = '%f' generator = '%d' seed = '%ld' radical = '%s'", +// random_id, random->min, random->max, random->mean, random->std, +// (int)random->generator, random->seed, random_radical); + +// if (!random_value) +// random_value = xbt_dict_new_homogeneous(free); + +// if (!strcmp(random_radical, "")) { +// res = random_generate(random); +// rd_value = bprintf("%f", res); +// xbt_dict_set(random_value, random_id, rd_value, NULL); +// } else { +// radical_elements = xbt_str_split(random_radical, ","); +// xbt_dynar_foreach(radical_elements, iter, groups) { +// radical_ends = xbt_str_split(groups, "-"); +// switch (xbt_dynar_length(radical_ends)) { +// case 1: +// xbt_assert(!xbt_dict_get_or_null(random_value, random_id), +// "Custom Random '%s' already exists !", random_id); +// res = random_generate(random); +// tmpbuf = +// bprintf("%s%d", random_id, +// atoi(xbt_dynar_getfirst_as(radical_ends, char *))); +// xbt_dict_set(random_value, tmpbuf, bprintf("%f", res), NULL); +// xbt_free(tmpbuf); +// break; + +// case 2: +// start = surf_parse_get_int(xbt_dynar_get_as(radical_ends, 0, char *)); +// end = surf_parse_get_int(xbt_dynar_get_as(radical_ends, 1, char *)); +// for (i = start; i <= end; i++) { +// xbt_assert(!xbt_dict_get_or_null(random_value, random_id), +// "Custom Random '%s' already exists !", bprintf("%s%d", +// random_id, +// i)); +// res = random_generate(random); +// tmpbuf = bprintf("%s%d", random_id, i); +// xbt_dict_set(random_value, tmpbuf, bprintf("%f", res), NULL); +// xbt_free(tmpbuf); +// } +// break; +// default: +// XBT_CRITICAL("Malformed radical"); +// break; +// } +// res = random_generate(random); +// rd_name = bprintf("%s_router", random_id); +// rd_value = bprintf("%f", res); +// xbt_dict_set(random_value, rd_name, rd_value, NULL); + +// xbt_dynar_free(&radical_ends); +// } +// free(rd_name); +// xbt_dynar_free(&radical_elements); +// } +// } + +static void check_disk_attachment() { - double mean, std, min, max, seed; - char *random_id = A_surfxml_random_id; - char *random_radical = A_surfxml_random_radical; - char *rd_name = NULL; - char *rd_value; - mean = surf_parse_get_double(A_surfxml_random_mean); - std = surf_parse_get_double(A_surfxml_random_std___deviation); - min = surf_parse_get_double(A_surfxml_random_min); - max = surf_parse_get_double(A_surfxml_random_max); - seed = surf_parse_get_double(A_surfxml_random_seed); - - double res = 0; - int i = 0; - random_data_t random = xbt_new0(s_random_data_t, 1); - char *tmpbuf; - - xbt_dynar_t radical_elements; - unsigned int iter; - char *groups; - int start, end; - xbt_dynar_t radical_ends; - - switch (A_surfxml_random_generator) { - case AU_surfxml_random_generator: - case A_surfxml_random_generator_NONE: - random->generator = NONE; - break; - case A_surfxml_random_generator_DRAND48: - random->generator = DRAND48; - break; - case A_surfxml_random_generator_RAND: - random->generator = RAND; - break; - case A_surfxml_random_generator_RNGSTREAM: - random->generator = RNGSTREAM; - break; - default: - surf_parse_error("Invalid random generator"); - break; - } - random->seed = seed; - random->min = min; - random->max = max; - - /* Check user stupidities */ - if (max < min) - THROWF(arg_error, 0, "random->max < random->min (%f < %f)", max, min); - if (mean < min) - THROWF(arg_error, 0, "random->mean < random->min (%f < %f)", mean, min); - if (mean > max) - THROWF(arg_error, 0, "random->mean > random->max (%f > %f)", mean, max); - - /* normalize the mean and standard deviation before storing */ - random->mean = (mean - min) / (max - min); - random->std = std / (max - min); - - if (random->mean * (1 - random->mean) < random->std * random->std) - THROWF(arg_error, 0, "Invalid mean and standard deviation (%f and %f)", - random->mean, random->std); - - XBT_DEBUG - ("id = '%s' min = '%f' max = '%f' mean = '%f' std_deviatinon = '%f' generator = '%d' seed = '%ld' radical = '%s'", - random_id, random->min, random->max, random->mean, random->std, - (int)random->generator, random->seed, random_radical); - - if (!random_value) - random_value = xbt_dict_new_homogeneous(free); - - if (!strcmp(random_radical, "")) { - res = random_generate(random); - rd_value = bprintf("%f", res); - xbt_dict_set(random_value, random_id, rd_value, NULL); - } else { - radical_elements = xbt_str_split(random_radical, ","); - xbt_dynar_foreach(radical_elements, iter, groups) { - radical_ends = xbt_str_split(groups, "-"); - switch (xbt_dynar_length(radical_ends)) { - case 1: - xbt_assert(!xbt_dict_get_or_null(random_value, random_id), - "Custom Random '%s' already exists !", random_id); - res = random_generate(random); - tmpbuf = - bprintf("%s%d", random_id, - atoi(xbt_dynar_getfirst_as(radical_ends, char *))); - xbt_dict_set(random_value, tmpbuf, bprintf("%f", res), NULL); - xbt_free(tmpbuf); - break; - - case 2: - start = surf_parse_get_int(xbt_dynar_get_as(radical_ends, 0, char *)); - end = surf_parse_get_int(xbt_dynar_get_as(radical_ends, 1, char *)); - for (i = start; i <= end; i++) { - xbt_assert(!xbt_dict_get_or_null(random_value, random_id), - "Custom Random '%s' already exists !", bprintf("%s%d", - random_id, - i)); - res = random_generate(random); - tmpbuf = bprintf("%s%d", random_id, i); - xbt_dict_set(random_value, tmpbuf, bprintf("%f", res), NULL); - xbt_free(tmpbuf); - } - break; - default: - XBT_CRITICAL("Malformed radical"); - break; - } - res = random_generate(random); - rd_name = bprintf("%s_router", random_id); - rd_value = bprintf("%f", res); - xbt_dict_set(random_value, rd_name, rd_value, NULL); - - xbt_dynar_free(&radical_ends); + xbt_lib_cursor_t cursor; + char *key; + void **data; + RoutingEdgePtr host_elm; + xbt_lib_foreach(storage_lib, cursor, key, data) { + if(xbt_lib_get_level(xbt_lib_get_elm_or_null(storage_lib, key), SURF_STORAGE_LEVEL) != NULL) { + StoragePtr storage = static_cast(xbt_lib_get_level(xbt_lib_get_elm_or_null(storage_lib, key), SURF_STORAGE_LEVEL)); + host_elm = sg_routing_edge_by_name_or_null(storage->p_attach); + if(!host_elm) + surf_parse_error("Unable to attach storage %s: host %s doesn't exist.", storage->getName(), storage->p_attach); } - free(rd_name); - xbt_dynar_free(&radical_elements); } } @@ -1185,6 +1272,7 @@ void routing_register_callbacks() sg_platf_peer_add_cb(routing_parse_peer); sg_platf_postparse_add_cb(routing_parse_postparse); + sg_platf_postparse_add_cb(check_disk_attachment); /* we care about the ASes while parsing the platf. Incredible, isnt it? */ sg_platf_AS_end_add_cb(routing_AS_end); @@ -1220,11 +1308,13 @@ static void finalize_rec(AsPtr as) { /** \brief Frees all memory allocated by the routing module */ void routing_exit(void) { - if (!routing_platf) - return; - xbt_dynar_free(&routing_platf->p_lastRoute); - finalize_rec(routing_platf->p_root); - xbt_free(routing_platf); + delete routing_platf; +} + +RoutingPlatf::~RoutingPlatf() +{ + xbt_dynar_free(&p_lastRoute); + finalize_rec(p_root); } AS_t surf_AS_get_routing_root() { @@ -1252,7 +1342,7 @@ xbt_dynar_t surf_AS_get_hosts(AsPtr as) { xbt_dynar_t res = xbt_dynar_new(sizeof(xbt_dictelm_t), NULL); for (index = 0; index < count; index++) { relm = xbt_dynar_get_as(elms, index, RoutingEdgePtr); - delm = xbt_lib_get_elm_or_null(host_lib, relm->p_name); + delm = xbt_lib_get_elm_or_null(host_lib, relm->getName()); if (delm!=NULL) { xbt_dynar_push(res, &delm); }