X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/fc566e17d32fb6664755d572d51def38592fa2c4..66a6b6eefde8b9d5aac551b3e0008d3df3ddeba7:/src/surf/surf_routing.c diff --git a/src/surf/surf_routing.c b/src/surf/surf_routing.c index 9c7d787752..65abb38f6f 100644 --- a/src/surf/surf_routing.c +++ b/src/surf/surf_routing.c @@ -1,1054 +1,2278 @@ -/* Copyright (c) 2009, 2010. The SimGrid Team. +/* Copyright (c) 2009, 2010. 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 -#include "surf_private.h" -#include "xbt/dynar.h" -#include "xbt/str.h" -#include "xbt/config.h" -#include "xbt/graph.h" -#include "xbt/set.h" - -XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_route,surf,"Routing part of surf"); - -routing_t used_routing = NULL; -xbt_dict_t onelink_routes = NULL; - -/* Prototypes of each model */ -static void routing_model_full_create(size_t size_of_link,void *loopback); -static void routing_model_floyd_create(size_t size_of_link, void*loopback); -static void routing_model_dijkstra_create(size_t size_of_link, void*loopback); -static void routing_model_dijkstracache_create(size_t size_of_link, void*loopback); -static void routing_model_none_create(size_t size_of_link, void*loopback); - -/* Definition of each model */ -struct model_type { - const char *name; - const char *desc; - void (*fun)(size_t,void*); +#ifdef HAVE_PCRE_LIB +#include /* regular expression library */ +#endif +#include "surf_routing_private.h" +#include "surf/surf_routing.h" + +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 COORD_HOST_LEVEL; //Coordinates level +int NS3_HOST_LEVEL; //host node for ns3 + +xbt_lib_t link_lib; +int SD_LINK_LEVEL; //Simdag level +int SURF_LINK_LEVEL; //Surf level +int NS3_LINK_LEVEL; //link for ns3 + +xbt_lib_t as_router_lib; +int ROUTING_ASR_LEVEL; //Routing level +int COORD_ASR_LEVEL; //Coordinates level +int NS3_ASR_LEVEL; //host node for ns3 + +static xbt_dict_t patterns = NULL; +static xbt_dict_t random_value = NULL; + +/* Global vars */ +routing_global_t global_routing = NULL; +routing_component_t current_routing = NULL; +model_type_t current_routing_model = NULL; + +/* global parse functions */ +xbt_dynar_t link_list = NULL; /* temporary store of current list link of a route */ +static const char *src = NULL; /* temporary store the source name of a route */ +static const char *dst = NULL; /* temporary store the destination name of a route */ +static char *gw_src = NULL; /* temporary store the gateway source name of a route */ +static char *gw_dst = NULL; /* temporary store the gateway destination name of a route */ +static double_f_cpvoid_t get_link_latency = NULL; + +XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_route, surf, "Routing part of surf"); + +static void routing_parse_Speer(void); /* peer bypass */ +static void routing_parse_Srandom(void); /* random bypass */ +static void routing_parse_Erandom(void); /* random bypass */ + +static void routing_parse_Sconfig(void); /* config Tag */ +static void routing_parse_Econfig(void); /* config Tag */ + +static char* replace_random_parameter(char * chaine); +static void clean_dict_random(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, +#ifdef HAVE_PCRE_LIB + SURF_MODEL_RULEBASED +#endif +} e_routing_types; + +struct s_model_type routing_models[] = { {"Full", + "Full routing data (fast, large memory requirements, fully expressive)", + model_full_create, + model_full_load, + model_full_unload, + model_full_end}, +{"Floyd", + "Floyd routing data (slow initialization, fast lookup, lesser memory requirements, shortest path routing only)", + model_floyd_create, model_floyd_load, model_floyd_unload, + model_floyd_end}, +{"Dijkstra", + "Dijkstra routing data (fast initialization, slow lookup, small memory requirements, shortest path routing only)", + model_dijkstra_create, model_dijkstra_both_load, + model_dijkstra_both_unload, 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_load, + model_dijkstra_both_unload, model_dijkstra_both_end}, +{"none", "No routing (usable with Constant network only)", + model_none_create, model_none_load, model_none_unload, model_none_end}, +#ifdef HAVE_PCRE_LIB +{"RuleBased", "Rule-Based routing data (...)", model_rulebased_create, + model_rulebased_load, model_rulebased_unload, model_rulebased_end}, +{"Vivaldi", "Vivaldi routing", model_rulebased_create, + model_rulebased_load, model_rulebased_unload, model_rulebased_end}, +#endif +{NULL, NULL, NULL, NULL, NULL, NULL} }; -struct model_type models[] = -{ {"Full", "Full routing data (fast, large memory requirements, fully expressive)", routing_model_full_create }, - {"Floyd", "Floyd routing data (slow initialization, fast lookup, lesser memory requirements, shortest path routing only)", routing_model_floyd_create }, - {"Dijkstra", "Dijkstra routing data (fast initialization, slow lookup, small memory requirements, shortest path routing only)", routing_model_dijkstra_create }, - {"DijkstraCache", "Dijkstra routing data (fast initialization, fast lookup, small memory requirements, shortest path routing only)", routing_model_dijkstracache_create }, - {"none", "No routing (usable with Constant network only)", routing_model_none_create }, - {NULL,NULL,NULL}}; +static double euclidean_dist_comp(int index, xbt_dynar_t src, xbt_dynar_t dst) +{ + double src_coord, dst_coord; -void routing_model_create(size_t size_of_links, void* loopback) { + src_coord = atof(xbt_dynar_get_as(src, index, char *)); + dst_coord = atof(xbt_dynar_get_as(dst, index, char *)); - char * wanted=xbt_cfg_get_string(_surf_cfg_set,"routing"); - int cpt; - for (cpt=0;models[cpt].name;cpt++) { - if (!strcmp(wanted,models[cpt].name)) { - (*(models[cpt].fun))(size_of_links,loopback); - return; - } + return (src_coord-dst_coord)*(src_coord-dst_coord); + +} + +static double base_vivaldi_get_latency (const char *src, const char *dst) +{ + double euclidean_dist; + xbt_dynar_t src_ctn, dst_ctn; + src_ctn = xbt_lib_get_or_null(host_lib, src, COORD_HOST_LEVEL); + if(!src_ctn) src_ctn = xbt_lib_get_or_null(as_router_lib, src, COORD_ASR_LEVEL); + dst_ctn = xbt_lib_get_or_null(host_lib, dst, COORD_HOST_LEVEL); + if(!dst_ctn) dst_ctn = xbt_lib_get_or_null(as_router_lib, dst, COORD_ASR_LEVEL); + + if(dst_ctn == NULL || src_ctn == NULL) + xbt_die("Coord src '%s' :%p dst '%s' :%p",src,src_ctn,dst,dst_ctn); + + euclidean_dist = sqrt (euclidean_dist_comp(0,src_ctn,dst_ctn)+euclidean_dist_comp(1,src_ctn,dst_ctn)) + + fabs(atof(xbt_dynar_get_as(src_ctn, 2, char *)))+fabs(atof(xbt_dynar_get_as(dst_ctn, 2, char *))); + + xbt_assert(euclidean_dist>=0, "Euclidean Dist is less than 0\"%s\" and \"%.2f\"", src, euclidean_dist); + + //From .ms to .s + return euclidean_dist / 1000; +} + +static double vivaldi_get_link_latency (routing_component_t rc,const char *src, const char *dst, route_extended_t e_route) +{ + if(get_network_element_type(src) == SURF_NETWORK_ELEMENT_AS) { + int need_to_clean = e_route?0:1; + double latency; + e_route = e_route?e_route:(*(rc->get_route)) (rc, src, dst); + latency = base_vivaldi_get_latency(e_route->src_gateway,e_route->dst_gateway); + if(need_to_clean) generic_free_extended_route(e_route); + return latency; + } else { + return base_vivaldi_get_latency(src,dst); } - fprintf(stderr,"Routing model %s not found. Existing models:\n",wanted); - for (cpt=0;models[cpt].name;cpt++) - if (!strcmp(wanted,models[cpt].name)) - fprintf(stderr," %s: %s\n",models[cpt].name,models[cpt].desc); - exit(1); } -/* ************************************************************************** */ -/* *************************** FULL ROUTING ********************************* */ -typedef struct { - s_routing_t generic_routing; - xbt_dynar_t *routing_table; - void *loopback; - size_t size_of_link; -} s_routing_full_t,*routing_full_t; - -#define ROUTE_FULL(i,j) ((routing_full_t)used_routing)->routing_table[(i)+(j)*(used_routing)->host_count] -#define HOST2ROUTER(id) ((id)+(2<<29)) -#define ROUTER2HOST(id) ((id)-(2<<29)) -#define ISROUTER(id) ((id)>=(2<<29)) +/** + * \brief Add a "host" to the network element list + */ +static void parse_S_host(const char *host_id, const char* coord) +{ + network_element_info_t info = NULL; + if (current_routing->hierarchy == SURF_ROUTING_NULL) + current_routing->hierarchy = SURF_ROUTING_BASE; + xbt_assert(!xbt_lib_get_or_null(host_lib, host_id,ROUTING_HOST_LEVEL), + "Reading a host, processing unit \"%s\" already exists", + host_id); + xbt_assert(current_routing->set_processing_unit, + "no defined method \"set_processing_unit\" in \"%s\"", + current_routing->name); + (*(current_routing->set_processing_unit)) (current_routing, host_id); + info = xbt_new0(s_network_element_info_t, 1); + info->rc_component = current_routing; + info->rc_type = SURF_NETWORK_ELEMENT_HOST; + xbt_lib_set(host_lib,host_id,ROUTING_HOST_LEVEL,(void *) info); + if (strcmp(coord,"")) { + if(!COORD_HOST_LEVEL) xbt_die("To use coordinates, you must set configuration 'coordinates' to 'yes'"); + xbt_dynar_t ctn = xbt_str_split_str(coord, " "); + xbt_dynar_shrink(ctn, 0); + xbt_lib_set(host_lib,host_id,COORD_HOST_LEVEL,(void *) ctn); + } +} + +static void parse_E_host(void) +{ + xbt_dict_cursor_t cursor = NULL; + char *key; + char *elem; + + xbt_dict_foreach(current_property_set, cursor, key, elem) { + XBT_DEBUG("property : %s = %s",key,elem); + } +} /* - * Free the onelink routes + * \brief Add a host to the network element list from XML */ -static void onelink_route_elem_free(void *e) { - s_onelink_t tmp = (s_onelink_t)e; - if(tmp) { - free(tmp); - } +static void parse_S_host_XML(void) +{ + parse_S_host(A_surfxml_host_id, A_surfxml_host_coordinates); +} +static void parse_E_host_XML(void) +{ + parse_E_host(); } /* - * Parsing + * \brief Add a host to the network element list from lua script */ -static void routing_full_parse_Shost(void) { - int *val = xbt_malloc(sizeof(int)); - DEBUG2("Seen host %s (#%d)",A_surfxml_host_id,used_routing->host_count); - *val = used_routing->host_count++; - xbt_dict_set(used_routing->host_id,A_surfxml_host_id,val,xbt_free); -#ifdef HAVE_TRACING - TRACE_surf_host_define_id (A_surfxml_host_id, *val); -#endif +static void parse_S_host_lua(const char *host_id, const char *coord) +{ + parse_S_host(host_id, coord); } -static void routing_full_parse_Srouter(void) { - int *val = xbt_malloc(sizeof(int)); - DEBUG3("Seen router %s (%d -> #%d)",A_surfxml_router_id,used_routing->router_count, - HOST2ROUTER(used_routing->router_count)); - *val = HOST2ROUTER(used_routing->router_count++); - xbt_dict_set(used_routing->host_id,A_surfxml_router_id,val,xbt_free); -#ifdef HAVE_TRACING - TRACE_surf_host_define_id (A_surfxml_host_id, *val); - TRACE_surf_host_declaration (A_surfxml_host_id, 0); -#endif + +/** + * \brief Add a "router" to the network element list + */ +static void parse_S_router(const char *router_id) +{ + network_element_info_t info = NULL; + + if (current_routing->hierarchy == SURF_ROUTING_NULL) + current_routing->hierarchy = SURF_ROUTING_BASE; + xbt_assert(!xbt_lib_get_or_null(as_router_lib,A_surfxml_router_id, ROUTING_ASR_LEVEL), + "Reading a router, processing unit \"%s\" already exists", + router_id); + xbt_assert(current_routing->set_processing_unit, + "no defined method \"set_processing_unit\" in \"%s\"", + current_routing->name); + (*(current_routing->set_processing_unit)) (current_routing, + router_id); + info = xbt_new0(s_network_element_info_t, 1); + info->rc_component = current_routing; + info->rc_type = SURF_NETWORK_ELEMENT_ROUTER; + + xbt_lib_set(as_router_lib,router_id,ROUTING_ASR_LEVEL,(void *) info); + if (strcmp(A_surfxml_router_coordinates,"")) { + if(!COORD_ASR_LEVEL) xbt_die("To use coordinates, you must set configuration 'coordinates' to 'yes'"); + xbt_dynar_t ctn = xbt_str_split_str(A_surfxml_router_coordinates, " "); + xbt_dynar_shrink(ctn, 0); + xbt_lib_set(as_router_lib,router_id,COORD_ASR_LEVEL,(void *) ctn); + } } -static int src_id = -1; -static int dst_id = -1; -static void routing_full_parse_Sroute_set_endpoints(void) +/** + * brief Add a "router" to the network element list from XML description + */ +static void parse_S_router_XML(void) { - src_id = *(int*)xbt_dict_get(used_routing->host_id,A_surfxml_route_src); - dst_id = *(int*)xbt_dict_get(used_routing->host_id,A_surfxml_route_dst); - DEBUG4("Route %s %d -> %s %d",A_surfxml_route_src,src_id,A_surfxml_route_dst,dst_id); - route_action = A_surfxml_route_action; + return parse_S_router(A_surfxml_router_id); } -static void routing_full_parse_Eroute(void) + +/** + * brief Add a "router" to the network element list from XML description + */ +static void parse_S_router_lua(const char* router_id) { - char *name; - if (src_id != -1 && dst_id != -1) { - name = bprintf("%x#%x", src_id, dst_id); - manage_route(route_table, name, route_action, 0); - free(name); - } + return parse_S_router(router_id); } -/* Cluster tag functions */ +/** + * \brief Set the endponints for a route + */ +static void parse_S_route_new_and_endpoints(const char *src_id, const char *dst_id) +{ + if (src != NULL && dst != NULL && link_list != NULL) + THROWF(arg_error, 0, "Route between %s to %s can not be defined", + src_id, dst_id); + src = src_id; + dst = dst_id; + xbt_assert(strlen(src) > 0 || strlen(dst) > 0, + "Some limits are null in the route between \"%s\" and \"%s\"", + src, dst); + link_list = xbt_dynar_new(sizeof(char *), &xbt_free_ref); +} -static void routing_full_parse_change_cpu_data(const char *hostName, - const char *surfxml_host_power, - const char *surfxml_host_availability, - const char *surfxml_host_availability_file, - const char *surfxml_host_state_file) +/** + * \brief Set the endpoints for a route from XML + */ +static void parse_S_route_new_and_endpoints_XML(void) { - int AX_ptr = 0; + parse_S_route_new_and_endpoints(A_surfxml_route_src, + A_surfxml_route_dst); +} - SURFXML_BUFFER_SET(host_id, hostName); - SURFXML_BUFFER_SET(host_power, surfxml_host_power /*hostPower */ ); - SURFXML_BUFFER_SET(host_availability, surfxml_host_availability); - SURFXML_BUFFER_SET(host_availability_file, surfxml_host_availability_file); - SURFXML_BUFFER_SET(host_state_file, surfxml_host_state_file); +/** + * \brief Set the endpoints for a route from lua + */ +static void parse_S_route_new_and_endpoints_lua(const char *id_src, const char *id_dst) +{ + parse_S_route_new_and_endpoints(id_src, id_dst); } -static void routing_full_parse_change_link_data(const char *linkName, - const char *surfxml_link_bandwidth, - const char *surfxml_link_bandwidth_file, - const char *surfxml_link_latency, - const char *surfxml_link_latency_file, - const char *surfxml_link_state_file) +/** + * \brief Set the endponints and gateways for a ASroute + */ +static void parse_S_ASroute_new_and_endpoints(void) { - int AX_ptr = 0; + if (src != NULL && dst != NULL && link_list != NULL) + THROWF(arg_error, 0, "Route between %s to %s can not be defined", + A_surfxml_ASroute_src, A_surfxml_ASroute_dst); + src = A_surfxml_ASroute_src; + dst = A_surfxml_ASroute_dst; + gw_src = A_surfxml_ASroute_gw_src; + gw_dst = A_surfxml_ASroute_gw_dst; + xbt_assert(strlen(src) > 0 || strlen(dst) > 0 || strlen(gw_src) > 0 + || strlen(gw_dst) > 0, + "Some limits are null in the route between \"%s\" and \"%s\"", + src, dst); + link_list = xbt_dynar_new(sizeof(char *), &xbt_free_ref); +} - SURFXML_BUFFER_SET(link_id, linkName); - SURFXML_BUFFER_SET(link_bandwidth, surfxml_link_bandwidth); - SURFXML_BUFFER_SET(link_bandwidth_file, surfxml_link_bandwidth_file); - SURFXML_BUFFER_SET(link_latency, surfxml_link_latency); - SURFXML_BUFFER_SET(link_latency_file, surfxml_link_latency_file); - SURFXML_BUFFER_SET(link_state_file, surfxml_link_state_file); +/** + * \brief Set the endponints for a bypassRoute + */ +static void parse_S_bypassRoute_new_and_endpoints(void) +{ + if (src != NULL && dst != NULL && link_list != NULL) + THROWF(arg_error, 0, + "Bypass Route between %s to %s can not be defined", + A_surfxml_bypassRoute_src, A_surfxml_bypassRoute_dst); + src = A_surfxml_bypassRoute_src; + dst = A_surfxml_bypassRoute_dst; + gw_src = A_surfxml_bypassRoute_gw_src; + gw_dst = A_surfxml_bypassRoute_gw_dst; + xbt_assert(strlen(src) > 0 || strlen(dst) > 0 || strlen(gw_src) > 0 + || strlen(gw_dst) > 0, + "Some limits are null in the route between \"%s\" and \"%s\"", + src, dst); + link_list = xbt_dynar_new(sizeof(char *), &xbt_free_ref); } -static void routing_full_parse_Scluster(void) +/** + * \brief Set a new link on the actual list of link for a route or ASroute + */ +static void parse_E_link_ctn_new_elem(const char *link_id) { - static int AX_ptr = 0; + char *val; + val = xbt_strdup(link_id); + xbt_dynar_push(link_list, &val); +} - char *cluster_id = A_surfxml_cluster_id; - char *cluster_prefix = A_surfxml_cluster_prefix; - char *cluster_suffix = A_surfxml_cluster_suffix; - char *cluster_radical = A_surfxml_cluster_radical; - char *cluster_power = A_surfxml_cluster_power; - char *cluster_bw = A_surfxml_cluster_bw; - char *cluster_lat = A_surfxml_cluster_lat; - char *cluster_bb_bw = A_surfxml_cluster_bb_bw; - char *cluster_bb_lat = A_surfxml_cluster_bb_lat; - char *backbone_name; - unsigned int it1,it2; - char *name1,*name2; - xbt_dynar_t names = NULL; - surfxml_bufferstack_push(1); +/** + * \brief Set a new link on the actual list of link for a route or ASroute from XML + */ - /* Make set a set to parse the prefix/suffix/radical into a neat list of names */ - DEBUG4("Make ", - cluster_id,cluster_prefix,cluster_suffix,cluster_radical); - SURFXML_BUFFER_SET(set_id, cluster_id); - SURFXML_BUFFER_SET(set_prefix, cluster_prefix); - SURFXML_BUFFER_SET(set_suffix, cluster_suffix); - SURFXML_BUFFER_SET(set_radical, cluster_radical); +static void parse_E_link_ctn_new_elem_XML(void) +{ + if (A_surfxml_link_ctn_direction == A_surfxml_link_ctn_direction_NONE) + parse_E_link_ctn_new_elem(A_surfxml_link_ctn_id); + if (A_surfxml_link_ctn_direction == A_surfxml_link_ctn_direction_UP) { + char *link_id = bprintf("%s_UP", A_surfxml_link_ctn_id); + parse_E_link_ctn_new_elem(link_id); + free(link_id); + } + if (A_surfxml_link_ctn_direction == A_surfxml_link_ctn_direction_DOWN) { + char *link_id = bprintf("%s_DOWN", A_surfxml_link_ctn_id); + parse_E_link_ctn_new_elem(link_id); + free(link_id); + } +} - SURFXML_START_TAG(set); - SURFXML_END_TAG(set); +/** + * \brief Set a new link on the actual list of link for a route or ASroute from lua + */ +static void parse_E_link_c_ctn_new_elem_lua(const char *link_id) +{ + parse_E_link_ctn_new_elem(link_id); +} - names = xbt_dict_get(set_list,cluster_id); +/** + * \brief Store the route by calling the set_route function of the current routing component + */ +static void parse_E_route_store_route(void) +{ + name_route_extended_t route = xbt_new0(s_name_route_extended_t, 1); + route->generic_route.link_list = link_list; + xbt_assert(current_routing->set_route, + "no defined method \"set_route\" in \"%s\"", + current_routing->name); + (*(current_routing->set_route)) (current_routing, src, dst, route); + link_list = NULL; + src = NULL; + dst = NULL; +} - xbt_dynar_foreach(names,it1,name1) { - /* create the host */ - routing_full_parse_change_cpu_data(name1, cluster_power, "1.0", "", ""); - A_surfxml_host_state = A_surfxml_host_state_ON; +/** + * \brief Store the ASroute by calling the set_ASroute function of the current routing component + */ +static void parse_E_ASroute_store_route(void) +{ + name_route_extended_t e_route = xbt_new0(s_name_route_extended_t, 1); + e_route->generic_route.link_list = link_list; + e_route->src_gateway = xbt_strdup(gw_src); + e_route->dst_gateway = xbt_strdup(gw_dst); + xbt_assert(current_routing->set_ASroute, + "no defined method \"set_ASroute\" in \"%s\"", + current_routing->name); + (*(current_routing->set_ASroute)) (current_routing, src, dst, e_route); + link_list = NULL; + src = NULL; + dst = NULL; + gw_src = NULL; + gw_dst = NULL; +} - SURFXML_START_TAG(host); - SURFXML_END_TAG(host); +/** + * \brief Store the bypass route by calling the set_bypassroute function of the current routing component + */ +static void parse_E_bypassRoute_store_route(void) +{ + route_extended_t e_route = xbt_new0(s_route_extended_t, 1); + e_route->generic_route.link_list = link_list; + e_route->src_gateway = xbt_strdup(gw_src); + e_route->dst_gateway = xbt_strdup(gw_dst); + xbt_assert(current_routing->set_bypassroute, + "no defined method \"set_bypassroute\" in \"%s\"", + current_routing->name); + (*(current_routing->set_bypassroute)) (current_routing, src, dst, + e_route); + link_list = NULL; + src = NULL; + dst = NULL; + gw_src = NULL; + gw_dst = NULL; +} - /* Here comes the link */ - routing_full_parse_change_link_data(name1, cluster_bw, "", cluster_lat, "", ""); - A_surfxml_link_state = A_surfxml_link_state_ON; - A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED; +/** + * \brief Make a new routing component + * + * make the new structure and + * set the parsing functions to allows parsing the part of the routing tree + */ +static void parse_S_AS(char *AS_id, char *AS_routing) +{ + routing_component_t new_routing; + model_type_t model = NULL; + char *wanted = AS_routing; + int cpt; + /* seach the routing model */ + for (cpt = 0; routing_models[cpt].name; cpt++) + if (!strcmp(wanted, routing_models[cpt].name)) + model = &routing_models[cpt]; + /* if its not exist, error */ + if (model == NULL) { + fprintf(stderr, "Routing model %s not found. Existing models:\n", + wanted); + for (cpt = 0; routing_models[cpt].name; cpt++) + if (!strcmp(wanted, routing_models[cpt].name)) + fprintf(stderr, " %s: %s\n", routing_models[cpt].name, + routing_models[cpt].desc); + xbt_die(NULL); + } + + /* make a new routing component */ + new_routing = (routing_component_t) (*(model->create)) (); + new_routing->routing = model; + new_routing->hierarchy = SURF_ROUTING_NULL; + new_routing->name = xbt_strdup(AS_id); + new_routing->routing_sons = xbt_dict_new(); + + /* Hack for Vivaldi */ + if(!strcmp(model->name,"Vivaldi")) + new_routing->get_latency = vivaldi_get_link_latency; + + if (current_routing == NULL && global_routing->root == NULL) { + + /* it is the first one */ + new_routing->routing_father = NULL; + global_routing->root = new_routing; + + } else if (current_routing != NULL && global_routing->root != NULL) { + + xbt_assert(!xbt_dict_get_or_null + (current_routing->routing_sons, AS_id), + "The AS \"%s\" already exists", AS_id); + /* it is a part of the tree */ + new_routing->routing_father = current_routing; + /* set the father behavior */ + if (current_routing->hierarchy == SURF_ROUTING_NULL) + current_routing->hierarchy = SURF_ROUTING_RECURSIVE; + /* add to the sons dictionary */ + xbt_dict_set(current_routing->routing_sons, AS_id, + (void *) new_routing, NULL); + /* add to the father element list */ + (*(current_routing->set_autonomous_system)) (current_routing, AS_id); + /* unload the prev parse rules */ + (*(current_routing->routing->unload)) (); - SURFXML_START_TAG(link); - SURFXML_END_TAG(link); + } else { + THROWF(arg_error, 0, "All defined components must be belong to a AS"); } + /* set the new parse rules */ + (*(new_routing->routing->load)) (); + /* set the new current component of the tree */ + current_routing = new_routing; +} - /* Make backbone link */ - backbone_name = bprintf("%s_bb", cluster_id); - routing_full_parse_change_link_data(backbone_name, cluster_bb_bw, "", cluster_bb_lat, "", - ""); - A_surfxml_link_state = A_surfxml_link_state_ON; - A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_FATPIPE; +/* + * Detect the routing model type of the routing component from XML platforms + */ +static void parse_S_AS_XML(void) +{ + parse_S_AS(A_surfxml_AS_id, A_surfxml_AS_routing); +} - SURFXML_START_TAG(link); - SURFXML_END_TAG(link); +/* + * define the routing model type of routing component from lua script + */ +static void parse_S_AS_lua(char *id, char *mode) +{ + parse_S_AS(id, mode); +} - /* And now the internal routes */ - xbt_dynar_foreach(names,it1,name1) { - xbt_dynar_foreach(names,it2,name2) { - if (strcmp(name1,name2)) { - A_surfxml_route_action = A_surfxml_route_action_POSTPEND; - SURFXML_BUFFER_SET(route_src,name1); - SURFXML_BUFFER_SET(route_dst,name2); - SURFXML_START_TAG(route); { - /* FIXME: name1 link is added by error about 20 lines below, so don't add it here - SURFXML_BUFFER_SET(link_c_ctn_id, name1); - SURFXML_START_TAG(link_c_ctn); - SURFXML_END_TAG(link_c_ctn); - */ - SURFXML_BUFFER_SET(link_c_ctn_id, backbone_name); - SURFXML_START_TAG(link_c_ctn); - SURFXML_END_TAG(link_c_ctn); - - SURFXML_BUFFER_SET(link_c_ctn_id, name2); - SURFXML_START_TAG(link_c_ctn); - SURFXML_END_TAG(link_c_ctn); - - } SURFXML_END_TAG(route); - } - } + +/** + * \brief Finish the creation of a new routing component + * + * When you finish to read the routing component, other structures must be created. + * the "end" method allow to do that for any routing model type + */ +static void parse_E_AS(const char *AS_id) +{ + + if (current_routing == NULL) { + THROWF(arg_error, 0, "Close AS(%s), that never open", AS_id); + } else { + network_element_info_t info = NULL; + xbt_assert(!xbt_lib_get_or_null(as_router_lib,current_routing->name, ROUTING_ASR_LEVEL), + "The AS \"%s\" already exists",current_routing->name); + info = xbt_new0(s_network_element_info_t, 1); + info->rc_component = current_routing->routing_father; + info->rc_type = SURF_NETWORK_ELEMENT_AS; + xbt_lib_set(as_router_lib,current_routing->name,ROUTING_ASR_LEVEL,(void *) info); + + (*(current_routing->routing->unload)) (); + (*(current_routing->routing->end)) (); + current_routing = current_routing->routing_father; + if (current_routing != NULL) + (*(current_routing->routing->load)) (); } +} - /* Make route multi with the outside world, i.e. cluster->$* */ +/* + * \brief Finish the creation of a new routing component from XML + */ +static void parse_E_AS_XML(void) +{ + parse_E_AS(A_surfxml_AS_id); +} - /* FIXME - * This also adds an elements to the routes within the cluster, - * and I guess it's wrong, but since this element is commented out in the above - * code creating the internal routes, we're good. - * To fix it, I'd say that we need a way to understand "$*-${cluster_id}" as "whole world, but the guys in that cluster" - * But for that, we need to install a real expression parser for src/dst attributes - * - * FIXME - * This also adds a dumb element (the private link) in place of the loopback. Then, since - * the loopback is added only if no link to self already exist, this fails. - * That's really dumb. - * - * FIXME - * It seems to me that it does not add the backbone to the path to outside world... - */ - SURFXML_BUFFER_SET(route_c_multi_src, cluster_id); - SURFXML_BUFFER_SET(route_c_multi_dst, "$*"); - A_surfxml_route_c_multi_symmetric = A_surfxml_route_c_multi_symmetric_NO; - A_surfxml_route_c_multi_action = A_surfxml_route_c_multi_action_PREPEND; +/* + * \brief Finish the creation of a new routing component from lua + */ +static void parse_E_AS_lua(const char *id) +{ + parse_E_AS(id); +} - SURFXML_START_TAG(route_c_multi); +/* Aux Business methods */ - SURFXML_BUFFER_SET(link_c_ctn_id, "$src"); +/** + * \brief Get the AS name of the element + * + * \param name the host name + * + */ +static char* elements_As_name(const char *name) +{ + routing_component_t as_comp; - SURFXML_START_TAG(link_c_ctn); - SURFXML_END_TAG(link_c_ctn); + /* (1) find the as where the host is located */ + as_comp = ((network_element_info_t) + xbt_lib_get_or_null(host_lib,name, ROUTING_HOST_LEVEL))->rc_component; + return as_comp->name; +} - SURFXML_END_TAG(route_c_multi); - free(backbone_name); +/** + * \brief Get the AS father and the first elements of the chain + * + * \param src the source host name + * \param dst the destination host name + * + * Get the common father of the to processing units, and the first different + * father in the chain + */ +static void elements_father(const char *src, const char *dst, + routing_component_t *res_father, + routing_component_t *res_src, + routing_component_t *res_dst) +{ + xbt_assert(src && dst, "bad parameters for \"elements_father\" method"); +#define ELEMENTS_FATHER_MAXDEPTH 16 /* increase if it is not enough */ + routing_component_t src_as, dst_as; + routing_component_t path_src[ELEMENTS_FATHER_MAXDEPTH]; + routing_component_t path_dst[ELEMENTS_FATHER_MAXDEPTH]; + int index_src = 0; + int index_dst = 0; + routing_component_t current; + routing_component_t current_src; + routing_component_t current_dst; + routing_component_t father; + + /* (1) find the as where the src and dst are located */ + network_element_info_t src_data = xbt_lib_get_or_null(host_lib, src, + ROUTING_HOST_LEVEL); + network_element_info_t dst_data = xbt_lib_get_or_null(host_lib, dst, + ROUTING_HOST_LEVEL); + if (!src_data) + src_data = xbt_lib_get_or_null(as_router_lib, src, ROUTING_ASR_LEVEL); + if (!dst_data) + dst_data = xbt_lib_get_or_null(as_router_lib, dst, ROUTING_ASR_LEVEL); + src_as = src_data->rc_component; + dst_as = dst_data->rc_component; + + xbt_assert(src_as && dst_as, + "Ask for route \"from\"(%s) or \"to\"(%s) no found", src, dst); + + /* (2) find the path to the root routing component */ + for (current = src_as ; current != NULL ; current = current->routing_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->routing_father) { + if (index_dst >= ELEMENTS_FATHER_MAXDEPTH) + xbt_die("ELEMENTS_FATHER_MAXDEPTH should be increased for path_dst"); + path_dst[index_dst++] = current; + } - /* Restore buff */ - surfxml_bufferstack_pop(1); + /* (3) find the common father */ + do { + current_src = path_src[--index_src]; + current_dst = path_dst[--index_dst]; + } while (index_src > 0 && index_dst > 0 && current_src == current_dst); + + /* (4) they are not in the same routing component, make the path */ + if (current_src == current_dst) + father = current_src; + else + father = path_src[index_src + 1]; + + /* (5) result generation */ + *res_father = father; /* first the common father of src and dst */ + *res_src = current_src; /* second the first different father of src */ + *res_dst = current_dst; /* three the first different father of dst */ + +#undef ELEMENTS_FATHER_MAXDEPTH } +/* Global Business methods */ -static void routing_full_parse_end(void) { - routing_full_t routing = (routing_full_t) used_routing; - int nb_link = 0; - unsigned int cpt = 0; - xbt_dict_cursor_t cursor = NULL; - char *key, *data, *end; - const char *sep = "#"; - xbt_dynar_t links, keys; - char *link_name = NULL; - int i,j; - - int host_count = routing->generic_routing.host_count; - - /* Create the routing table */ - routing->routing_table = xbt_new0(xbt_dynar_t, host_count * host_count); - for (i=0;isize_of_link,NULL); - - /* Put the routes in position */ - xbt_dict_foreach(route_table, cursor, key, data) { - nb_link = 0; - links = (xbt_dynar_t) data; - keys = xbt_str_split_str(key, sep); - - src_id = strtol(xbt_dynar_get_as(keys, 0, char *), &end, 16); - dst_id = strtol(xbt_dynar_get_as(keys, 1, char *), &end, 16); - xbt_dynar_free(&keys); - - if(xbt_dynar_length(links) == 1){ - s_onelink_t new_link = (s_onelink_t) xbt_malloc0(sizeof(s_onelink)); - new_link->src_id = src_id; - new_link->dst_id = dst_id; - link_name = xbt_dynar_getfirst_as(links, char*); - new_link->link_ptr = xbt_dict_get_or_null(surf_network_model->resource_set, link_name); - DEBUG3("Adding onelink route from (#%d) to (#%d), link_name %s",src_id, dst_id, link_name); - xbt_dict_set(onelink_routes, link_name, (void *)new_link, onelink_route_elem_free); -#ifdef HAVE_TRACING - TRACE_surf_link_save_endpoints (link_name, src_id, dst_id); -#endif +/** + * \brief Recursive function for get_route_latency + * + * \param src the source host name + * \param dst the destination host name + * \param *e_route the route where the links are stored + * \param *latency the latency, if needed + * + * This function is called by "get_route" and "get_latency". It allows to walk + * recursively through the routing components tree. + */ +static void _get_route_latency(const char *src, const char *dst, + xbt_dynar_t *route, double *latency) +{ + XBT_DEBUG("Solve route/latency \"%s\" to \"%s\"", src, dst); + xbt_assert(src && dst, "bad parameters for \"_get_route_latency\" method"); + + routing_component_t common_father; + routing_component_t src_father; + routing_component_t dst_father; + elements_father(src, dst, &common_father, &src_father, &dst_father); + + if (src_father == dst_father) { /* SURF_ROUTING_BASE */ + + route_extended_t e_route = NULL; + if (route) { + e_route = common_father->get_route(common_father, src, dst); + xbt_assert(e_route, "no route between \"%s\" and \"%s\"", src, dst); + *route = e_route->generic_route.link_list; + } + if (latency) { + *latency = common_father->get_latency(common_father, src, dst, e_route); + xbt_assert(*latency >= 0.0, + "latency error on route between \"%s\" and \"%s\"", src, dst); + } + if (e_route) { + xbt_free(e_route->src_gateway); + xbt_free(e_route->dst_gateway); + xbt_free(e_route); + } + + } else { /* SURF_ROUTING_RECURSIVE */ + + route_extended_t e_route_bypass = NULL; + if (common_father->get_bypass_route) + e_route_bypass = common_father->get_bypass_route(common_father, src, dst); + + xbt_assert(!latency || !e_route_bypass, + "Bypass cannot work yet with get_latency"); + + route_extended_t e_route_cnt = e_route_bypass + ? e_route_bypass + : common_father->get_route(common_father, + src_father->name, dst_father->name); + + xbt_assert(e_route_cnt, "no route between \"%s\" and \"%s\"", + src_father->name, dst_father->name); + + xbt_assert((e_route_cnt->src_gateway == NULL) == + (e_route_cnt->dst_gateway == NULL), + "bad gateway for route between \"%s\" and \"%s\"", src, dst); + + if (route) { + *route = xbt_dynar_new(global_routing->size_of_link, NULL); + } + if (latency) { + *latency = common_father->get_latency(common_father, + src_father->name, dst_father->name, + e_route_cnt); + xbt_assert(*latency >= 0.0, + "latency error on route between \"%s\" and \"%s\"", + src_father->name, dst_father->name); } - if(ISROUTER(src_id) || ISROUTER(dst_id)) { - DEBUG2("There is route with a router here: (%d ,%d)",src_id,dst_id); - /* Check there is only one link in the route and store the information */ - continue; + void *link; + unsigned int cpt; + + if (strcmp(src, e_route_cnt->src_gateway)) { + double latency_src; + xbt_dynar_t route_src; + + _get_route_latency(src, e_route_cnt->src_gateway, + (route ? &route_src : NULL), + (latency ? &latency_src : NULL)); + if (route) { + xbt_assert(route_src, "no route between \"%s\" and \"%s\"", + src, e_route_cnt->src_gateway); + xbt_dynar_foreach(route_src, cpt, link) { + xbt_dynar_push(*route, &link); + } + xbt_dynar_free(&route_src); + } + if (latency) { + xbt_assert(latency_src >= 0.0, + "latency error on route between \"%s\" and \"%s\"", + src, e_route_cnt->src_gateway); + *latency += latency_src; + } } - DEBUG4("Handle %d %d (from %d hosts): %ld links", - src_id,dst_id,routing->generic_routing.host_count,xbt_dynar_length(links)); - xbt_dynar_foreach(links, cpt, link_name) { - void* link = xbt_dict_get_or_null(surf_network_model->resource_set, link_name); - if (link) - xbt_dynar_push(ROUTE_FULL(src_id,dst_id),&link); - else - THROW1(mismatch_error,0,"Link %s not found", link_name); + if (route) { + xbt_dynar_foreach(e_route_cnt->generic_route.link_list, cpt, link) { + xbt_dynar_push(*route, &link); + } } + + if (strcmp(e_route_cnt->dst_gateway, dst)) { + double latency_dst; + xbt_dynar_t route_dst; + + _get_route_latency(e_route_cnt->dst_gateway, dst, + (route ? &route_dst : NULL), + (latency ? &latency_dst : NULL)); + if (route) { + xbt_assert(route_dst, "no route between \"%s\" and \"%s\"", + e_route_cnt->dst_gateway, dst); + xbt_dynar_foreach(route_dst, cpt, link) { + xbt_dynar_push(*route, &link); + } + xbt_dynar_free(&route_dst); + } + if (latency) { + xbt_assert(latency_dst >= 0.0, + "latency error on route between \"%s\" and \"%s\"", + e_route_cnt->dst_gateway, dst); + *latency += latency_dst; + } + } + + generic_free_extended_route(e_route_cnt); } +} - /* Add the loopback if needed */ - for (i = 0; i < host_count; i++) - if (!xbt_dynar_length(ROUTE_FULL(i, i))) - xbt_dynar_push(ROUTE_FULL(i,i),&routing->loopback); +/** + * \brief Generic function for get_route, get_route_no_cleanup, and get_latency + */ +static void get_route_latency(const char *src, const char *dst, + xbt_dynar_t *route, double *latency, int cleanup) +{ + _get_route_latency(src, dst, route, latency); + xbt_assert(!route || *route, "no route between \"%s\" and \"%s\"", src, dst); + xbt_assert(!latency || *latency >= 0.0, + "latency error on route between \"%s\" and \"%s\"", src, dst); + if (route) { + xbt_dynar_free(&global_routing->last_route); + global_routing->last_route = cleanup ? *route : NULL; + } +} - /* Shrink the dynar routes (save unused slots) */ - for (i=0;irouting_sons, cursor, key, elem) { + _finalize(elem); + } + xbt_dict_t tmp_sons = rc->routing_sons; + char *tmp_name = rc->name; + xbt_dict_free(&tmp_sons); + xbt_free(tmp_name); + xbt_assert(rc->finalize, "no defined method \"finalize\" in \"%s\"", + current_routing->name); + (*(rc->finalize)) (rc); + } } -static void routing_full_finalize(void) { - routing_full_t routing = (routing_full_t)used_routing; - int i,j; +/** + * \brief Generic method: delete all the routing structures + * + * walk through the routing components tree and delete the structures + * by calling the differents "finalize" functions in each routing component + */ +static void finalize(void) +{ + /* delete recursibly all the tree */ + _finalize(global_routing->root); + /* delete last_route */ + xbt_dynar_free(&(global_routing->last_route)); + /* delete global routing structure */ + xbt_free(global_routing); +} - if (routing) { - for (i = 0; i < used_routing->host_count; i++) - for (j = 0; j < used_routing->host_count; j++) - xbt_dynar_free(&ROUTE_FULL(i, j)); - free(routing->routing_table); - xbt_dict_free(&used_routing->host_id); - xbt_dict_free(&onelink_routes); - free(routing); - routing=NULL; +static xbt_dynar_t recursive_get_onelink_routes(routing_component_t rc) +{ + xbt_dynar_t ret = xbt_dynar_new(sizeof(onelink_t), xbt_free); + + //adding my one link routes + unsigned int cpt; + void *link; + xbt_dynar_t onelink_mine = rc->get_onelink_routes(rc); + if (onelink_mine) { + xbt_dynar_foreach(onelink_mine, cpt, link) { + xbt_dynar_push(ret, &link); + } + } + //recursing + char *key; + xbt_dict_cursor_t cursor = NULL; + routing_component_t rc_child; + xbt_dict_foreach(rc->routing_sons, cursor, key, rc_child) { + xbt_dynar_t onelink_child = recursive_get_onelink_routes(rc_child); + if (onelink_child) { + xbt_dynar_foreach(onelink_child, cpt, link) { + xbt_dynar_push(ret, &link); + } + } } + return ret; } -static void routing_model_full_create(size_t size_of_link,void *loopback) { - /* initialize our structure */ - routing_full_t routing = xbt_new0(s_routing_full_t,1); - routing->generic_routing.name = "Full"; - routing->generic_routing.host_count = 0; - routing->generic_routing.get_route = routing_full_get_route; - routing->generic_routing.get_onelink_routes = routing_full_get_onelink_routes; - routing->generic_routing.is_router = routing_full_is_router; - routing->generic_routing.finalize = routing_full_finalize; +static xbt_dynar_t get_onelink_routes(void) +{ + return recursive_get_onelink_routes(global_routing->root); +} - routing->size_of_link = size_of_link; - routing->loopback = loopback; +e_surf_network_element_type_t get_network_element_type(const char + *name) +{ + network_element_info_t rc = NULL; - /* Set it in position */ - used_routing = (routing_t) routing; + rc = xbt_lib_get_or_null(host_lib, name, ROUTING_HOST_LEVEL); + if(rc) return rc->rc_type; - /* Set the dict for onehop routes */ - onelink_routes = xbt_dict_new(); + rc = xbt_lib_get_or_null(as_router_lib, name, ROUTING_ASR_LEVEL); + if(rc) return rc->rc_type; - /* Setup the parsing callbacks we need */ - routing->generic_routing.host_id = xbt_dict_new(); - surfxml_add_callback(STag_surfxml_host_cb_list, &routing_full_parse_Shost); - surfxml_add_callback(STag_surfxml_router_cb_list, &routing_full_parse_Srouter); - surfxml_add_callback(ETag_surfxml_platform_cb_list, &routing_full_parse_end); - surfxml_add_callback(STag_surfxml_route_cb_list, - &routing_full_parse_Sroute_set_endpoints); - surfxml_add_callback(ETag_surfxml_route_cb_list, &routing_full_parse_Eroute); - surfxml_add_callback(STag_surfxml_cluster_cb_list, &routing_full_parse_Scluster); + return SURF_NETWORK_ELEMENT_NULL; } -/* ************************************************************************** */ - -static void routing_shortest_path_parse_Scluster(void) +/** + * \brief Generic method: create the global routing schema + * + * Make a global routing structure and set all the parsing functions. + */ +void routing_model_create(size_t size_of_links, void *loopback, double_f_cpvoid_t get_link_latency_fun) { - static int AX_ptr = 0; + /* config the uniq global routing */ + global_routing = xbt_new0(s_routing_global_t, 1); + global_routing->root = NULL; + global_routing->get_route = get_route; + global_routing->get_latency = get_latency; + global_routing->get_route_no_cleanup = get_route_no_cleanup; + global_routing->get_onelink_routes = get_onelink_routes; + global_routing->get_route_latency = get_route_latency; + global_routing->get_network_element_type = get_network_element_type; + global_routing->finalize = finalize; + global_routing->loopback = loopback; + global_routing->size_of_link = size_of_links; + global_routing->last_route = NULL; + get_link_latency = get_link_latency_fun; + /* no current routing at moment */ + current_routing = NULL; + + /* parse generic elements */ + surfxml_add_callback(STag_surfxml_host_cb_list, &parse_S_host_XML); + surfxml_add_callback(ETag_surfxml_host_cb_list, &parse_E_host_XML); + surfxml_add_callback(STag_surfxml_router_cb_list, &parse_S_router_XML); - char *cluster_id = A_surfxml_cluster_id; - char *cluster_prefix = A_surfxml_cluster_prefix; - char *cluster_suffix = A_surfxml_cluster_suffix; - char *cluster_radical = A_surfxml_cluster_radical; - char *cluster_power = A_surfxml_cluster_power; - char *cluster_bb_bw = A_surfxml_cluster_bb_bw; - char *cluster_bb_lat = A_surfxml_cluster_bb_lat; - char *backbone_name; + surfxml_add_callback(STag_surfxml_route_cb_list, + &parse_S_route_new_and_endpoints_XML); + surfxml_add_callback(STag_surfxml_ASroute_cb_list, + &parse_S_ASroute_new_and_endpoints); + surfxml_add_callback(STag_surfxml_bypassRoute_cb_list, + &parse_S_bypassRoute_new_and_endpoints); - surfxml_bufferstack_push(1); + surfxml_add_callback(ETag_surfxml_link_ctn_cb_list, + &parse_E_link_ctn_new_elem_XML); - /* Make set */ - SURFXML_BUFFER_SET(set_id, cluster_id); - SURFXML_BUFFER_SET(set_prefix, cluster_prefix); - SURFXML_BUFFER_SET(set_suffix, cluster_suffix); - SURFXML_BUFFER_SET(set_radical, cluster_radical); + surfxml_add_callback(ETag_surfxml_route_cb_list, + &parse_E_route_store_route); + surfxml_add_callback(ETag_surfxml_ASroute_cb_list, + &parse_E_ASroute_store_route); + surfxml_add_callback(ETag_surfxml_bypassRoute_cb_list, + &parse_E_bypassRoute_store_route); - SURFXML_START_TAG(set); - SURFXML_END_TAG(set); + surfxml_add_callback(STag_surfxml_AS_cb_list, &parse_S_AS_XML); + surfxml_add_callback(ETag_surfxml_AS_cb_list, &parse_E_AS_XML); - /* Make foreach */ - SURFXML_BUFFER_SET(foreach_set_id, cluster_id); + surfxml_add_callback(STag_surfxml_cluster_cb_list, + &routing_parse_Scluster); - SURFXML_START_TAG(foreach); + surfxml_add_callback(STag_surfxml_peer_cb_list, + &routing_parse_Speer); - /* Make host for the foreach */ - routing_full_parse_change_cpu_data("$1", cluster_power, "1.0", "", ""); - A_surfxml_host_state = A_surfxml_host_state_ON; + surfxml_add_callback(ETag_surfxml_platform_cb_list, + &clean_dict_random); - SURFXML_START_TAG(host); - SURFXML_END_TAG(host); +#ifdef HAVE_TRACING + instr_routing_define_callbacks(); +#endif +} - SURFXML_END_TAG(foreach); +void surf_parse_add_callback_config(void) +{ + surfxml_add_callback(STag_surfxml_config_cb_list, &routing_parse_Sconfig); + surfxml_add_callback(ETag_surfxml_config_cb_list, &routing_parse_Econfig); + surfxml_add_callback(STag_surfxml_prop_cb_list, &parse_properties_XML); + surfxml_add_callback(STag_surfxml_AS_cb_list, &surf_parse_models_setup); + surfxml_add_callback(STag_surfxml_random_cb_list, &routing_parse_Srandom); +} - /* Make backbone link */ - backbone_name = bprintf("%s_bb", cluster_id); - routing_full_parse_change_link_data(backbone_name, cluster_bb_bw, "", cluster_bb_lat, "", - ""); - A_surfxml_link_state = A_surfxml_link_state_ON; - A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_FATPIPE; +void surf_parse_models_setup() +{ + routing_parse_Erandom(); + surfxml_del_callback(STag_surfxml_AS_cb_list, surf_parse_models_setup); + surf_config_models_setup(platform_filename); + free(platform_filename); +} - SURFXML_START_TAG(link); - SURFXML_END_TAG(link); +/* ************************************************** */ +/* ********** PATERN FOR NEW ROUTING **************** */ - free(backbone_name); +/* 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 */ - /* Restore buff */ - surfxml_bufferstack_pop(1); +/* ************************************************************************** */ +/* ************************* GENERIC PARSE FUNCTIONS ************************ */ + +void generic_set_processing_unit(routing_component_t rc, + const char *name) +{ + XBT_DEBUG("Load process unit \"%s\"", name); + int *id = xbt_new0(int, 1); + xbt_dict_t _to_index; + _to_index = current_routing->to_index; + *id = xbt_dict_length(_to_index); + xbt_dict_set(_to_index, name, id, xbt_free); +} + +void generic_set_autonomous_system(routing_component_t rc, + const char *name) +{ + XBT_DEBUG("Load Autonomous system \"%s\"", name); + int *id = xbt_new0(int, 1); + xbt_dict_t _to_index; + _to_index = current_routing->to_index; + *id = xbt_dict_length(_to_index); + xbt_dict_set(_to_index, name, id, xbt_free); +} + +int surf_pointer_resource_cmp(const void *a, const void *b) +{ + return a != b; +} + +int surf_link_resource_cmp(const void *a, const void *b) +{ + return !!memcmp(a,b,global_routing->size_of_link); +} + +void generic_set_bypassroute(routing_component_t rc, + const char *src, const char *dst, + route_extended_t e_route) +{ + XBT_DEBUG("Load bypassRoute from \"%s\" to \"%s\"", src, dst); + xbt_dict_t dict_bypassRoutes = rc->bypassRoutes; + char *route_name; + + route_name = bprintf("%s#%s", src, dst); + xbt_assert(xbt_dynar_length(e_route->generic_route.link_list) > 0, + "Invalid count of links, must be greater than zero (%s,%s)", + src, dst); + xbt_assert(!xbt_dict_get_or_null(dict_bypassRoutes, route_name), + "The bypass route between \"%s\"(\"%s\") and \"%s\"(\"%s\") already exists", + src, e_route->src_gateway, dst, e_route->dst_gateway); + + route_extended_t new_e_route = + generic_new_extended_route(SURF_ROUTING_RECURSIVE, e_route, 0); + xbt_dynar_free(&(e_route->generic_route.link_list)); + xbt_free(e_route); + + xbt_dict_set(dict_bypassRoutes, route_name, new_e_route, + (void (*)(void *)) generic_free_extended_route); + xbt_free(route_name); } /* ************************************************************************** */ -/* *************************** FLOYD ROUTING ********************************* */ -typedef struct { - s_routing_t generic_routing; - int *predecessor_table; - void** link_table; - xbt_dynar_t last_route; - void *loopback; - size_t size_of_link; -} s_routing_floyd_t,*routing_floyd_t; - -#define FLOYD_COST(i,j) cost_table[(i)+(j)*(used_routing)->host_count] -#define FLOYD_PRED(i,j) ((routing_floyd_t)used_routing)->predecessor_table[(i)+(j)*(used_routing)->host_count] -#define FLOYD_LINK(i,j) ((routing_floyd_t)used_routing)->link_table[(i)+(j)*(used_routing)->host_count] - -static void routing_floyd_parse_end(void) { - - routing_floyd_t routing = (routing_floyd_t) used_routing; - int nb_link = 0; - void* link_list = NULL; - double * cost_table; - xbt_dict_cursor_t cursor = NULL; - char *key,*data, *end; - const char *sep = "#"; - xbt_dynar_t links, keys; - - unsigned int i,j; - unsigned int a,b,c; - int host_count = routing->generic_routing.host_count; - char * link_name = NULL; - void * link = NULL; - - /* Create Cost, Predecessor and Link tables */ - cost_table = xbt_new0(double, host_count * host_count); //link cost from host to host - routing->predecessor_table = xbt_new0(int, host_count*host_count); //predecessor host numbers - routing->link_table = xbt_new0(void*,host_count*host_count); //actual link between src and dst - routing->last_route = xbt_dynar_new(routing->size_of_link, NULL); - - /* Initialize costs and predecessors*/ - for(i = 0; igeneric_routing.host_count,xbt_dynar_length(links)); - xbt_assert3(xbt_dynar_length(links) == 1, "%ld links in route between host %d and %d, should be 1", xbt_dynar_length(links), src_id, dst_id); - - link_name = xbt_dynar_getfirst_as(links, char*); - link = xbt_dict_get_or_null(surf_network_model->resource_set, link_name); - - if (link) - link_list = link; - else - THROW1(mismatch_error,0,"Link %s not found", link_name); - - - FLOYD_LINK(src_id,dst_id) = link_list; - FLOYD_PRED(src_id, dst_id) = src_id; - - //link cost - FLOYD_COST(src_id, dst_id) = 1; // assume 1 for now +double generic_get_link_latency(routing_component_t rc, + const char *src, const char *dst, + route_extended_t route) +{ + int need_to_clean = route?0:1; + void * link; + unsigned int i; + double latency = 0.0; - } + route = route?route:rc->get_route(rc,src,dst); - /* Add the loopback if needed */ - for (i = 0; i < host_count; i++) - if (!FLOYD_PRED(i, i)) { - FLOYD_PRED(i, i) = i; - FLOYD_COST(i, i) = 1; - FLOYD_LINK(i, i) = routing->loopback; - } + xbt_dynar_foreach(route->generic_route.link_list,i,link) { + latency += get_link_latency(link); + } + if(need_to_clean) generic_free_extended_route(route); + return latency; +} + +xbt_dynar_t generic_get_onelink_routes(routing_component_t rc) +{ + xbt_die("\"generic_get_onelink_routes\" not implemented yet"); +} +route_extended_t generic_get_bypassroute(routing_component_t rc, + const char *src, + const char *dst) +{ + xbt_dict_t dict_bypassRoutes = rc->bypassRoutes; + routing_component_t src_as, dst_as; + int index_src, index_dst; + xbt_dynar_t path_src = NULL; + xbt_dynar_t path_dst = NULL; + routing_component_t current = NULL; + routing_component_t *current_src = NULL; + routing_component_t *current_dst = NULL; + + /* (1) find the as where the src and dst are located */ + void * src_data = xbt_lib_get_or_null(host_lib,src, ROUTING_HOST_LEVEL); + void * dst_data = xbt_lib_get_or_null(host_lib,dst, ROUTING_HOST_LEVEL); + if(!src_data) src_data = xbt_lib_get_or_null(as_router_lib,src, ROUTING_ASR_LEVEL); + if(!dst_data) dst_data = xbt_lib_get_or_null(as_router_lib,dst, ROUTING_ASR_LEVEL); + + if(src_data == NULL || dst_data == NULL) + xbt_die("Ask for route \"from\"(%s) or \"to\"(%s) no found at AS \"%s\"", + src, dst, rc->name); + + src_as = ((network_element_info_t)src_data)->rc_component; + dst_as = ((network_element_info_t)dst_data)->rc_component; + + /* (2) find the path to the root routing component */ + path_src = xbt_dynar_new(sizeof(routing_component_t), NULL); + current = src_as; + while (current != NULL) { + xbt_dynar_push(path_src, ¤t); + current = current->routing_father; + } + path_dst = xbt_dynar_new(sizeof(routing_component_t), NULL); + current = dst_as; + while (current != NULL) { + xbt_dynar_push(path_dst, ¤t); + current = current->routing_father; + } - //Calculate path costs + /* (3) find the common father */ + index_src = path_src->used - 1; + index_dst = path_dst->used - 1; + current_src = xbt_dynar_get_ptr(path_src, index_src); + current_dst = xbt_dynar_get_ptr(path_dst, index_dst); + while (index_src >= 0 && index_dst >= 0 && *current_src == *current_dst) { + xbt_dynar_pop_ptr(path_src); + xbt_dynar_pop_ptr(path_dst); + index_src--; + index_dst--; + current_src = xbt_dynar_get_ptr(path_src, index_src); + current_dst = xbt_dynar_get_ptr(path_dst, index_dst); + } - for(c=0;cused - 1; + int max_index_dst = path_dst->used - 1; + + int max_index = max(max_index_src, max_index_dst); + int i, max; + + route_extended_t e_route_bypass = NULL; + + for (max = 0; max <= max_index; max++) { + for (i = 0; i < max; i++) { + if (i <= max_index_src && max <= max_index_dst) { + char *route_name = bprintf("%s#%s", + (*(routing_component_t *) + (xbt_dynar_get_ptr + (path_src, i)))->name, + (*(routing_component_t *) + (xbt_dynar_get_ptr + (path_dst, max)))->name); + e_route_bypass = + xbt_dict_get_or_null(dict_bypassRoutes, route_name); + xbt_free(route_name); } + if (e_route_bypass) + break; + if (max <= max_index_src && i <= max_index_dst) { + char *route_name = bprintf("%s#%s", + (*(routing_component_t *) + (xbt_dynar_get_ptr + (path_src, max)))->name, + (*(routing_component_t *) + (xbt_dynar_get_ptr + (path_dst, i)))->name); + e_route_bypass = + xbt_dict_get_or_null(dict_bypassRoutes, route_name); + xbt_free(route_name); + } + if (e_route_bypass) + break; + } + + if (e_route_bypass) + break; + + if (max <= max_index_src && max <= max_index_dst) { + char *route_name = bprintf("%s#%s", + (*(routing_component_t *) + (xbt_dynar_get_ptr + (path_src, max)))->name, + (*(routing_component_t *) + (xbt_dynar_get_ptr + (path_dst, max)))->name); + e_route_bypass = xbt_dict_get_or_null(dict_bypassRoutes, route_name); + xbt_free(route_name); + } + if (e_route_bypass) + break; + } + + xbt_dynar_free(&path_src); + xbt_dynar_free(&path_dst); + + route_extended_t new_e_route = NULL; + + if (e_route_bypass) { + void *link; + unsigned int cpt = 0; + new_e_route = xbt_new0(s_route_extended_t, 1); + new_e_route->src_gateway = xbt_strdup(e_route_bypass->src_gateway); + new_e_route->dst_gateway = xbt_strdup(e_route_bypass->dst_gateway); + new_e_route->generic_route.link_list = + xbt_dynar_new(global_routing->size_of_link, NULL); + xbt_dynar_foreach(e_route_bypass->generic_route.link_list, cpt, link) { + xbt_dynar_push(new_e_route->generic_route.link_list, &link); } } - //cleanup - free(cost_table); + return new_e_route; } -/* - * Business methods - */ -static xbt_dynar_t routing_floyd_get_route(int src_id,int dst_id) { +/* ************************************************************************** */ +/* ************************* GENERIC AUX FUNCTIONS ************************** */ - routing_floyd_t routing = (routing_floyd_t) used_routing; +route_t +generic_new_route(e_surf_routing_hierarchy_t hierarchy, + void *data, int order) +{ - int pred = dst_id; - int prev_pred = 0; + char *link_name; + route_t new_route; + unsigned int cpt; + xbt_dynar_t links = NULL, links_id = NULL; - xbt_dynar_reset(routing->last_route); + new_route = xbt_new0(s_route_t, 1); + new_route->link_list = + xbt_dynar_new(global_routing->size_of_link, NULL); - do { - prev_pred = pred; - pred = FLOYD_PRED(src_id, pred); + xbt_assert(hierarchy == SURF_ROUTING_BASE, + "the hierarchy type is not SURF_ROUTING_BASE"); + + links = ((route_t) data)->link_list; - if(pred == -1) // if no pred in route -> no route to host - break; - xbt_dynar_unshift(routing->last_route, &FLOYD_LINK(pred,prev_pred)); + links_id = new_route->link_list; - } while(pred != src_id); + xbt_dynar_foreach(links, cpt, link_name) { - xbt_assert2(pred != -1, "no route from host %d to %d", src_id, dst_id); + void *link = + xbt_lib_get_or_null(link_lib, link_name, SURF_LINK_LEVEL); + if (link) { + if (order) + xbt_dynar_push(links_id, &link); + else + xbt_dynar_unshift(links_id, &link); + } else + THROWF(mismatch_error, 0, "Link %s not found", link_name); + } - return routing->last_route; + return new_route; } -static void routing_floyd_finalize(void) { - routing_floyd_t routing = (routing_floyd_t)used_routing; +route_extended_t +generic_new_extended_route(e_surf_routing_hierarchy_t hierarchy, + void *data, int order) +{ + + char *link_name; + route_extended_t e_route, new_e_route; + route_t route; + unsigned int cpt; + xbt_dynar_t links = NULL, links_id = NULL; + + new_e_route = xbt_new0(s_route_extended_t, 1); + new_e_route->generic_route.link_list = + xbt_dynar_new(global_routing->size_of_link, NULL); + new_e_route->src_gateway = NULL; + new_e_route->dst_gateway = NULL; + + xbt_assert(hierarchy == SURF_ROUTING_BASE + || hierarchy == SURF_ROUTING_RECURSIVE, + "the hierarchy type is not defined"); + + if (hierarchy == SURF_ROUTING_BASE) { + + route = (route_t) data; + links = route->link_list; - if (routing) { - free(routing->link_table); - free(routing->predecessor_table); - xbt_dynar_free(&routing->last_route); - xbt_dict_free(&used_routing->host_id); - free(routing); - routing=NULL; + } else if (hierarchy == SURF_ROUTING_RECURSIVE) { + + e_route = (route_extended_t) data; + xbt_assert(e_route->src_gateway + && e_route->dst_gateway, "bad gateway, is null"); + links = e_route->generic_route.link_list; + + /* remeber not erase the gateway names */ + new_e_route->src_gateway = strdup(e_route->src_gateway); + new_e_route->dst_gateway = strdup(e_route->dst_gateway); } -} -static xbt_dict_t routing_floyd_get_onelink_routes(void){ - xbt_assert0(0,"The get_onelink_routes feature is not supported in routing model Floyd"); -} + links_id = new_e_route->generic_route.link_list; -static int routing_floyd_is_router(int id){ - xbt_assert0(0,"The get_is_router feature is not supported in routing model Floyd"); -} + xbt_dynar_foreach(links, cpt, link_name) { -static void routing_model_floyd_create(size_t size_of_link,void *loopback) { - /* initialize our structure */ - routing_floyd_t routing = xbt_new0(s_routing_floyd_t,1); - routing->generic_routing.name = "Floyd"; - routing->generic_routing.host_count = 0; - routing->generic_routing.host_id = xbt_dict_new(); - routing->generic_routing.get_route = routing_floyd_get_route; - routing->generic_routing.get_onelink_routes = routing_floyd_get_onelink_routes; - routing->generic_routing.is_router = routing_floyd_is_router; - routing->generic_routing.finalize = routing_floyd_finalize; - routing->size_of_link = size_of_link; - routing->loopback = loopback; + void *link = + xbt_lib_get_or_null(link_lib, link_name, SURF_LINK_LEVEL); + if (link) { + if (order) + xbt_dynar_push(links_id, &link); + else + xbt_dynar_unshift(links_id, &link); + } else + THROWF(mismatch_error, 0, "Link %s not found", link_name); + } - /* Set it in position */ - used_routing = (routing_t) routing; - - /* Setup the parsing callbacks we need */ - surfxml_add_callback(STag_surfxml_host_cb_list, &routing_full_parse_Shost); - surfxml_add_callback(ETag_surfxml_platform_cb_list, &routing_floyd_parse_end); - surfxml_add_callback(STag_surfxml_route_cb_list, - &routing_full_parse_Sroute_set_endpoints); - surfxml_add_callback(ETag_surfxml_route_cb_list, &routing_full_parse_Eroute); - surfxml_add_callback(STag_surfxml_cluster_cb_list, &routing_shortest_path_parse_Scluster); - + return new_e_route; } -/* ************************************************************************** */ -/* ********** Dijkstra & Dijkstra Cached ROUTING **************************** */ -typedef struct { - s_routing_t generic_routing; - xbt_graph_t route_graph; - xbt_dict_t graph_node_map; - xbt_dict_t route_cache; - xbt_dynar_t last_route; - int cached; - void *loopback; - size_t size_of_link; -} s_routing_dijkstra_t,*routing_dijkstra_t; - - -typedef struct graph_node_data { - int id; - int graph_id; //used for caching internal graph id's -} s_graph_node_data_t, * graph_node_data_t; - -typedef struct graph_node_map_element { - xbt_node_t node; -} s_graph_node_map_element_t, * graph_node_map_element_t; - -typedef struct route_cache_element { - int * pred_arr; - int size; -} s_route_cache_element_t, * route_cache_element_t; - -/* - * Free functions - */ -static void route_cache_elem_free(void *e) { - route_cache_element_t elm=(route_cache_element_t)e; +void generic_free_route(route_t route) +{ + if (route) { + xbt_dynar_free(&(route->link_list)); + xbt_free(route); + } +} - if (elm) { - free(elm->pred_arr); - free(elm); +void generic_free_extended_route(route_extended_t e_route) +{ + if (e_route) { + xbt_dynar_free(&(e_route->generic_route.link_list)); + if (e_route->src_gateway) + xbt_free(e_route->src_gateway); + if (e_route->dst_gateway) + xbt_free(e_route->dst_gateway); + xbt_free(e_route); } } -static void graph_node_map_elem_free(void *e) { - graph_node_map_element_t elm = (graph_node_map_element_t)e; +static routing_component_t generic_as_exist(routing_component_t find_from, + routing_component_t to_find) +{ + //return to_find; // FIXME: BYPASSERROR OF FOREACH WITH BREAK + xbt_dict_cursor_t cursor = NULL; + char *key; + int found = 0; + routing_component_t elem; + xbt_dict_foreach(find_from->routing_sons, cursor, key, elem) { + if (to_find == elem || generic_as_exist(elem, to_find)) { + found = 1; + break; + } + } + if (found) + return to_find; + return NULL; +} - if(elm) { - free(elm); +routing_component_t +generic_autonomous_system_exist(routing_component_t rc, char *element) +{ + //return rc; // FIXME: BYPASSERROR OF FOREACH WITH BREAK + routing_component_t element_as, result, elem; + xbt_dict_cursor_t cursor = NULL; + char *key; + element_as = ((network_element_info_t) + xbt_lib_get_or_null(as_router_lib, element, ROUTING_ASR_LEVEL))->rc_component; + result = ((routing_component_t) - 1); + if (element_as != rc) + result = generic_as_exist(rc, element_as); + + int found = 0; + if (result) { + xbt_dict_foreach(element_as->routing_sons, cursor, key, elem) { + found = !strcmp(elem->name, element); + if (found) + break; + } + if (found) + return element_as; } + return NULL; } -/* - * Utility functions -*/ -static xbt_node_t route_graph_new_node(int id, int graph_id) { - xbt_node_t node = NULL; - graph_node_data_t data = NULL; - graph_node_map_element_t elm = NULL; - routing_dijkstra_t routing = (routing_dijkstra_t) used_routing; +routing_component_t +generic_processing_units_exist(routing_component_t rc, char *element) +{ + routing_component_t element_as; + element_as = ((network_element_info_t) + xbt_lib_get_or_null(host_lib, + element, ROUTING_HOST_LEVEL))->rc_component; + if (element_as == rc) + return element_as; + return generic_as_exist(rc, element_as); +} - data = xbt_new0(struct graph_node_data, sizeof(struct graph_node_data)); - data->id = id; - data->graph_id = graph_id; - node = xbt_graph_new_node(routing->route_graph, data); +void generic_src_dst_check(routing_component_t rc, const char *src, + const char *dst) +{ - elm = xbt_new0(struct graph_node_map_element, sizeof(struct graph_node_map_element)); - elm->node = node; - xbt_dict_set_ext(routing->graph_node_map, (char*)(&id), sizeof(int), (xbt_set_elm_t)elm, &graph_node_map_elem_free); + void * src_data = xbt_lib_get_or_null(host_lib,src, ROUTING_HOST_LEVEL); + void * dst_data = xbt_lib_get_or_null(host_lib,dst, ROUTING_HOST_LEVEL); + if(!src_data) src_data = xbt_lib_get_or_null(as_router_lib,src, ROUTING_ASR_LEVEL); + if(!dst_data) dst_data = xbt_lib_get_or_null(as_router_lib,dst, ROUTING_ASR_LEVEL); - return node; -} + if(src_data == NULL || dst_data == NULL) + xbt_die("Ask for route \"from\"(%s) or \"to\"(%s) no found at AS \"%s\"", + src, dst, rc->name); -static graph_node_map_element_t graph_node_map_search(int id) { - routing_dijkstra_t routing = (routing_dijkstra_t) used_routing; + routing_component_t src_as = ((network_element_info_t)src_data)->rc_component; + routing_component_t dst_as = ((network_element_info_t)dst_data)->rc_component; - graph_node_map_element_t elm = (graph_node_map_element_t)xbt_dict_get_or_null_ext(routing->graph_node_map, (char*)(&id), sizeof(int)); + if(src_as != dst_as) + xbt_die("The src(%s in %s) and dst(%s in %s) are in differents AS", + src, src_as->name, dst, dst_as->name); + if(rc != dst_as) + xbt_die("The routing component of src'%s' and dst'%s' is not the same as the network elements belong (%s?=%s?=%s)", + src,dst,src_as->name, dst_as->name,rc->name); +} - return elm; +static void routing_parse_Sconfig(void) +{ + XBT_DEBUG("START configuration name = %s",A_surfxml_config_id); } -/* - * Parsing - */ -static void route_new_dijkstra(int src_id, int dst_id, void* link) { - routing_dijkstra_t routing = (routing_dijkstra_t) used_routing; +static void routing_parse_Econfig(void) +{ + xbt_dict_cursor_t cursor = NULL; + char *key; + char *elem; + char *cfg; + xbt_dict_foreach(current_property_set, cursor, key, elem) { + cfg = bprintf("%s:%s",key,elem); + if(xbt_cfg_is_default_value(_surf_cfg_set, key)) + xbt_cfg_set_parse(_surf_cfg_set, cfg); + else + XBT_INFO("The custom configuration '%s' is already define by user!",key); + free(cfg); + } + XBT_DEBUG("End configuration name = %s",A_surfxml_config_id); +} - xbt_node_t src = NULL; - xbt_node_t dst = NULL; - graph_node_map_element_t src_elm = (graph_node_map_element_t)xbt_dict_get_or_null_ext(routing->graph_node_map, (char*)(&src_id), sizeof(int)); - graph_node_map_element_t dst_elm = (graph_node_map_element_t)xbt_dict_get_or_null_ext(routing->graph_node_map, (char*)(&dst_id), sizeof(int)); +void routing_parse_Scluster(void) +{ + static int AX_ptr = 0; - if(src_elm) - src = src_elm->node; + char *cluster_id = A_surfxml_cluster_id; + char *cluster_prefix = A_surfxml_cluster_prefix; + char *cluster_suffix = A_surfxml_cluster_suffix; + char *cluster_radical = A_surfxml_cluster_radical; + char *cluster_power = A_surfxml_cluster_power; + char *cluster_core = A_surfxml_cluster_core; + char *cluster_bw = A_surfxml_cluster_bw; + char *cluster_lat = A_surfxml_cluster_lat; + char *temp_cluster_bw = NULL; + char *temp_cluster_lat = NULL; + char *temp_cluster_power = NULL; + char *cluster_bb_bw = A_surfxml_cluster_bb_bw; + char *cluster_bb_lat = A_surfxml_cluster_bb_lat; + char *cluster_availability_file = A_surfxml_cluster_availability_file; + char *cluster_state_file = A_surfxml_cluster_state_file; + char *host_id, *groups, *link_id = NULL; + char *router_id, *link_backbone; + char *availability_file = xbt_strdup(cluster_availability_file); + char *state_file = xbt_strdup(cluster_state_file); + + if(xbt_dict_size(patterns)==0) + patterns = xbt_dict_new(); + + xbt_dict_set(patterns,"id",cluster_id,NULL); + xbt_dict_set(patterns,"prefix",cluster_prefix,NULL); + xbt_dict_set(patterns,"suffix",cluster_suffix,NULL); + +#ifdef HAVE_PCRE_LIB + char *route_src_dst; +#endif + unsigned int iter; + int start, end, i; + xbt_dynar_t radical_elements; + xbt_dynar_t radical_ends; + int cluster_sharing_policy = AX_surfxml_cluster_sharing_policy; + int cluster_bb_sharing_policy = AX_surfxml_cluster_bb_sharing_policy; + +#ifndef HAVE_PCRE_LIB + xbt_dynar_t tab_elements_num = xbt_dynar_new(sizeof(int), NULL); + char *route_src, *route_dst; + int j; +#endif - if(dst_elm) - dst = dst_elm->node; + static unsigned int surfxml_buffer_stack_stack_ptr = 1; + static unsigned int surfxml_buffer_stack_stack[1024]; - //add nodes if they don't exist in the graph - if(src_id == dst_id && src == NULL && dst == NULL) { - src = route_graph_new_node(src_id, -1); - dst = src; - } else { - if(src == NULL) { - src = route_graph_new_node(src_id, -1); - } - - if(dst == NULL) { - dst = route_graph_new_node(dst_id, -1); + surfxml_buffer_stack_stack[0] = 0; + + surfxml_bufferstack_push(1); + + SURFXML_BUFFER_SET(AS_id, cluster_id); +#ifdef HAVE_PCRE_LIB + SURFXML_BUFFER_SET(AS_routing, "RuleBased"); + XBT_DEBUG("", cluster_id); +#else + SURFXML_BUFFER_SET(AS_routing, "Full"); + XBT_DEBUG("", cluster_id); +#endif + SURFXML_START_TAG(AS); + + radical_elements = xbt_str_split(cluster_radical, ","); + xbt_dynar_foreach(radical_elements, iter, groups) { + radical_ends = xbt_str_split(groups, "-"); + switch (xbt_dynar_length(radical_ends)) { + case 1: + surf_parse_get_int(&start, + xbt_dynar_get_as(radical_ends, 0, char *)); + host_id = bprintf("%s%d%s", cluster_prefix, start, cluster_suffix); +#ifndef HAVE_PCRE_LIB + xbt_dynar_push_as(tab_elements_num, int, start); +#endif + link_id = bprintf("%s_link_%d", cluster_id, start); + + xbt_dict_set(patterns, "radical", bprintf("%d", start), xbt_free); + temp_cluster_power = xbt_strdup(cluster_power); + temp_cluster_power = replace_random_parameter(temp_cluster_power); + XBT_DEBUG("", host_id, temp_cluster_power); + A_surfxml_host_state = A_surfxml_host_state_ON; + SURFXML_BUFFER_SET(host_id, host_id); + SURFXML_BUFFER_SET(host_power, temp_cluster_power); + SURFXML_BUFFER_SET(host_core, cluster_core); + SURFXML_BUFFER_SET(host_availability, "1.0"); + SURFXML_BUFFER_SET(host_coordinates, ""); + xbt_free(availability_file); + availability_file = xbt_strdup(cluster_availability_file); + xbt_free(state_file); + state_file = xbt_strdup(cluster_state_file); + XBT_DEBUG("\tavailability_file=\"%s\"",xbt_str_varsubst(availability_file,patterns)); + XBT_DEBUG("\tstate_file=\"%s\"",xbt_str_varsubst(state_file,patterns)); + SURFXML_BUFFER_SET(host_availability_file, xbt_str_varsubst(availability_file,patterns)); + SURFXML_BUFFER_SET(host_state_file, xbt_str_varsubst(state_file,patterns)); + XBT_DEBUG(""); + SURFXML_START_TAG(host); + SURFXML_END_TAG(host); + + + temp_cluster_bw = xbt_strdup(cluster_bw); + temp_cluster_bw = replace_random_parameter(temp_cluster_bw); + temp_cluster_lat = xbt_strdup(cluster_lat); + temp_cluster_lat = replace_random_parameter(temp_cluster_lat); + XBT_DEBUG("", link_id,temp_cluster_bw, cluster_lat); + A_surfxml_link_state = A_surfxml_link_state_ON; + A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED; + if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX) + {A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_FULLDUPLEX;} + if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FATPIPE) + {A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_FATPIPE;} + SURFXML_BUFFER_SET(link_id, link_id); + SURFXML_BUFFER_SET(link_bandwidth, temp_cluster_bw); + SURFXML_BUFFER_SET(link_latency, temp_cluster_lat); + SURFXML_BUFFER_SET(link_bandwidth_file, ""); + SURFXML_BUFFER_SET(link_latency_file, ""); + SURFXML_BUFFER_SET(link_state_file, ""); + SURFXML_START_TAG(link); + SURFXML_END_TAG(link); + + xbt_free(temp_cluster_bw); + xbt_free(temp_cluster_lat); + xbt_free(temp_cluster_power); + free(link_id); + free(host_id); + break; + + case 2: + + surf_parse_get_int(&start, + xbt_dynar_get_as(radical_ends, 0, char *)); + surf_parse_get_int(&end, xbt_dynar_get_as(radical_ends, 1, char *)); + for (i = start; i <= end; i++) { + host_id = bprintf("%s%d%s", cluster_prefix, i, cluster_suffix); +#ifndef HAVE_PCRE_LIB + xbt_dynar_push_as(tab_elements_num, int, i); +#endif + link_id = bprintf("%s_link_%d", cluster_id, i); + + xbt_dict_set(patterns, "radical", bprintf("%d", i), xbt_free); + temp_cluster_power = xbt_strdup(cluster_power); + temp_cluster_power = replace_random_parameter(temp_cluster_power); + XBT_DEBUG("", host_id, temp_cluster_power); + A_surfxml_host_state = A_surfxml_host_state_ON; + SURFXML_BUFFER_SET(host_id, host_id); + SURFXML_BUFFER_SET(host_power, temp_cluster_power); + SURFXML_BUFFER_SET(host_core, cluster_core); + SURFXML_BUFFER_SET(host_availability, "1.0"); + SURFXML_BUFFER_SET(host_coordinates, ""); + xbt_free(availability_file); + availability_file = xbt_strdup(cluster_availability_file); + xbt_free(state_file); + state_file = xbt_strdup(cluster_state_file); + XBT_DEBUG("\tavailability_file=\"%s\"",xbt_str_varsubst(availability_file,patterns)); + XBT_DEBUG("\tstate_file=\"%s\"",xbt_str_varsubst(state_file,patterns)); + SURFXML_BUFFER_SET(host_availability_file, xbt_str_varsubst(availability_file,patterns)); + SURFXML_BUFFER_SET(host_state_file, xbt_str_varsubst(state_file,patterns)); + XBT_DEBUG(""); + SURFXML_START_TAG(host); + SURFXML_END_TAG(host); + + xbt_free(temp_cluster_power); + + temp_cluster_bw = xbt_strdup(cluster_bw); + temp_cluster_bw = replace_random_parameter(temp_cluster_bw); + temp_cluster_lat = xbt_strdup(cluster_lat); + temp_cluster_lat = replace_random_parameter(temp_cluster_lat); + XBT_DEBUG("", link_id,temp_cluster_bw, cluster_lat); + A_surfxml_link_state = A_surfxml_link_state_ON; + A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED; + if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX) + {A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_FULLDUPLEX;} + if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FATPIPE) + {A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_FATPIPE;} + SURFXML_BUFFER_SET(link_id, link_id); + SURFXML_BUFFER_SET(link_bandwidth, temp_cluster_bw); + SURFXML_BUFFER_SET(link_latency, temp_cluster_lat); + SURFXML_BUFFER_SET(link_bandwidth_file, ""); + SURFXML_BUFFER_SET(link_latency_file, ""); + SURFXML_BUFFER_SET(link_state_file, ""); + SURFXML_START_TAG(link); + SURFXML_END_TAG(link); + + xbt_free(temp_cluster_bw); + xbt_free(temp_cluster_lat); + free(link_id); + free(host_id); + } + break; + + default: + XBT_DEBUG("Malformed radical"); } + + xbt_dynar_free(&radical_ends); } + xbt_dynar_free(&radical_elements); + + XBT_DEBUG(" "); + router_id = + bprintf("%s%s_router%s", cluster_prefix, cluster_id, + cluster_suffix); + //link_router = bprintf("%s_link_%s_router", cluster_id, cluster_id); + link_backbone = bprintf("%s_backbone", cluster_id); + + XBT_DEBUG("", router_id); + SURFXML_BUFFER_SET(router_id, router_id); + SURFXML_BUFFER_SET(router_coordinates, ""); + SURFXML_START_TAG(router); + SURFXML_END_TAG(router); + + //TODO +// xbt_dict_set(patterns, "radical", xbt_strdup("_router"), xbt_free); +// temp_cluster_bw = xbt_strdup(cluster_bw); +// temp_cluster_bw = replace_random_parameter(temp_cluster_bw); +// temp_cluster_lat = xbt_strdup(cluster_lat); +// temp_cluster_lat = replace_random_parameter(temp_cluster_lat); +// XBT_DEBUG("", link_router,temp_cluster_bw, temp_cluster_lat); +// A_surfxml_link_state = A_surfxml_link_state_ON; +// A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED; +// if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX) +// {A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_FULLDUPLEX;} +// if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FATPIPE) +// {A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_FATPIPE;} +// SURFXML_BUFFER_SET(link_id, link_router); +// SURFXML_BUFFER_SET(link_bandwidth, temp_cluster_bw); +// SURFXML_BUFFER_SET(link_latency, temp_cluster_lat); +// SURFXML_BUFFER_SET(link_bandwidth_file, ""); +// SURFXML_BUFFER_SET(link_latency_file, ""); +// SURFXML_BUFFER_SET(link_state_file, ""); +// SURFXML_START_TAG(link); +// SURFXML_END_TAG(link); + +// xbt_free(temp_cluster_bw); +// xbt_free(temp_cluster_lat); + + XBT_DEBUG("", link_backbone,cluster_bb_bw, cluster_bb_lat); + A_surfxml_link_state = A_surfxml_link_state_ON; + A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED; + if(cluster_bb_sharing_policy == A_surfxml_cluster_bb_sharing_policy_FATPIPE) + {A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_FATPIPE;} + SURFXML_BUFFER_SET(link_id, link_backbone); + SURFXML_BUFFER_SET(link_bandwidth, cluster_bb_bw); + SURFXML_BUFFER_SET(link_latency, cluster_bb_lat); + SURFXML_BUFFER_SET(link_bandwidth_file, ""); + SURFXML_BUFFER_SET(link_latency_file, ""); + SURFXML_BUFFER_SET(link_state_file, ""); + SURFXML_START_TAG(link); + SURFXML_END_TAG(link); - //add link as edge to graph - xbt_graph_new_edge(routing->route_graph, src, dst, link); - -} - -static void add_loopback_dijkstra(void) { - routing_dijkstra_t routing = (routing_dijkstra_t) used_routing; - - xbt_dynar_t nodes = xbt_graph_get_nodes(routing->route_graph); - - xbt_node_t node = NULL; - unsigned int cursor2; - xbt_dynar_foreach(nodes, cursor2, node) { - xbt_dynar_t out_edges = xbt_graph_node_get_outedges(node); - xbt_edge_t edge = NULL; - unsigned int cursor; - - int found = 0; - xbt_dynar_foreach(out_edges, cursor, edge) { - xbt_node_t other_node = xbt_graph_edge_get_target(edge); - if(other_node == node) { - found = 1; - break; - } - } + XBT_DEBUG(" "); - if(!found) - xbt_graph_new_edge(routing->route_graph, node, node, &routing->loopback); - } -} +#ifdef HAVE_PCRE_LIB + char *new_suffix = xbt_strdup(""); -static void routing_dijkstra_parse_end(void) { - routing_dijkstra_t routing = (routing_dijkstra_t) used_routing; - int nb_link = 0; - xbt_dict_cursor_t cursor = NULL; - char *key, *data, *end; - const char *sep = "#"; - xbt_dynar_t links, keys; - char* link_name = NULL; - void* link = NULL; - xbt_node_t node = NULL; - unsigned int cursor2; - xbt_dynar_t nodes = NULL; - /* Create the topology graph */ - routing->route_graph = xbt_graph_new_graph(1, NULL); - routing->graph_node_map = xbt_dict_new(); - routing->last_route = xbt_dynar_new(routing->size_of_link, NULL); - if(routing->cached) - routing->route_cache = xbt_dict_new(); - - - /* Put the routes in position */ - xbt_dict_foreach(route_table, cursor, key, data) { - nb_link = 0; - links = (xbt_dynar_t) data; - keys = xbt_str_split_str(key, sep); - - src_id = strtol(xbt_dynar_get_as(keys, 0, char *), &end, 16); - dst_id = strtol(xbt_dynar_get_as(keys, 1, char *), &end, 16); - xbt_dynar_free(&keys); - - DEBUG4("Handle %d %d (from %d hosts): %ld links", - src_id,dst_id,routing->generic_routing.host_count,xbt_dynar_length(links)); - - xbt_assert3(xbt_dynar_length(links) == 1, "%ld links in route between host %d and %d, should be 1", xbt_dynar_length(links), src_id, dst_id); - - link_name = xbt_dynar_getfirst_as(links, char*); - link = xbt_dict_get_or_null(surf_network_model->resource_set, link_name); - if (link) - route_new_dijkstra(src_id,dst_id,link); - else - THROW1(mismatch_error,0,"Link %s not found", link_name); - + radical_elements = xbt_str_split(cluster_suffix, "."); + xbt_dynar_foreach(radical_elements, iter, groups) { + if (strcmp(groups, "")) { + char *old_suffix = new_suffix; + new_suffix = bprintf("%s\\.%s", old_suffix, groups); + free(old_suffix); + } } + route_src_dst = bprintf("%s(.*)%s", cluster_prefix, new_suffix); + xbt_dynar_free(&radical_elements); + free(new_suffix); + + char *pcre_link_src = bprintf("%s_link_$1src", cluster_id); + char *pcre_link_backbone = bprintf("%s_backbone", cluster_id); + char *pcre_link_dst = bprintf("%s_link_$1dst", cluster_id); + + //from router to router + XBT_DEBUG(""); + SURFXML_BUFFER_SET(route_src, router_id); + SURFXML_BUFFER_SET(route_dst, router_id); + A_surfxml_route_symmetrical = A_surfxml_route_symmetrical_NO; + SURFXML_START_TAG(route); + + XBT_DEBUG("", pcre_link_backbone); + SURFXML_BUFFER_SET(link_ctn_id, pcre_link_backbone); + A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE; + SURFXML_START_TAG(link_ctn); + SURFXML_END_TAG(link_ctn); + + XBT_DEBUG(""); + SURFXML_END_TAG(route); + + //from host to router + XBT_DEBUG(""); + SURFXML_BUFFER_SET(route_src, route_src_dst); + SURFXML_BUFFER_SET(route_dst, router_id); + A_surfxml_route_symmetrical = A_surfxml_route_symmetrical_NO; + SURFXML_START_TAG(route); + + XBT_DEBUG("", pcre_link_src); + SURFXML_BUFFER_SET(link_ctn_id, pcre_link_src); + A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE; + if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX) + {A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_UP;} + SURFXML_START_TAG(link_ctn); + SURFXML_END_TAG(link_ctn); + + XBT_DEBUG("", pcre_link_backbone); + SURFXML_BUFFER_SET(link_ctn_id, pcre_link_backbone); + A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE; + SURFXML_START_TAG(link_ctn); + SURFXML_END_TAG(link_ctn); + + XBT_DEBUG(""); + SURFXML_END_TAG(route); + + //from router to host + XBT_DEBUG(""); + SURFXML_BUFFER_SET(route_src, router_id); + SURFXML_BUFFER_SET(route_dst, route_src_dst); + A_surfxml_route_symmetrical = A_surfxml_route_symmetrical_NO; + SURFXML_START_TAG(route); + + XBT_DEBUG("", pcre_link_backbone); + SURFXML_BUFFER_SET(link_ctn_id, pcre_link_backbone); + A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE; + SURFXML_START_TAG(link_ctn); + SURFXML_END_TAG(link_ctn); + + XBT_DEBUG("", pcre_link_dst); + SURFXML_BUFFER_SET(link_ctn_id, pcre_link_dst); + A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE; + if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX) + {A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_UP;} + SURFXML_START_TAG(link_ctn); + SURFXML_END_TAG(link_ctn); + + XBT_DEBUG(""); + SURFXML_END_TAG(route); + + //from host to host + XBT_DEBUG(""); + SURFXML_BUFFER_SET(route_src, route_src_dst); + SURFXML_BUFFER_SET(route_dst, route_src_dst); + A_surfxml_route_symmetrical = A_surfxml_route_symmetrical_NO; + SURFXML_START_TAG(route); + + XBT_DEBUG("", pcre_link_src); + SURFXML_BUFFER_SET(link_ctn_id, pcre_link_src); + A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE; + if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX) + {A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_UP;} + SURFXML_START_TAG(link_ctn); + SURFXML_END_TAG(link_ctn); + + XBT_DEBUG("", pcre_link_backbone); + SURFXML_BUFFER_SET(link_ctn_id, pcre_link_backbone); + A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE; + SURFXML_START_TAG(link_ctn); + SURFXML_END_TAG(link_ctn); + + XBT_DEBUG("", pcre_link_dst); + SURFXML_BUFFER_SET(link_ctn_id, pcre_link_dst); + A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE; + if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX) + {A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_DOWN;} + SURFXML_START_TAG(link_ctn); + SURFXML_END_TAG(link_ctn); + + XBT_DEBUG(""); + SURFXML_END_TAG(route); + + free(pcre_link_dst); + free(pcre_link_backbone); + free(pcre_link_src); + free(route_src_dst); +#else + for (i = 0; i <= xbt_dynar_length(tab_elements_num); i++) { + for (j = 0; j <= xbt_dynar_length(tab_elements_num); j++) { + if (i == xbt_dynar_length(tab_elements_num)) { + route_src = router_id; + } else { + route_src = + bprintf("%s%d%s", cluster_prefix, + xbt_dynar_get_as(tab_elements_num, i, int), + cluster_suffix); + } - /* Add the loopback if needed */ - add_loopback_dijkstra(); + if (j == xbt_dynar_length(tab_elements_num)) { + route_dst = router_id; + } else { + route_dst = + bprintf("%s%d%s", cluster_prefix, + xbt_dynar_get_as(tab_elements_num, j, int), + cluster_suffix); + } - /* initialize graph indexes in nodes after graph has been built */ - nodes = xbt_graph_get_nodes(routing->route_graph); + XBT_DEBUG(""); + SURFXML_BUFFER_SET(route_src, route_src); + SURFXML_BUFFER_SET(route_dst, route_dst); + A_surfxml_route_symmetrical = A_surfxml_route_symmetrical_NO; + SURFXML_START_TAG(route); + + if (i != xbt_dynar_length(tab_elements_num)){ + route_src = + bprintf("%s_link_%d", cluster_id, + xbt_dynar_get_as(tab_elements_num, i, int)); + XBT_DEBUG("", route_src); + SURFXML_BUFFER_SET(link_ctn_id, route_src); + A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE; + if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX) + {A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_UP;} + SURFXML_START_TAG(link_ctn); + SURFXML_END_TAG(link_ctn); + free(route_src); + } - xbt_dynar_foreach(nodes, cursor2, node) { - graph_node_data_t data = xbt_graph_node_get_data(node); - data->graph_id = cursor2; + XBT_DEBUG("", cluster_id); + SURFXML_BUFFER_SET(link_ctn_id, bprintf("%s_backbone", cluster_id)); + A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE; + SURFXML_START_TAG(link_ctn); + SURFXML_END_TAG(link_ctn); + + if (j != xbt_dynar_length(tab_elements_num)) { + route_dst = + bprintf("%s_link_%d", cluster_id, + xbt_dynar_get_as(tab_elements_num, j, int)); + XBT_DEBUG("", route_dst); + SURFXML_BUFFER_SET(link_ctn_id, route_dst); + A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE; + if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX) + {A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_DOWN;} + SURFXML_START_TAG(link_ctn); + SURFXML_END_TAG(link_ctn); + free(route_dst); + } + + XBT_DEBUG(""); + SURFXML_END_TAG(route); + } } + xbt_dynar_free(&tab_elements_num); -} +#endif + + free(router_id); + free(link_backbone); + //free(link_router); + xbt_dict_free(&patterns); + free(availability_file); + free(state_file); + XBT_DEBUG(""); + SURFXML_END_TAG(AS); + XBT_DEBUG(" "); + + surfxml_bufferstack_pop(1); +} /* - * Business methods + * This function take a string and replace parameters from patterns dict. + * It returns the new value. */ -static xbt_dynar_t routing_dijkstra_get_route(int src_id,int dst_id) { - - routing_dijkstra_t routing = (routing_dijkstra_t) used_routing; - int * pred_arr = NULL; - int src_node_id = 0; - int dst_node_id = 0; - int * nodeid = NULL; - int v; - int size = 0; - void * link = NULL; - route_cache_element_t elm = NULL; - xbt_dynar_t nodes = xbt_graph_get_nodes(routing->route_graph); - - /*Use the graph_node id mapping set to quickly find the nodes */ - graph_node_map_element_t src_elm = graph_node_map_search(src_id); - graph_node_map_element_t dst_elm = graph_node_map_search(dst_id); - xbt_assert2(src_elm != NULL && dst_elm != NULL, "src %d or dst %d does not exist", src_id, dst_id); - src_node_id = ((graph_node_data_t)xbt_graph_node_get_data(src_elm->node))->graph_id; - dst_node_id = ((graph_node_data_t)xbt_graph_node_get_data(dst_elm->node))->graph_id; - - if(routing->cached) { - /*check if there is a cached predecessor list avail */ - elm = (route_cache_element_t)xbt_dict_get_or_null_ext(routing->route_cache, (char*)(&src_id), sizeof(int)); - } - - if(elm) { //cached mode and cache hit - pred_arr = elm->pred_arr; - } else { //not cached mode or cache miss - double * cost_arr = NULL; - xbt_heap_t pqueue = NULL; - int i = 0; +static char* replace_random_parameter(char * string) +{ + char *test_string = NULL; + + if(xbt_dict_size(random_value)==0) + return string; + + string = xbt_str_varsubst(string, patterns); // for patterns of cluster + test_string = bprintf("${%s}", string); + test_string = xbt_str_varsubst(test_string,random_value); //Add ${xxxxx} for random Generator + + if (strcmp(test_string,"")) { //if not empty, keep this value. + xbt_free(string); + string = test_string; + } //In other case take old value (without ${}) + else + free(test_string); + return string; +} - int nr_nodes = xbt_dynar_length(nodes); - cost_arr = xbt_new0(double, nr_nodes); //link cost from src to other hosts - pred_arr = xbt_new0(int, nr_nodes); //predecessors in path from src - pqueue = xbt_heap_new(nr_nodes, free); +static void clean_dict_random(void) +{ + xbt_dict_free(&random_value); + xbt_dict_free(&patterns); +} - //initialize - cost_arr[src_node_id] = 0.0; +static void routing_parse_Speer(void) +{ + static int AX_ptr = 0; - for(i = 0; i < nr_nodes; i++) { - if(i != src_node_id) { - cost_arr[i] = DBL_MAX; - } + char *peer_id = A_surfxml_peer_id; + char *peer_power = A_surfxml_peer_power; + char *peer_bw_in = A_surfxml_peer_bw_in; + char *peer_bw_out = A_surfxml_peer_bw_out; + char *peer_lat = A_surfxml_peer_lat; + char *peer_coord = A_surfxml_peer_coordinates; + char *peer_state_file = A_surfxml_peer_state_file; + char *peer_availability_file = A_surfxml_peer_availability_file; - pred_arr[i] = 0; + char *host_id = NULL; + char *router_id, *link_router, *link_backbone, *link_id_up, *link_id_down; - //initialize priority queue - nodeid = xbt_new0(int, 1); - *nodeid = i; - xbt_heap_push(pqueue, nodeid, cost_arr[i]); + static unsigned int surfxml_buffer_stack_stack_ptr = 1; + static unsigned int surfxml_buffer_stack_stack[1024]; - } + surfxml_buffer_stack_stack[0] = 0; - // apply dijkstra using the indexes from the graph's node array - while(xbt_heap_size(pqueue) > 0) { - int * v_id = xbt_heap_pop(pqueue); - xbt_node_t v_node = xbt_dynar_get_as(nodes, *v_id, xbt_node_t); - xbt_dynar_t out_edges = xbt_graph_node_get_outedges(v_node); - xbt_edge_t edge = NULL; - unsigned int cursor; - - xbt_dynar_foreach(out_edges, cursor, edge) { - xbt_node_t u_node = xbt_graph_edge_get_target(edge); - graph_node_data_t data = xbt_graph_node_get_data(u_node); - int u_id = data->graph_id; - int cost_v_u = 1; //fixed link cost for now - - if(cost_v_u + cost_arr[*v_id] < cost_arr[u_id]) { - pred_arr[u_id] = *v_id; - cost_arr[u_id] = cost_v_u + cost_arr[*v_id]; - nodeid = xbt_new0(int, 1); - *nodeid = u_id; - xbt_heap_push(pqueue, nodeid, cost_arr[u_id]); - } - } - - //free item popped from pqueue - free(v_id); - } + surfxml_bufferstack_push(1); - free(cost_arr); - xbt_heap_free(pqueue); + SURFXML_BUFFER_SET(AS_id, peer_id); - } + SURFXML_BUFFER_SET(AS_routing, "Full"); + XBT_DEBUG("", peer_id); - //compose route path with links - xbt_dynar_reset(routing->last_route); + SURFXML_START_TAG(AS); - for(v = dst_node_id; v != src_node_id; v = pred_arr[v]) { - xbt_node_t node_pred_v = xbt_dynar_get_as(nodes, pred_arr[v], xbt_node_t); - xbt_node_t node_v = xbt_dynar_get_as(nodes, v, xbt_node_t); - xbt_edge_t edge = xbt_graph_get_edge(routing->route_graph, node_pred_v, node_v); + XBT_DEBUG(" "); + host_id = bprintf("peer_%s", peer_id); + router_id = bprintf("router_%s", peer_id); + link_id_up = bprintf("link_%s_up", peer_id); + link_id_down = bprintf("link_%s_down", peer_id); - xbt_assert2(edge != NULL, "no route between host %d and %d", src_id, dst_id); + link_router = bprintf("%s_link_router", peer_id); + link_backbone = bprintf("%s_backbone", peer_id); - link = xbt_graph_edge_get_data(edge); - xbt_dynar_unshift(routing->last_route, &link); - size++; - } + XBT_DEBUG("", host_id, peer_power); + A_surfxml_host_state = A_surfxml_host_state_ON; + SURFXML_BUFFER_SET(host_id, host_id); + SURFXML_BUFFER_SET(host_power, peer_power); + SURFXML_BUFFER_SET(host_availability, "1.0"); + SURFXML_BUFFER_SET(host_availability_file, peer_availability_file); + SURFXML_BUFFER_SET(host_state_file, peer_state_file); + SURFXML_BUFFER_SET(host_coordinates, ""); + SURFXML_START_TAG(host); + SURFXML_END_TAG(host); + XBT_DEBUG("", router_id, peer_coord); + SURFXML_BUFFER_SET(router_id, router_id); + SURFXML_BUFFER_SET(router_coordinates, peer_coord); + SURFXML_START_TAG(router); + SURFXML_END_TAG(router); - if(routing->cached && elm == NULL) { - //add to predecessor list of the current src-host to cache - elm = xbt_new0(struct route_cache_element, sizeof(struct route_cache_element)); - elm->pred_arr = pred_arr; - elm->size = size; - xbt_dict_set_ext(routing->route_cache, (char*)(&src_id), sizeof(int), (xbt_set_elm_t)elm, &route_cache_elem_free); - } + XBT_DEBUG("", link_id_up, peer_bw_in, peer_lat); + A_surfxml_link_state = A_surfxml_link_state_ON; + A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED; + SURFXML_BUFFER_SET(link_id, link_id_up); + SURFXML_BUFFER_SET(link_bandwidth, peer_bw_in); + SURFXML_BUFFER_SET(link_latency, peer_lat); + SURFXML_BUFFER_SET(link_bandwidth_file, ""); + SURFXML_BUFFER_SET(link_latency_file, ""); + SURFXML_BUFFER_SET(link_state_file, ""); + SURFXML_START_TAG(link); + SURFXML_END_TAG(link); - if(!routing->cached) - free(pred_arr); + XBT_DEBUG("", link_id_down, peer_bw_out, peer_lat); + A_surfxml_link_state = A_surfxml_link_state_ON; + A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED; + SURFXML_BUFFER_SET(link_id, link_id_down); + SURFXML_BUFFER_SET(link_bandwidth, peer_bw_out); + SURFXML_BUFFER_SET(link_latency, peer_lat); + SURFXML_BUFFER_SET(link_bandwidth_file, ""); + SURFXML_BUFFER_SET(link_latency_file, ""); + SURFXML_BUFFER_SET(link_state_file, ""); + SURFXML_START_TAG(link); + SURFXML_END_TAG(link); - return routing->last_route; + XBT_DEBUG(" "); + + // begin here + XBT_DEBUG(""); + SURFXML_BUFFER_SET(route_src, host_id); + SURFXML_BUFFER_SET(route_dst, router_id); + A_surfxml_route_symmetrical = A_surfxml_route_symmetrical_NO; + SURFXML_START_TAG(route); + + XBT_DEBUG("", link_id_up); + SURFXML_BUFFER_SET(link_ctn_id, link_id_up); + A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE; + SURFXML_START_TAG(link_ctn); + SURFXML_END_TAG(link_ctn); + + XBT_DEBUG(""); + SURFXML_END_TAG(route); + + //Opposite Route + XBT_DEBUG(""); + SURFXML_BUFFER_SET(route_src, router_id); + SURFXML_BUFFER_SET(route_dst, host_id); + A_surfxml_route_symmetrical = A_surfxml_route_symmetrical_NO; + SURFXML_START_TAG(route); + + XBT_DEBUG("", link_id_down); + SURFXML_BUFFER_SET(link_ctn_id, link_id_down); + A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE; + SURFXML_START_TAG(link_ctn); + SURFXML_END_TAG(link_ctn); + + XBT_DEBUG(""); + SURFXML_END_TAG(route); + + XBT_DEBUG(""); + SURFXML_END_TAG(AS); + XBT_DEBUG(" "); + + //xbt_dynar_free(&tab_elements_num); + free(host_id); + free(router_id); + free(link_router); + free(link_backbone); + free(link_id_up); + free(link_id_down); + surfxml_bufferstack_pop(1); } +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; + surf_parse_get_double(&mean,A_surfxml_random_mean); + surf_parse_get_double(&std,A_surfxml_random_std_deviation); + surf_parse_get_double(&min,A_surfxml_random_min); + surf_parse_get_double(&max,A_surfxml_random_max); + surf_parse_get_double(&seed,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; + + random->generator = A_surfxml_random_generator; + 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, + random->generator, + random->seed, + random_radical); + + if(xbt_dict_size(random_value)==0) + random_value = xbt_dict_new(); + + if(!strcmp(random_radical,"")) + { + res = random_generate(random); + rd_value = bprintf("%f",res); + xbt_dict_set(random_value, random_id, rd_value, free); + } + 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), free); + xbt_free(tmpbuf); + break; + + case 2: surf_parse_get_int(&start, + xbt_dynar_get_as(radical_ends, 0, char *)); + surf_parse_get_int(&end, 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), free); + xbt_free(tmpbuf); + } + break; + default: + XBT_INFO("Malformed radical"); + } + 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, free); + + xbt_dynar_free(&radical_ends); + } + free(rd_name); + xbt_dynar_free(&radical_elements); + } +} -static void routing_dijkstra_finalize(void) { - routing_dijkstra_t routing = (routing_dijkstra_t)used_routing; +static void routing_parse_Erandom(void) +{ + xbt_dict_cursor_t cursor = NULL; + char *key; + char *elem; - if (routing) { - xbt_graph_free_graph(routing->route_graph, &free, NULL, &free); - xbt_dict_free(&routing->graph_node_map); - if(routing->cached) - xbt_dict_free(&routing->route_cache); - xbt_dynar_free(&routing->last_route); - xbt_dict_free(&used_routing->host_id); - free(routing); - routing=NULL; - } -} + xbt_dict_foreach(random_value, cursor, key, elem) { + XBT_DEBUG("%s = %s",key,elem); + } -static xbt_dict_t routing_dijkstraboth_get_onelink_routes(void){ - xbt_assert0(0,"The get_onelink_routes feature is not supported in routing model dijkstraboth"); } -static int routing_dijkstraboth_is_router(int id){ - xbt_assert0(0,"The get_is_router feature is not supported in routing model dijkstraboth"); -} /* - * + * New methods to init the routing model component from the lua script */ -static void routing_model_dijkstraboth_create(size_t size_of_link,void *loopback, int cached) { - /* initialize our structure */ - routing_dijkstra_t routing = xbt_new0(s_routing_dijkstra_t,1); - routing->generic_routing.name = "Dijkstra"; - routing->generic_routing.host_count = 0; - routing->generic_routing.get_route = routing_dijkstra_get_route; - routing->generic_routing.get_onelink_routes = routing_dijkstraboth_get_onelink_routes; - routing->generic_routing.is_router = routing_dijkstraboth_is_router; - routing->generic_routing.finalize = routing_dijkstra_finalize; - routing->size_of_link = size_of_link; - routing->loopback = loopback; - routing->cached = cached; - - /* Set it in position */ - used_routing = (routing_t) routing; - - /* Setup the parsing callbacks we need */ - routing->generic_routing.host_id = xbt_dict_new(); - surfxml_add_callback(STag_surfxml_host_cb_list, &routing_full_parse_Shost); - surfxml_add_callback(ETag_surfxml_platform_cb_list, &routing_dijkstra_parse_end); - surfxml_add_callback(STag_surfxml_route_cb_list, - &routing_full_parse_Sroute_set_endpoints); - surfxml_add_callback(ETag_surfxml_route_cb_list, &routing_full_parse_Eroute); - surfxml_add_callback(STag_surfxml_cluster_cb_list, &routing_shortest_path_parse_Scluster); -} -static void routing_model_dijkstra_create(size_t size_of_link,void *loopback) { - routing_model_dijkstraboth_create(size_of_link, loopback, 0); +/* + * calling parse_S_AS_lua with lua values + */ +void routing_AS_init(const char *AS_id, const char *AS_routing) +{ + parse_S_AS_lua((char *) AS_id, (char *) AS_routing); } -static void routing_model_dijkstracache_create(size_t size_of_link,void *loopback) { - routing_model_dijkstraboth_create(size_of_link, loopback, 1); +/* + * calling parse_E_AS_lua to fisnish the creation of routing component + */ +void routing_AS_end(const char *AS_id) +{ + parse_E_AS_lua((char *) AS_id); } -/* ************************************************** */ -/* ********** NO ROUTING **************************** */ - +/* + * add a host to the network element list + */ -static void routing_none_finalize(void) { - if (used_routing) { - xbt_dict_free(&used_routing->host_id); - free(used_routing); - used_routing=NULL; - } +void routing_add_host(const char *host_id) +{ + parse_S_host_lua((char *) host_id, (char*)""); // FIXME propagate coordinate system to lua } -static void routing_model_none_create(size_t size_of_link,void *loopback) { - routing_t routing = xbt_new0(s_routing_t,1); - INFO0("Null routing"); - routing->name = "none"; - routing->host_count = 0; - routing->host_id = xbt_dict_new(); - routing->get_onelink_routes = NULL; - routing->is_router = NULL; - routing->get_route = NULL; +/* + * Set a new link on the actual list of link for a route or ASroute + */ +void routing_add_link(const char *link_id) +{ + parse_E_link_c_ctn_new_elem_lua((char *) link_id); +} - routing->finalize = routing_none_finalize; +/* + *Set the endpoints for a route + */ +void routing_set_route(const char *src_id, const char *dst_id) +{ + parse_S_route_new_and_endpoints_lua(src_id, dst_id); +} - /* Set it in position */ - used_routing = (routing_t) routing; +/* + * Store the route by calling parse_E_route_store_route + */ +void routing_store_route(void) +{ + parse_E_route_store_route(); }