-/* Copyright (c) 2009 The SimGrid team. All rights reserved. */
+/* 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 "xbt/graph.h"
#include "xbt/set.h"
-XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_route,surf,"Routing part of surf");// FIXME: connect this under windows
+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 {
{"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}};
}
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);
+ fprintf(stderr," %s: %s\n",models[cpt].name,models[cpt].desc);
+ xbt_die("Invalid model.");
}
/* ************************************************************************** */
} 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))
+
+/*
+ * Free the onelink routes
+ */
+static void onelink_route_elem_free(void *e) {
+ s_onelink_t tmp = (s_onelink_t)e;
+ if(tmp) {
+ free(tmp);
+ }
+}
/*
* Parsing
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 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_router_id, *val);
+ TRACE_surf_host_declaration (A_surfxml_router_id, 0);
+#endif
+}
+
static int src_id = -1;
static int dst_id = -1;
static void routing_full_parse_Sroute_set_endpoints(void)
}
}
+/* Cluster tag functions */
+
+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)
+{
+ int AX_ptr = 0;
+
+ 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);
+}
+
+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)
+{
+ int AX_ptr = 0;
+
+ 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);
+}
+
+static void routing_full_parse_Scluster(void)
+{
+ static int AX_ptr = 0;
+
+ 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);
+
+ /* Make set a set to parse the prefix/suffix/radical into a neat list of names */
+ DEBUG4("Make <set id='%s' prefix='%s' suffix='%s' radical='%s'>",
+ 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);
+
+ SURFXML_START_TAG(set);
+ SURFXML_END_TAG(set);
+
+ names = xbt_dict_get(set_list,cluster_id);
+
+ 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;
+
+ SURFXML_START_TAG(host);
+ SURFXML_END_TAG(host);
+
+ /* 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;
+
+ SURFXML_START_TAG(link);
+ SURFXML_END_TAG(link);
+ }
+
+ /* 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;
+
+ SURFXML_START_TAG(link);
+ SURFXML_END_TAG(link);
+
+ /* 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);
+ }
+ }
+ }
+
+ /* Make route multi with the outside world, i.e. cluster->$* */
+
+ /* 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;
+
+ SURFXML_START_TAG(route_c_multi);
+
+ SURFXML_BUFFER_SET(link_c_ctn_id, "$src");
+
+ SURFXML_START_TAG(link_c_ctn);
+ SURFXML_END_TAG(link_c_ctn);
+
+ SURFXML_END_TAG(route_c_multi);
+
+ free(backbone_name);
+
+ /* Restore buff */
+ surfxml_bufferstack_pop(1);
+}
+
static void routing_full_parse_end(void) {
routing_full_t routing = (routing_full_t) used_routing;
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
+ }
+
+ 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;
+ }
+
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) {
* Business methods
*/
static xbt_dynar_t routing_full_get_route(int src,int dst) {
+ xbt_assert0(!(ISROUTER(src) || ISROUTER(dst)), "Ask for route \"from\" or \"to\" a router node");
return ROUTE_FULL(src,dst);
}
+static xbt_dict_t routing_full_get_onelink_routes(void){
+ return onelink_routes;
+}
+
+static int routing_full_is_router(int id){
+ return ISROUTER(id);
+}
+
static void routing_full_finalize(void) {
routing_full_t routing = (routing_full_t)used_routing;
int i,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;
}
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;
+
routing->size_of_link = size_of_link;
routing->loopback = loopback;
/* Set it in position */
used_routing = (routing_t) routing;
+ /* Set the dict for onehop routes */
+ onelink_routes = xbt_dict_new();
+
/* 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);
+}
+
+/* ************************************************************************** */
+
+static void routing_shortest_path_parse_Scluster(void)
+{
+ static int AX_ptr = 0;
+
+ 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_bufferstack_push(1);
+
+ /* 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_START_TAG(set);
+ SURFXML_END_TAG(set);
+
+ /* Make foreach */
+ SURFXML_BUFFER_SET(foreach_set_id, cluster_id);
+
+ SURFXML_START_TAG(foreach);
+
+ /* 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_START_TAG(host);
+ SURFXML_END_TAG(host);
+
+ SURFXML_END_TAG(foreach);
+
+ /* 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;
+
+ SURFXML_START_TAG(link);
+ SURFXML_END_TAG(link);
+
+ free(backbone_name);
+
+ /* Restore buff */
+ surfxml_bufferstack_pop(1);
}
/* ************************************************************************** */
/* *************************** FLOYD ROUTING ********************************* */
typedef struct {
s_routing_t generic_routing;
- double *cost_table;
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) ((routing_floyd_t)used_routing)->cost_table[(i)+(j)*(used_routing)->host_count]
+#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]
routing_floyd_t routing = (routing_floyd_t) used_routing;
int nb_link = 0;
- unsigned int cpt = 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;
- char *link_name = NULL;
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 */
- routing->cost_table = xbt_new0(double, host_count * host_count); //link cost from host to host
+ 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; i<host_count;i++)
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);
- xbt_dynar_foreach (links, cpt, link_name) {
- void* 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);
+ 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;
//Calculate path costs
- unsigned int a,b,c;
+
for(c=0;c<host_count;c++) {
for(a=0;a<host_count;a++) {
for(b=0;b<host_count;b++) {
}
}
}
+
+ //cleanup
+ free(cost_table);
}
/*
int pred = dst_id;
int prev_pred = 0;
- xbt_dynar_t link_list = xbt_dynar_new(routing->size_of_link, NULL);
+ xbt_dynar_reset(routing->last_route);
do {
prev_pred = pred;
if(pred == -1) // if no pred in route -> no route to host
break;
- xbt_dynar_unshift(link_list, &FLOYD_LINK(pred,prev_pred));
+ xbt_dynar_unshift(routing->last_route, &FLOYD_LINK(pred,prev_pred));
} while(pred != src_id);
xbt_assert2(pred != -1, "no route from host %d to %d", src_id, dst_id);
- return link_list;
-}
-
-static void routing_floyd_finalize_route(xbt_dynar_t route) {
- xbt_dynar_free(&route);
+ return routing->last_route;
}
static void routing_floyd_finalize(void) {
if (routing) {
free(routing->link_table);
- free(routing->cost_table);
free(routing->predecessor_table);
+ xbt_dynar_free(&routing->last_route);
xbt_dict_free(&used_routing->host_id);
free(routing);
routing=NULL;
}
}
+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");
+}
+
+static int routing_floyd_is_router(int id){
+ xbt_assert0(0,"The get_is_router feature is not supported in routing model Floyd");
+}
+
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->generic_routing.finalize_route = routing_floyd_finalize_route;
routing->size_of_link = size_of_link;
routing->loopback = loopback;
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_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);
}
typedef struct {
s_routing_t generic_routing;
xbt_graph_t route_graph;
- xbt_set_t graph_node_map;
- xbt_set_t route_cache;
+ 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;
typedef struct graph_node_data {
int id;
- int graph_id; //used for caching internal id's
+ 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_SET_HEADERS;
-
xbt_node_t node;
} s_graph_node_map_element_t, * graph_node_map_element_t;
typedef struct route_cache_element {
- XBT_SET_HEADERS;
-
int * pred_arr;
int size;
} s_route_cache_element_t, * route_cache_element_t;
route_cache_element_t elm=(route_cache_element_t)e;
if (elm) {
- free(elm->name);
free(elm->pred_arr);
free(elm);
}
graph_node_map_element_t elm = (graph_node_map_element_t)e;
if(elm) {
- free(elm->name);
free(elm);
}
}
* 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;
- graph_node_data_t data = xbt_new0(struct graph_node_data, sizeof(struct graph_node_data));
+ data = xbt_new0(struct graph_node_data, sizeof(struct graph_node_data));
data->id = id;
data->graph_id = graph_id;
- xbt_node_t node = xbt_graph_new_node(routing->route_graph, data);
+ node = xbt_graph_new_node(routing->route_graph, data);
- graph_node_map_element_t elm = xbt_new0(struct graph_node_map_element, sizeof(struct graph_node_map_element));
- elm->name_len = 0;
- elm->name = bprintf("%d",id);
+ elm = xbt_new0(struct graph_node_map_element, sizeof(struct graph_node_map_element));
elm->node = node;
-
- xbt_set_add(routing->graph_node_map, (xbt_set_elm_t)elm, &graph_node_map_elem_free);
+ xbt_dict_set_ext(routing->graph_node_map, (char*)(&id), sizeof(int), (xbt_set_elm_t)elm, &graph_node_map_elem_free);
return node;
}
static graph_node_map_element_t graph_node_map_search(int id) {
routing_dijkstra_t routing = (routing_dijkstra_t) used_routing;
- char * id_str = bprintf("%d",id);
- graph_node_map_element_t elm = (graph_node_map_element_t)xbt_set_get_by_name_or_null(routing->graph_node_map, id_str);
- free(id_str);
+ 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));
return elm;
}
xbt_node_t src = NULL;
xbt_node_t dst = NULL;
- char * src_id_str = bprintf("%d",src_id);
- char * dst_id_str = bprintf("%d",dst_id);
- graph_node_map_element_t src_elm = (graph_node_map_element_t)xbt_set_get_by_name_or_null(routing->graph_node_map, src_id_str);
- graph_node_map_element_t dst_elm = (graph_node_map_element_t)xbt_set_get_by_name_or_null(routing->graph_node_map, dst_id_str);
- free(src_id_str);
- free(dst_id_str);
+ 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));
if(src_elm)
src = src_elm->node;
static void routing_dijkstra_parse_end(void) {
routing_dijkstra_t routing = (routing_dijkstra_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;
-
+ 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_set_new();
+ 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_set_new();
+ routing->route_cache = xbt_dict_new();
/* Put the routes in position */
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);
- xbt_dynar_foreach(links, cpt, link_name) {
- void* 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);
- }
+ 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);
}
add_loopback_dijkstra();
/* initialize graph indexes in nodes after graph has been built */
- xbt_dynar_t nodes = xbt_graph_get_nodes(routing->route_graph);
+ nodes = xbt_graph_get_nodes(routing->route_graph);
- xbt_node_t node = NULL;
- unsigned int cursor2;
xbt_dynar_foreach(nodes, cursor2, node) {
graph_node_data_t data = xbt_graph_node_get_data(node);
data->graph_id = cursor2;
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);
- int src_node_id = ((graph_node_data_t)xbt_graph_node_get_data(src_elm->node))->graph_id;
- int dst_node_id = ((graph_node_data_t)xbt_graph_node_get_data(dst_elm->node))->graph_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;
- route_cache_element_t elm = NULL;
if(routing->cached) {
/*check if there is a cached predecessor list avail */
- char * src_id_str = bprintf("%d",src_id);
- elm = (route_cache_element_t)xbt_set_get_by_name_or_null(routing->route_cache, src_id_str);
- free(src_id_str);
+ 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[i] = 0;
//initialize priority queue
- int * nodeid = xbt_new0(int, 1);
+ nodeid = xbt_new0(int, 1);
*nodeid = i;
xbt_heap_push(pqueue, nodeid, cost_arr[i]);
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];
- int * nodeid = xbt_new0(int, 1);
+ nodeid = xbt_new0(int, 1);
*nodeid = u_id;
xbt_heap_push(pqueue, nodeid, cost_arr[u_id]);
}
}
//compose route path with links
- xbt_dynar_t link_list = xbt_dynar_new(routing->size_of_link, NULL);
+ xbt_dynar_reset(routing->last_route);
- int v;
- int size = 0;
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_assert2(edge != NULL, "no route between host %d and %d", src_id, dst_id);
- void * link = xbt_graph_edge_get_data(edge);
- xbt_dynar_unshift(link_list, &link);
+ link = xbt_graph_edge_get_data(edge);
+ xbt_dynar_unshift(routing->last_route, &link);
size++;
}
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->name = bprintf("%d",src_id);
- elm->name_len = 0;
elm->pred_arr = pred_arr;
elm->size = size;
- xbt_set_add(routing->route_cache, (xbt_set_elm_t)elm, &route_cache_elem_free);
+ xbt_dict_set_ext(routing->route_cache, (char*)(&src_id), sizeof(int), (xbt_set_elm_t)elm, &route_cache_elem_free);
}
if(!routing->cached)
free(pred_arr);
- return link_list;
+ return routing->last_route;
}
-static void routing_dijkstra_finalize_route(xbt_dynar_t route) {
- xbt_dynar_free(&route);
-}
static void routing_dijkstra_finalize(void) {
routing_dijkstra_t routing = (routing_dijkstra_t)used_routing;
if (routing) {
xbt_graph_free_graph(routing->route_graph, &free, NULL, &free);
- xbt_set_free(&routing->graph_node_map);
+ xbt_dict_free(&routing->graph_node_map);
if(routing->cached)
- xbt_set_free(&routing->route_cache);
+ xbt_dict_free(&routing->route_cache);
+ xbt_dynar_free(&routing->last_route);
xbt_dict_free(&used_routing->host_id);
free(routing);
routing=NULL;
}
}
+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");
+}
+
/*
*
*/
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->generic_routing.finalize_route = routing_dijkstra_finalize_route;
routing->size_of_link = size_of_link;
routing->loopback = loopback;
routing->cached = cached;
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) {
static void routing_model_dijkstracache_create(size_t size_of_link,void *loopback) {
routing_model_dijkstraboth_create(size_of_link, loopback, 1);
}
+
+/* ************************************************** */
+/* ********** NO ROUTING **************************** */
+
+
+static void routing_none_finalize(void) {
+ if (used_routing) {
+ xbt_dict_free(&used_routing->host_id);
+ free(used_routing);
+ used_routing=NULL;
+ }
+}
+
+static void routing_model_none_create(size_t size_of_link,void *loopback) {
+ routing_t routing = xbt_new0(s_routing_t,1);
+ 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;
+
+ routing->finalize = routing_none_finalize;
+
+ /* Set it in position */
+ used_routing = (routing_t) routing;
+}
+
+/*****************************************************************/
+/******************* BYBASS THE PARSER ***************************/
+
+/*
+ * FIXME : better to add to the routing model instead !!
+ *
+ */
+void routing_add_route(char *source_id,char *destination_id,xbt_dynar_t links_id,int action)
+{
+ char * link_id;
+ char * name;
+ unsigned int i;
+ src_id = *(int*)xbt_dict_get(used_routing->host_id,source_id);
+ dst_id = *(int*)xbt_dict_get(used_routing->host_id,destination_id);
+ DEBUG4("Route %s %d -> %s %d",source_id,src_id,destination_id,dst_id);
+ //set Links
+ xbt_dynar_foreach(links_id,i,link_id)
+ {
+ surf_add_route_element(link_id);
+ }
+ route_action = action;
+ 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);
+ }
+
+}
+
+void routing_add_host(char* host_id)
+{
+ int *val = xbt_malloc(sizeof(int));
+ DEBUG2("Seen host %s (#%d)",host_id,used_routing->host_count);
+ *val = used_routing->host_count++;
+ xbt_dict_set(used_routing->host_id,host_id,val,xbt_free);
+}
+
+void routing_set_routes()
+{
+ routing_full_parse_end();
+}
