+ /* Create the topology graph */
+ if(!routing->route_graph)
+ routing->route_graph = xbt_graph_new_graph(1, NULL);
+ if(!routing->graph_node_map)
+ routing->graph_node_map = xbt_dict_new();
+
+ if (routing->cached && !routing->route_cache)
+ routing->route_cache = xbt_dict_new();
+
+ /* Add the loopback if needed */
+ if (current_routing->hierarchy == SURF_ROUTING_BASE)
+ add_loopback_dijkstra(routing);
+
+ /* initialize graph indexes in nodes after graph has been built */
+ nodes = xbt_graph_get_nodes(routing->route_graph);
+
+ xbt_dynar_foreach(nodes, cursor2, node) {
+ graph_node_data_t data = xbt_graph_node_get_data(node);
+ data->graph_id = cursor2;
+ }
+
+}
+static void model_dijkstra_both_set_route (routing_component_t rc, const char *src,
+ const char *dst, name_route_extended_t route)
+{
+ routing_component_dijkstra_t routing = (routing_component_dijkstra_t) rc;
+ int *src_id, *dst_id;
+ src_id = xbt_dict_get_or_null(rc->to_index, src);
+ dst_id = xbt_dict_get_or_null(rc->to_index, dst);
+
+ /* Create the topology graph */
+ if(!routing->route_graph)
+ routing->route_graph = xbt_graph_new_graph(1, NULL);
+ if(!routing->graph_node_map)
+ routing->graph_node_map = xbt_dict_new();
+
+ if (routing->cached && !routing->route_cache)
+ routing->route_cache = xbt_dict_new();
+
+ if( A_surfxml_route_symmetrical == A_surfxml_route_symmetrical_YES
+ || A_surfxml_ASroute_symmetrical == A_surfxml_ASroute_symmetrical_YES )
+ xbt_die("Route symmetrical not supported on model dijkstra");
+
+ if(!route->dst_gateway && !route->src_gateway)
+ DEBUG2("Load Route from \"%s\" to \"%s\"", src, dst);
+ else
+ DEBUG4("Load ASroute from \"%s(%s)\" to \"%s(%s)\"", src,
+ route->src_gateway, dst, route->dst_gateway);
+
+ route_extended_t e_route =
+ generic_new_extended_route(current_routing->hierarchy, route, 1);
+ route_new_dijkstra(routing, *src_id, *dst_id, e_route);
+}
+
+#ifdef HAVE_PCRE_LIB
+/* ************************************************** */
+/* ************** RULE-BASED ROUTING **************** */
+
+/* Routing model structure */
+
+typedef struct {
+ s_routing_component_t generic_routing;
+ xbt_dict_t dict_processing_units;
+ xbt_dict_t dict_autonomous_systems;
+ xbt_dynar_t list_route;
+ xbt_dynar_t list_ASroute;
+} s_routing_component_rulebased_t, *routing_component_rulebased_t;
+
+typedef struct s_rule_route s_rule_route_t, *rule_route_t;
+typedef struct s_rule_route_extended s_rule_route_extended_t,
+ *rule_route_extended_t;
+
+struct s_rule_route {
+ xbt_dynar_t re_str_link; // dynar of char*
+ pcre *re_src;
+ pcre *re_dst;
+};
+
+struct s_rule_route_extended {
+ s_rule_route_t generic_rule_route;
+ char *re_src_gateway;
+ char *re_dst_gateway;
+};
+
+static void rule_route_free(void *e)
+{
+ rule_route_t *elem = (rule_route_t *) (e);
+ if (*elem) {
+ xbt_dynar_free(&(*elem)->re_str_link);
+ pcre_free((*elem)->re_src);
+ pcre_free((*elem)->re_dst);
+ xbt_free(*elem);
+ }
+ *elem = NULL;
+}
+
+static void rule_route_extended_free(void *e)
+{
+ rule_route_extended_t *elem = (rule_route_extended_t *) e;
+ if (*elem) {
+ xbt_dynar_free(&(*elem)->generic_rule_route.re_str_link);
+ pcre_free((*elem)->generic_rule_route.re_src);
+ pcre_free((*elem)->generic_rule_route.re_dst);
+ xbt_free((*elem)->re_src_gateway);
+ xbt_free((*elem)->re_dst_gateway);
+ xbt_free(*elem);
+ }
+}
+
+/* Parse routing model functions */
+
+static void model_rulebased_set_processing_unit(routing_component_t rc,
+ const char *name)
+{
+ routing_component_rulebased_t routing =
+ (routing_component_rulebased_t) rc;
+ xbt_dict_set(routing->dict_processing_units, name, (void *) (-1), NULL);
+}
+
+static void model_rulebased_set_autonomous_system(routing_component_t rc,
+ const char *name)
+{
+ routing_component_rulebased_t routing =
+ (routing_component_rulebased_t) rc;
+ xbt_dict_set(routing->dict_autonomous_systems, name, (void *) (-1),
+ NULL);
+}
+
+static void model_rulebased_set_route(routing_component_t rc,
+ const char *src, const char *dst,
+ name_route_extended_t route)
+{
+ routing_component_rulebased_t routing =
+ (routing_component_rulebased_t) rc;
+ rule_route_t ruleroute = xbt_new0(s_rule_route_t, 1);
+ const char *error;
+ int erroffset;
+ ruleroute->re_src = pcre_compile(src, 0, &error, &erroffset, NULL);
+ xbt_assert3(ruleroute->re_src,
+ "PCRE compilation failed at offset %d (\"%s\"): %s\n",
+ erroffset, src, error);
+ ruleroute->re_dst = pcre_compile(dst, 0, &error, &erroffset, NULL);
+ xbt_assert3(ruleroute->re_src,
+ "PCRE compilation failed at offset %d (\"%s\"): %s\n",
+ erroffset, dst, error);
+ ruleroute->re_str_link = route->generic_route.link_list;
+ xbt_dynar_push(routing->list_route, &ruleroute);
+ xbt_free(route);
+}
+
+static void model_rulebased_set_ASroute(routing_component_t rc,
+ const char *src, const char *dst,
+ name_route_extended_t route)
+{
+ routing_component_rulebased_t routing =
+ (routing_component_rulebased_t) rc;
+ rule_route_extended_t ruleroute_e = xbt_new0(s_rule_route_extended_t, 1);
+ const char *error;
+ int erroffset;
+ ruleroute_e->generic_rule_route.re_src =
+ pcre_compile(src, 0, &error, &erroffset, NULL);
+ xbt_assert3(ruleroute_e->generic_rule_route.re_src,
+ "PCRE compilation failed at offset %d (\"%s\"): %s\n",
+ erroffset, src, error);
+ ruleroute_e->generic_rule_route.re_dst =
+ pcre_compile(dst, 0, &error, &erroffset, NULL);
+ xbt_assert3(ruleroute_e->generic_rule_route.re_src,
+ "PCRE compilation failed at offset %d (\"%s\"): %s\n",
+ erroffset, dst, error);
+ ruleroute_e->generic_rule_route.re_str_link =
+ route->generic_route.link_list;
+ ruleroute_e->re_src_gateway = route->src_gateway;
+ ruleroute_e->re_dst_gateway = route->dst_gateway;
+ xbt_dynar_push(routing->list_ASroute, &ruleroute_e);
+// xbt_free(route->src_gateway);
+// xbt_free(route->dst_gateway);
+ xbt_free(route);
+}
+
+static void model_rulebased_set_bypassroute(routing_component_t rc,
+ const char *src,
+ const char *dst,
+ route_extended_t e_route)
+{
+ xbt_die("bypass routing not supported for Route-Based model");
+}
+
+#define BUFFER_SIZE 4096 /* result buffer size */
+#define OVECCOUNT 30 /* should be a multiple of 3 */
+
+static char *remplace(char *value, const char **src_list, int src_size,
+ const char **dst_list, int dst_size)
+{
+
+ char result_result[BUFFER_SIZE];
+ int i_result_buffer;
+ int value_length = (int) strlen(value);
+ int number = 0;
+
+ int i = 0;
+ i_result_buffer = 0;
+ do {
+ if (value[i] == '$') {
+ i++; // skip $
+
+ // find the number
+ int number_length = 0;
+ while ('0' <= value[i + number_length]
+ && value[i + number_length] <= '9') {
+ number_length++;
+ }
+ xbt_assert2(number_length != 0,
+ "bad string parameter, no number indication, at offset: %d (\"%s\")",
+ i, value);
+
+ // solve number
+ number = atoi(value + i);
+ i = i + number_length;
+ xbt_assert2(i + 2 < value_length,
+ "bad string parameter, too few chars, at offset: %d (\"%s\")",
+ i, value);
+
+ // solve the indication
+ const char **param_list;
+ int param_size;
+ if (value[i] == 's' && value[i + 1] == 'r' && value[i + 2] == 'c') {
+ param_list = src_list;
+ param_size = src_size;
+ } else if (value[i] == 'd' && value[i + 1] == 's'
+ && value[i + 2] == 't') {
+ param_list = dst_list;
+ param_size = dst_size;
+ } else {
+ xbt_assert2(0,
+ "bad string parameter, support only \"src\" and \"dst\", at offset: %d (\"%s\")",
+ i, value);
+ }
+ i = i + 3;
+
+ xbt_assert4(param_size >= number,
+ "bad string parameter, not enough length param_size, at offset: %d (\"%s\") %d %d",
+ i, value, param_size, number);
+
+ const char *param = param_list[number];
+ int size = strlen(param);
+ int cp;
+ for (cp = 0; cp < size; cp++) {
+ result_result[i_result_buffer] = param[cp];
+ i_result_buffer++;
+ if (i_result_buffer >= BUFFER_SIZE)
+ break;
+ }
+ } else {
+ result_result[i_result_buffer] = value[i];
+ i_result_buffer++;
+ i++; // next char
+ }
+
+ } while (i < value_length && i_result_buffer < BUFFER_SIZE);
+
+ xbt_assert2(i_result_buffer < BUFFER_SIZE,
+ "solving string \"%s\", small buffer size (%d)", value,
+ BUFFER_SIZE);
+ result_result[i_result_buffer] = 0;
+ return xbt_strdup(result_result);
+}
+
+static route_extended_t rulebased_get_route(routing_component_t rc,
+ const char *src,
+ const char *dst);
+static xbt_dynar_t rulebased_get_onelink_routes(routing_component_t rc)
+{
+ xbt_dynar_t ret = xbt_dynar_new (sizeof(onelink_t), xbt_free);
+ routing_component_rulebased_t routing = (routing_component_rulebased_t)rc;
+
+ xbt_dict_cursor_t c1 = NULL;
+ char *k1, *d1;
+
+ //find router
+ char *router = NULL;
+ xbt_dict_foreach(routing->dict_processing_units, c1, k1, d1) {
+ if (strstr (k1, "router")){
+ router = k1;
+ }
+ }
+ if (!router){
+ xbt_die ("rulebased_get_onelink_routes works only if the AS is a cluster, sorry.");
+ }
+
+ xbt_dict_foreach(routing->dict_processing_units, c1, k1, d1) {
+ route_extended_t route = rulebased_get_route (rc, router, k1);
+
+ int number_of_links = xbt_dynar_length(route->generic_route.link_list);
+ if (number_of_links != 3) {
+ xbt_die ("rulebased_get_onelink_routes works only if the AS is a cluster, sorry.");
+ }
+
+ void *link_ptr;
+ xbt_dynar_get_cpy (route->generic_route.link_list, 2, &link_ptr);
+ onelink_t onelink = xbt_new0 (s_onelink_t, 1);
+ onelink->src = xbt_strdup (k1);
+ onelink->dst = xbt_strdup (router);
+ onelink->link_ptr = link_ptr;
+ xbt_dynar_push (ret, &onelink);
+ }
+ return ret;
+}
+
+/* Business methods */
+static route_extended_t rulebased_get_route(routing_component_t rc,
+ const char *src,
+ const char *dst)
+{
+ xbt_assert1(rc && src
+ && dst,
+ "Invalid params for \"get_route\" function at AS \"%s\"",
+ rc->name);
+
+ /* set utils vars */
+ routing_component_rulebased_t routing =
+ (routing_component_rulebased_t) rc;
+
+ int are_processing_units;
+ xbt_dynar_t rule_list;
+ if (xbt_dict_get_or_null(routing->dict_processing_units, src)
+ && xbt_dict_get_or_null(routing->dict_processing_units, dst)) {
+ are_processing_units = 1;
+ rule_list = routing->list_route;
+ } else if (xbt_dict_get_or_null(routing->dict_autonomous_systems, src)
+ && xbt_dict_get_or_null(routing->dict_autonomous_systems,
+ dst)) {
+ are_processing_units = 0;
+ rule_list = routing->list_ASroute;
+ } else
+ xbt_assert2(NULL,
+ "Ask for route \"from\"(%s) or \"to\"(%s) no found in the local table",
+ src, dst);
+
+ int rc_src = -1;
+ int rc_dst = -1;
+ int src_length = (int) strlen(src);
+ int dst_length = (int) strlen(dst);
+
+ xbt_dynar_t links_list =
+ xbt_dynar_new(global_routing->size_of_link, NULL);
+
+ rule_route_t ruleroute;
+ unsigned int cpt;
+ int ovector_src[OVECCOUNT];
+ int ovector_dst[OVECCOUNT];
+ const char **list_src = NULL;
+ const char **list_dst = NULL;
+ xbt_dynar_foreach(rule_list, cpt, ruleroute) {
+ rc_src =
+ pcre_exec(ruleroute->re_src, NULL, src, src_length, 0, 0,
+ ovector_src, OVECCOUNT);
+ if (rc_src >= 0) {
+ rc_dst =
+ pcre_exec(ruleroute->re_dst, NULL, dst, dst_length, 0, 0,
+ ovector_dst, OVECCOUNT);
+ if (rc_dst >= 0) {
+ xbt_assert1(!pcre_get_substring_list
+ (src, ovector_src, rc_src, &list_src),
+ "error solving substring list for src \"%s\"", src);
+ xbt_assert1(!pcre_get_substring_list
+ (dst, ovector_dst, rc_dst, &list_dst),
+ "error solving substring list for src \"%s\"", dst);
+ char *link_name;
+ xbt_dynar_foreach(ruleroute->re_str_link, cpt, link_name) {
+ char *new_link_name =
+ remplace(link_name, list_src, rc_src, list_dst, rc_dst);
+ void *link =
+ xbt_dict_get_or_null(surf_network_model->resource_set,
+ new_link_name);
+ if (link)
+ xbt_dynar_push(links_list, &link);
+ else
+ THROW1(mismatch_error, 0, "Link %s not found", new_link_name);
+ xbt_free(new_link_name);
+ }
+ }
+ }
+ if (rc_src >= 0 && rc_dst >= 0)
+ break;
+ }
+
+ route_extended_t new_e_route = NULL;
+ if (rc_src >= 0 && rc_dst >= 0) {
+ new_e_route = xbt_new0(s_route_extended_t, 1);
+ new_e_route->generic_route.link_list = links_list;
+ } else if (!strcmp(src, dst) && are_processing_units) {
+ new_e_route = xbt_new0(s_route_extended_t, 1);
+ xbt_dynar_push(links_list, &(global_routing->loopback));
+ new_e_route->generic_route.link_list = links_list;
+ } else {
+ xbt_dynar_free(&link_list);
+ }
+
+ if (!are_processing_units && new_e_route) {
+ rule_route_extended_t ruleroute_extended =
+ (rule_route_extended_t) ruleroute;
+ new_e_route->src_gateway =
+ remplace(ruleroute_extended->re_src_gateway, list_src, rc_src,
+ list_dst, rc_dst);
+ new_e_route->dst_gateway =
+ remplace(ruleroute_extended->re_dst_gateway, list_src, rc_src,
+ list_dst, rc_dst);
+ }
+
+ if (list_src)
+ pcre_free_substring_list(list_src);
+ if (list_dst)
+ pcre_free_substring_list(list_dst);
+
+ return new_e_route;
+}
+
+static route_extended_t rulebased_get_bypass_route(routing_component_t rc,
+ const char *src,
+ const char *dst)
+{
+ return NULL;
+}
+
+static void rulebased_finalize(routing_component_t rc)
+{
+ routing_component_rulebased_t routing =
+ (routing_component_rulebased_t) rc;
+ if (routing) {
+ xbt_dict_free(&routing->dict_processing_units);
+ xbt_dict_free(&routing->dict_autonomous_systems);
+ xbt_dynar_free(&routing->list_route);
+ xbt_dynar_free(&routing->list_ASroute);
+ /* Delete structure */
+ xbt_free(routing);
+ }
+}
+
+/* Creation routing model functions */
+static void *model_rulebased_create(void)
+{
+ routing_component_rulebased_t new_component =
+ xbt_new0(s_routing_component_rulebased_t, 1);
+ new_component->generic_routing.set_processing_unit =
+ model_rulebased_set_processing_unit;
+ new_component->generic_routing.set_autonomous_system =
+ model_rulebased_set_autonomous_system;
+ new_component->generic_routing.set_route = model_rulebased_set_route;
+ new_component->generic_routing.set_ASroute = model_rulebased_set_ASroute;
+ new_component->generic_routing.set_bypassroute = model_rulebased_set_bypassroute;
+ new_component->generic_routing.get_onelink_routes = rulebased_get_onelink_routes;
+ new_component->generic_routing.get_route = rulebased_get_route;
+ new_component->generic_routing.get_latency = generic_get_link_latency;
+ new_component->generic_routing.get_bypass_route = rulebased_get_bypass_route;
+ new_component->generic_routing.finalize = rulebased_finalize;
+ new_component->generic_routing.get_network_element_type = get_network_element_type;
+ /* initialization of internal structures */
+ new_component->dict_processing_units = xbt_dict_new();
+ new_component->dict_autonomous_systems = xbt_dict_new();
+ new_component->list_route = xbt_dynar_new(sizeof(rule_route_t), &rule_route_free);
+ new_component->list_ASroute =
+ xbt_dynar_new(sizeof(rule_route_extended_t),
+ &rule_route_extended_free);
+ return new_component;
+}
+
+static void model_rulebased_load(void)
+{
+ /* use "surfxml_add_callback" to add a parse function call */
+}
+
+static void model_rulebased_unload(void)
+{
+ /* use "surfxml_del_callback" to remove a parse function call */
+}
+
+static void model_rulebased_end(void)
+{
+}
+
+#endif /* HAVE_PCRE_LIB */
+
+/* ************************************************************************** */
+/* ******************************* NO ROUTING ******************************* */
+
+/* Routing model structure */
+typedef struct {
+ s_routing_component_t generic_routing;
+} s_routing_component_none_t, *routing_component_none_t;
+
+/* Business methods */
+static xbt_dynar_t none_get_onelink_routes(routing_component_t rc)
+{
+ return NULL;
+}
+
+static route_extended_t none_get_route(routing_component_t rc,
+ const char *src, const char *dst)
+{
+ return NULL;
+}
+
+static route_extended_t none_get_bypass_route(routing_component_t rc,
+ const char *src,
+ const char *dst)
+{
+ return NULL;
+}
+
+static void none_finalize(routing_component_t rc)
+{
+ xbt_free(rc);
+}
+
+static void none_set_processing_unit(routing_component_t rc,
+ const char *name)
+{
+}
+
+static void none_set_autonomous_system(routing_component_t rc,
+ const char *name)
+{
+}
+
+/* Creation routing model functions */
+static void *model_none_create(void)
+{
+ routing_component_none_t new_component =
+ xbt_new0(s_routing_component_none_t, 1);
+ new_component->generic_routing.set_processing_unit =
+ none_set_processing_unit;
+ new_component->generic_routing.set_autonomous_system =
+ none_set_autonomous_system;
+ new_component->generic_routing.set_route = NULL;
+ new_component->generic_routing.set_ASroute = NULL;
+ new_component->generic_routing.set_bypassroute = NULL;
+ new_component->generic_routing.get_route = none_get_route;
+ new_component->generic_routing.get_onelink_routes =
+ none_get_onelink_routes;
+ new_component->generic_routing.get_bypass_route = none_get_bypass_route;
+ new_component->generic_routing.finalize = none_finalize;
+ return new_component;
+}
+
+static void model_none_load(void)
+{
+}
+
+static void model_none_unload(void)
+{
+}
+
+static void model_none_end(void)
+{
+}
+
+/* ************************************************** */
+/* ********** PATERN FOR NEW ROUTING **************** */
+
+/* The minimal configuration of a new routing model need the next functions,
+ * also you need to set at the start of the file, the new model in the model
+ * list. Remember keep the null ending of the list.
+ */
+/*** Routing model structure ***/
+// typedef struct {
+// s_routing_component_t generic_routing;
+// /* things that your routing model need */
+// } s_routing_component_NEW_t,*routing_component_NEW_t;
+
+/*** Parse routing model functions ***/
+// static void model_NEW_set_processing_unit(routing_component_t rc, const char* name) {}
+// static void model_NEW_set_autonomous_system(routing_component_t rc, const char* name) {}
+// static void model_NEW_set_route(routing_component_t rc, const char* src, const char* dst, route_t route) {}
+// static void model_NEW_set_ASroute(routing_component_t rc, const char* src, const char* dst, route_extended_t route) {}
+// static void model_NEW_set_bypassroute(routing_component_t rc, const char* src, const char* dst, route_extended_t e_route) {}
+
+/*** Business methods ***/
+// static route_extended_t NEW_get_route(routing_component_t rc, const char* src,const char* dst) {return NULL;}
+// static route_extended_t NEW_get_bypass_route(routing_component_t rc, const char* src,const char* dst) {return NULL;}
+// static void NEW_finalize(routing_component_t rc) { xbt_free(rc);}
+
+/*** Creation routing model functions ***/
+// static void* model_NEW_create(void) {
+// routing_component_NEW_t new_component = xbt_new0(s_routing_component_NEW_t,1);
+// new_component->generic_routing.set_processing_unit = model_NEW_set_processing_unit;
+// new_component->generic_routing.set_autonomous_system = model_NEW_set_autonomous_system;
+// new_component->generic_routing.set_route = model_NEW_set_route;
+// new_component->generic_routing.set_ASroute = model_NEW_set_ASroute;
+// new_component->generic_routing.set_bypassroute = model_NEW_set_bypassroute;
+// new_component->generic_routing.get_route = NEW_get_route;
+// new_component->generic_routing.get_bypass_route = NEW_get_bypass_route;
+// new_component->generic_routing.finalize = NEW_finalize;
+// /* initialization of internal structures */
+// return new_component;
+// } /* mandatory */
+// static void model_NEW_load(void) {} /* mandatory */
+// static void model_NEW_unload(void) {} /* mandatory */
+// static void model_NEW_end(void) {} /* mandatory */
+
+/* ************************************************************************** */
+/* ************************* GENERIC PARSE FUNCTIONS ************************ */
+
+static void generic_set_processing_unit(routing_component_t rc,
+ const char *name)
+{
+ DEBUG1("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);
+}
+
+static void generic_set_autonomous_system(routing_component_t rc,
+ const char *name)
+{
+ DEBUG1("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);
+}
+
+static int surf_pointer_resource_cmp(const void *a, const void *b)
+{
+ return a != b;
+}
+
+static int surf_link_resource_cmp(const void *a, const void *b)
+{
+ return !!memcmp(a,b,global_routing->size_of_link);
+}
+
+static void generic_set_bypassroute(routing_component_t rc,
+ const char *src, const char *dst,
+ route_extended_t e_route)
+{
+ DEBUG2("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_assert2(xbt_dynar_length(e_route->generic_route.link_list) > 0,
+ "Invalid count of links, must be greater than zero (%s,%s)",
+ src, dst);
+ xbt_assert4(!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);
+}
+
+/* ************************************************************************** */
+/* *********************** GENERIC BUSINESS METHODS ************************* */
+
+static double generic_get_link_latency(routing_component_t rc,
+ const char *src, const char *dst)
+{
+ route_extended_t route = rc->get_route(rc,src,dst);
+ void * link;
+ unsigned int i;
+ double latency = 0.0;
+
+ xbt_dynar_foreach(route->generic_route.link_list,i,link) {
+ latency += get_link_latency(link);
+ }
+ generic_free_extended_route(route);
+ return latency;
+}
+
+static xbt_dynar_t generic_get_onelink_routes(routing_component_t rc)
+{
+ xbt_die("\"generic_get_onelink_routes\" not implemented yet");
+}
+
+static 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 */
+ src_as = ((network_element_info_t)
+ xbt_dict_get_or_null(global_routing->where_network_elements,
+ src))->rc_component;
+ dst_as = ((network_element_info_t)
+ xbt_dict_get_or_null(global_routing->where_network_elements,
+ dst))->rc_component;
+ xbt_assert2(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 */
+ 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;
+ }
+
+ /* (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) {
+ routing_component_t *tmp_src, *tmp_dst;
+ tmp_src = xbt_dynar_pop_ptr(path_src);
+ tmp_dst = 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);
+ }
+
+ int max_index_src = path_src->used - 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);
+ }
+ }
+
+ return new_e_route;
+}
+
+/* ************************************************************************** */
+/* ************************* GENERIC AUX FUNCTIONS ************************** */
+
+static route_t
+generic_new_route(e_surf_routing_hierarchy_t hierarchy,
+ void *data, int order)
+{
+
+ char *link_name;
+ route_t new_route;
+ unsigned int cpt;
+ xbt_dynar_t links = NULL, links_id = NULL;