} e_surf_network_element_type_t;
XBT_PUBLIC(e_surf_network_element_type_t)
- routing_get_network_element_type(const char *name);
+ routing_get_network_element_type(const char* name);
/** @Brief Specify that we use that action */
XBT_PUBLIC(void) surf_action_ref(surf_action_t action);
* Public functions specific to the network model
*/
typedef struct surf_network_model_extension_public {
- surf_action_t(*communicate) (const char *src_name,
- const char *dst_name,
+ surf_action_t(*communicate) (void* src,
+ void* dst,
double size, double rate);
- xbt_dynar_t(*get_route) (const char *src_name, const char *dst_name); //FIXME: kill field? That is done by the routing nowadays
+ xbt_dynar_t(*get_route) (void *src, void *dst); //FIXME: kill field? That is done by the routing nowadays
double (*get_link_bandwidth) (const void *link);
double (*get_link_latency) (const void *link);
int (*link_shared) (const void *link);
double value;
} s_smpi_factor_t;
-typedef struct s_net_card *net_card_t;
-typedef struct s_net_card {
- char* name;
- void* routing_obj;
-} s_net_card_t;
double sg_sender_gap = 0.0;
double sg_latency_factor = 1.0; /* default value; can be set by model or from command line */
}
-static surf_action_t net_communicate(const char *src_name,
- const char *dst_name, double size,
+static surf_action_t net_communicate(void *src,
+ void *dst, double size,
double rate)
{
unsigned int i;
xbt_dynar_t route = xbt_dynar_new(global_routing->size_of_link, NULL);
- XBT_IN("(%s,%s,%g,%g)", src_name, dst_name, size, rate);
+ XBT_IN("(%s,%s,%g,%g)", ((network_element_t)src)->name, ((network_element_t)dst)->name, size, rate);
- routing_get_route_and_latency(src_name, dst_name, &route, &latency);
+ routing_get_route_and_latency(src, dst, &route, &latency);
xbt_assert(!xbt_dynar_is_empty(route) || latency,
"You're trying to send data from %s to %s but there is no connection at all between these two hosts.",
- src_name, dst_name);
+ ((network_element_t)src)->name, ((network_element_t)dst)->name);
xbt_dynar_foreach(route, i, link) {
if (link->lmm_resource.state_current == SURF_RESOURCE_OFF) {
}
}
if (sg_network_crosstraffic == 1) {
- routing_get_route_and_latency(dst_name, src_name, &back_route, NULL);
+ routing_get_route_and_latency(src, dst, &back_route, NULL);
xbt_dynar_foreach(back_route, i, link) {
if (link->lmm_resource.state_current == SURF_RESOURCE_OFF) {
failed = 1;
link = *(link_CM02_t *) xbt_dynar_get_ptr(route, 0);
gap_append(size, link, action);
XBT_DEBUG("Comm %p: %s -> %s gap=%f (lat=%f)",
- action, src_name, dst_name, action->sender.gap,
+ action, ((network_element_t)src)->name, ((network_element_t)dst)->name, action->sender.gap,
action->latency);
}
return (surf_action_t) action;
}
-static xbt_dynar_t net_get_route(const char *src, const char *dst)
+static xbt_dynar_t net_get_route(void *src, void *dst)
{
xbt_dynar_t route = NULL;
routing_get_route_and_latency(src, dst, &route, NULL);
DIE_IMPOSSIBLE;
}
-static surf_action_t netcste_communicate(const char *src_name,
- const char *dst_name, double size,
+static surf_action_t netcste_communicate(void *src,
+ void *dst, double size,
double rate)
{
surf_action_network_Constant_t action = NULL;
+ char *src_name = ((network_element_t)src)->name;
+ char *dst_name = ((network_element_t)dst)->name;
+
XBT_IN("(%s,%s,%g,%g)", src_name, dst_name, size, rate);
action =
}
/* Max durations are not supported */
-static surf_action_t communicate(const char *src_name,
- const char *dst_name, double size,
+static surf_action_t communicate(void *src_card,
+ void *dst_card, double size,
double rate)
{
int src, dst;
return bdw;
}
-static xbt_dynar_t ns3_get_route(const char *src, const char *dst)
+static xbt_dynar_t ns3_get_route(void *src_card, void *dst_card)
{
xbt_dynar_t route = NULL;
- routing_get_route_and_latency(src, dst, &route, NULL);
+ routing_get_route_and_latency(src_card, dst_card, &route, NULL);
return route;
}
}
/* Max durations are not supported */
-static surf_action_t ns3_communicate(const char *src_name,
- const char *dst_name, double size, double rate)
+static surf_action_t ns3_communicate(void *src_card,
+ void *dst_card, double size, double rate)
{
surf_action_network_ns3_t action = NULL;
*/
int __surf_is_absolute_file_path(const char *file_path);
+typedef struct s_as *AS_t;
+typedef struct s_network_element_info {
+ AS_t rc_component;
+ e_surf_network_element_type_t rc_type;
+ int id;
+ char *name;
+} s_network_element_t, *network_element_t;
+
/*
* Link of lenght 1, alongside with its source and destination. This is mainly usefull in the bindings to gtnets and ns3
*/
typedef struct s_onelink {
- char *src;
- char *dst;
+ network_element_t src;
+ network_element_t dst;
void *link_ptr;
} s_onelink_t, *onelink_t;
/**
* Routing logic
*/
-typedef struct s_as *AS_t;
typedef struct s_model_type {
const char *name;
typedef struct s_route {
xbt_dynar_t link_list;
- char *src_gateway;
- char *dst_gateway;
+ network_element_t src_gateway;
+ network_element_t dst_gateway;
} s_route_t, *route_t;
/* This enum used in the routing structure helps knowing in which situation we are. */
} e_surf_routing_hierarchy_t;
typedef struct s_as {
- xbt_dict_t to_index; /* char* -> network_element_t */
+ int nb_index;
xbt_dict_t bypassRoutes; /* store bypass routes */
routing_model_description_t model_desc;
e_surf_routing_hierarchy_t hierarchy;
char *name;
struct s_as *routing_father;
xbt_dict_t routing_sons;
+ network_element_t net_elem;
- void (*get_route_and_latency) (AS_t as, const char *src, const char *dst, route_t into, double *latency);
+ void (*get_route_and_latency) (AS_t as, network_element_t src, network_element_t dst, route_t into, double *latency);
xbt_dynar_t(*get_onelink_routes) (AS_t as);
- route_t(*get_bypass_route) (AS_t as, const char *src, const char *dst);
+ route_t(*get_bypass_route) (AS_t as, network_element_t src, network_element_t dst);
void (*finalize) (AS_t as);
* that a new element is added to the AS currently built.
*
* Of course, only the routing model of this AS is informed, not every ones */
- void (*parse_PU) (AS_t as, const char *name); /* A host or a router, whatever */
- void (*parse_AS) (AS_t as, const char *name);
+ int (*parse_PU) (AS_t as, const char *name); /* A host or a router, whatever */
+ int (*parse_AS) (AS_t as, const char *name);
void (*parse_route) (AS_t as, const char *src,
const char *dst, route_t route);
void (*parse_ASroute) (AS_t as, const char *src,
const char *dst, route_t e_route);
} s_as_t;
-typedef struct s_network_element_info {
- AS_t rc_component;
- e_surf_network_element_type_t rc_type;
- int id;
- char *name;
-} s_network_element_info_t, *network_element_info_t;
-
-typedef int *network_element_t;
-
struct s_routing_global {
AS_t root;
void *loopback;
// FIXME: make previous function private to routing again?
-XBT_PUBLIC(void) routing_get_route_and_latency(const char *src, const char *dst,
+XBT_PUBLIC(void) routing_get_route_and_latency(network_element_t src, network_element_t dst,
xbt_dynar_t * route, double *latency);
/**
*/
static void parse_S_host(sg_platf_host_cbarg_t host)
{
- network_element_info_t info = NULL;
+ network_element_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);
- current_routing->parse_PU(current_routing, host->id);
- info = xbt_new0(s_network_element_info_t, 1);
+ info = xbt_new0(s_network_element_t, 1);
info->rc_component = current_routing;
info->rc_type = SURF_NETWORK_ELEMENT_HOST;
+ info->name = xbt_strdup(host->id);
+ info->id = current_routing->parse_PU(current_routing, host->id);
xbt_lib_set(host_lib, host->id, ROUTING_HOST_LEVEL, (void *) info);
+ XBT_DEBUG("Having set name '%s' id '%d'",host->id,info->id);
if(mount_list){
xbt_lib_set(storage_lib, host->id, ROUTING_STORAGE_HOST_LEVEL, (void *) mount_list);
char*str;
if (!COORD_HOST_LEVEL)
- xbt_die ("To use host coordinates, please add --cfg=coordinates:yes to your command line");
-
+ xbt_die ("To use host coordinates, please add --cfg=network/coordinates:yes to your command line");
/* Pre-parse the host coordinates -- FIXME factorize with routers by overloading the routing->parse_PU function*/
xbt_dynar_t ctn_str = xbt_str_split_str(host->coord, " ");
xbt_dynar_t ctn = xbt_dynar_new(sizeof(double),NULL);
xbt_dynar_shrink(ctn, 0);
xbt_dynar_free(&ctn_str);
xbt_lib_set(host_lib, host->id, COORD_HOST_LEVEL, (void *) ctn);
+ XBT_DEBUG("Having set host coordinates for '%s'",host->id);
}
}
*/
static void parse_S_router(sg_platf_router_cbarg_t router)
{
- network_element_info_t info = NULL;
+ network_element_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, router->id, ROUTING_ASR_LEVEL),
"Reading a router, processing unit \"%s\" already exists",
router->id);
- current_routing->parse_PU(current_routing, router->id);
- info = xbt_new0(s_network_element_info_t, 1);
+ info = xbt_new0(s_network_element_t, 1);
info->rc_component = current_routing;
info->rc_type = SURF_NETWORK_ELEMENT_ROUTER;
-
+ info->name = xbt_strdup(router->id);
+ info->id = current_routing->parse_PU(current_routing, router->id);
xbt_lib_set(as_router_lib, router->id, ROUTING_ASR_LEVEL, (void *) info);
+ XBT_DEBUG("Having set name '%s' id '%d'",router->id,info->id);
+
if (strcmp(router->coord, "")) {
unsigned int cursor;
char*str;
if (!COORD_ASR_LEVEL)
- xbt_die ("To use host coordinates, please add --cfg=coordinates:yes to your command line");
-
+ xbt_die ("To use host coordinates, please add --cfg=network/coordinates:yes to your command line");
/* Pre-parse the host coordinates */
xbt_dynar_t ctn_str = xbt_str_split_str(router->coord, " ");
xbt_dynar_t ctn = xbt_dynar_new(sizeof(double),NULL);
xbt_dynar_shrink(ctn, 0);
xbt_dynar_free(&ctn_str);
xbt_lib_set(as_router_lib, router->id, COORD_ASR_LEVEL, (void *) ctn);
+ XBT_DEBUG("Having set router coordinates for '%s'",router->id);
}
}
{
route_t e_route = xbt_new0(s_route_t, 1);
e_route->link_list = parsed_link_list;
- e_route->src_gateway = xbt_strdup(gw_src);
- e_route->dst_gateway = xbt_strdup(gw_dst);
+
+ if(!strcmp(current_routing->model_desc->name,"RuleBased")) {
+ e_route->src_gateway = (network_element_t) gw_src; // DIRTY HACK possible only
+ e_route->dst_gateway = (network_element_t) gw_dst; // because of what is in routing_parse_E_ASroute
+ }
+ else{
+ e_route->src_gateway = ((network_element_t)xbt_lib_get_or_null(as_router_lib,gw_src,ROUTING_ASR_LEVEL));
+ if(!e_route->src_gateway)
+ e_route->src_gateway = ((network_element_t)xbt_lib_get_or_null(host_lib,gw_src,ROUTING_HOST_LEVEL));
+ e_route->dst_gateway = ((network_element_t)xbt_lib_get_or_null(as_router_lib,gw_dst,ROUTING_ASR_LEVEL));
+ if(!e_route->dst_gateway)
+ e_route->dst_gateway = ((network_element_t)xbt_lib_get_or_null(host_lib,gw_dst,ROUTING_HOST_LEVEL));
+ }
xbt_assert(current_routing->parse_ASroute,
"no defined method \"set_ASroute\" in \"%s\"",
current_routing->name);
{
route_t e_route = xbt_new0(s_route_t, 1);
e_route->link_list = parsed_link_list;
- e_route->src_gateway = xbt_strdup(gw_src);
- e_route->dst_gateway = xbt_strdup(gw_dst);
+ e_route->src_gateway = ((network_element_t)xbt_lib_get_or_null(as_router_lib,gw_src,ROUTING_ASR_LEVEL));
+ if(!e_route->src_gateway)
+ e_route->src_gateway = ((network_element_t)xbt_lib_get_or_null(host_lib,gw_src,ROUTING_HOST_LEVEL));
+ e_route->dst_gateway = ((network_element_t)xbt_lib_get_or_null(as_router_lib,gw_dst,ROUTING_ASR_LEVEL));
+ if(!e_route->dst_gateway)
+ e_route->dst_gateway = ((network_element_t)xbt_lib_get_or_null(host_lib,gw_dst,ROUTING_HOST_LEVEL));
xbt_assert(current_routing->parse_bypassroute,
"Bypassing mechanism not implemented by routing '%s'",
current_routing->name);
routing_model_description_t model = NULL;
int cpt;
+ xbt_assert(!xbt_lib_get_or_null
+ (as_router_lib, AS_id, ROUTING_ASR_LEVEL),
+ "The AS \"%s\" already exists", AS_id);
+
/* search the routing model */
for (cpt = 0; routing_models[cpt].name; cpt++)
if (!strcmp(wanted_routing_type, routing_models[cpt].name))
new_as->hierarchy = SURF_ROUTING_NULL;
new_as->name = xbt_strdup(AS_id);
+ network_element_t info = NULL;
+ info = xbt_new0(s_network_element_t, 1);
+
if (current_routing == NULL && global_routing->root == NULL) {
/* it is the first one */
new_as->routing_father = NULL;
global_routing->root = new_as;
-
+ info->id = -1;
} else if (current_routing != NULL && global_routing->root != NULL) {
xbt_assert(!xbt_dict_get_or_null
xbt_dict_set(current_routing->routing_sons, AS_id,
(void *) new_as, NULL);
/* add to the father element list */
- current_routing->parse_AS(current_routing, AS_id);
+ info->id = current_routing->parse_AS(current_routing, AS_id);
} else {
THROWF(arg_error, 0, "All defined components must be belong to a AS");
}
+
+ info->rc_component = new_as->routing_father;
+ info->rc_type = SURF_NETWORK_ELEMENT_AS;
+ info->name = new_as->name;
+
+ xbt_lib_set(as_router_lib, new_as->name, ROUTING_ASR_LEVEL,
+ (void *) info);
+ XBT_DEBUG("Having set name '%s' id '%d'",new_as->name,info->id);
+
/* set the new current component of the tree */
current_routing = new_as;
+ current_routing->net_elem = info;
+
}
/**
if (current_routing == NULL) {
THROWF(arg_error, 0, "Close an AS, but none was under construction");
} 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);
-
if (current_routing->model_desc->end)
current_routing->model_desc->end(current_routing);
current_routing = current_routing->routing_father;
* 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,
+static void elements_father(network_element_t src, network_element_t dst,
AS_t * res_father,
AS_t * res_src,
AS_t * res_dst)
AS_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);
+ network_element_t src_data = src;
+ network_element_t dst_data = dst;
src_as = src_data->rc_component;
dst_as = dst_data->rc_component;
+ char* src_name = src_data->name;
+ char* dst_name = dst_data->name;
xbt_assert(src_as && dst_as,
- "Ask for route \"from\"(%s) or \"to\"(%s) no found", src, dst);
+ "Ask for route \"from\"(%s) or \"to\"(%s) no found", src_name, dst_name);
/* (2) find the path to the root routing component */
for (current = src_as; current != NULL; current = current->routing_father) {
* This function is called by "get_route" and "get_latency". It allows to walk
* recursively through the ASes tree.
*/
-static void _get_route_and_latency(const char *src, const char *dst,
+static void _get_route_and_latency(network_element_t src, network_element_t dst,
xbt_dynar_t * links, double *latency)
{
s_route_t route;
memset(&route,0,sizeof(route));
- XBT_DEBUG("Solve route/latency \"%s\" to \"%s\"", src, dst);
+ XBT_DEBUG("Solve route/latency \"%s\" to \"%s\"", src->name, dst->name);
xbt_assert(src && dst, "bad parameters for \"_get_route_latency\" method");
/* Find how src and dst are interconnected */
AS_t common_father, src_father, dst_father;
elements_father(src, dst, &common_father, &src_father, &dst_father);
+ XBT_DEBUG("elements_father: common father '%s' src_father '%s' dst_father '%s'",
+ common_father->name,src_father->name,dst_father->name);
/* If src and dst are in the same AS, life is good */
if (src_father == dst_father) { /* SURF_ROUTING_BASE */
route.link_list = *links;
common_father->get_route_and_latency(common_father, src, dst, &route,latency);
-
- xbt_free(route.src_gateway);
- xbt_free(route.dst_gateway);
return;
}
return;
}
-
/* Not in the same AS, no bypass. We'll have to find our path between the ASes recursively*/
route.link_list = xbt_dynar_new(global_routing->size_of_link, NULL);
- common_father->get_route_and_latency(common_father, src_father->name, dst_father->name, &route,latency);
+ // Find the net_card corresponding to father
+ network_element_t src_father_net_elm = src_father->net_elem;
+ network_element_t dst_father_net_elm = dst_father->net_elem;
+
+ common_father->get_route_and_latency(common_father, src_father_net_elm, dst_father_net_elm, &route,latency);
xbt_assert((route.src_gateway != NULL) && (route.dst_gateway != NULL),
- "bad gateways for route from \"%s\" to \"%s\"", src, dst);
+ "bad gateways for route from \"%s\" to \"%s\"", src->name, dst->name);
- char*src_gateway = route.src_gateway;
- char*dst_gateway = route.dst_gateway;
+ network_element_t src_gateway_net_elm = route.src_gateway;
+ network_element_t dst_gateway_net_elm = route.dst_gateway;
/* If source gateway is not our source, we have to recursively find our way up to this point */
- if (strcmp(src, src_gateway))
- _get_route_and_latency(src, src_gateway, links, latency);
+ if (strcmp(src->name, src_gateway_net_elm->name))
+ _get_route_and_latency(src, src_gateway_net_elm, links, latency);
xbt_dynar_merge(links,&(route.link_list));
/* If dest gateway is not our destination, we have to recursively find our way from this point */
// FIXME why can't I factorize it the same way than [src;src_gw] without breaking the examples??
- if (strcmp(dst_gateway, dst)) {
- _get_route_and_latency(dst_gateway, dst, links, latency);
+ if (strcmp(dst_gateway_net_elm->name, dst->name)) {
+ _get_route_and_latency(dst_gateway_net_elm, dst, links, latency);
}
-
- xbt_free(src_gateway);
- xbt_free_f(dst_gateway);
xbt_dynar_free(&route.link_list);
}
* walk through the routing components tree and find a route between hosts
* by calling the differents "get_route" functions in each routing component.
*/
-void routing_get_route_and_latency(const char *src, const char *dst,
+void routing_get_route_and_latency(network_element_t src, network_element_t dst,
xbt_dynar_t * route, double *latency)
{
if (!*route) {
_get_route_and_latency(src, dst, route, latency);
xbt_assert(!latency || *latency >= 0.0,
- "negative latency on route between \"%s\" and \"%s\"", src, dst);
+ "negative latency on route between \"%s\" and \"%s\"", src->name, dst->name);
}
static xbt_dynar_t recursive_get_onelink_routes(AS_t rc)
e_surf_network_element_type_t routing_get_network_element_type(const char *name)
{
- network_element_info_t rc = NULL;
+ network_element_t rc = NULL;
rc = xbt_lib_get_or_null(host_lib, name, ROUTING_HOST_LEVEL);
if (rc)
/* Business methods */
static void cluster_get_route_and_latency(AS_t as,
- const char *src, const char *dst,
+ network_element_t src, network_element_t dst,
route_t route, double *lat) {
surf_parsing_link_up_down_t info;
- info = xbt_dict_get_or_null(cluster_host_link,src);
+ info = xbt_dict_get_or_null(cluster_host_link,src->name);
if(info) { // link up
xbt_dynar_push_as(route->link_list,void*,info->link_up);
if (lat)
*lat += surf_network_model->extension.network.get_link_latency(((as_cluster_t)as)->backbone);
}
- info = xbt_dict_get_or_null(cluster_host_link,dst);
+ info = xbt_dict_get_or_null(cluster_host_link,dst->name);
if(info) { // link down
xbt_dynar_push_as(route->link_list,void*,info->link_down);
if (lat)
}
static void dijkstra_get_route_and_latency(AS_t as_generic,
- const char *src, const char *dst, route_t route, double *lat);
+ network_element_t src, network_element_t dst, route_t route, double *lat);
static xbt_dynar_t dijkstra_get_onelink_routes(AS_t as)
{
xbt_dynar_t ret = xbt_dynar_new(sizeof(onelink_t), xbt_free);
-
- //size_t table_size = xbt_dict_length(routing->generic_routing.to_index);
- xbt_dict_cursor_t c1 = NULL, c2 = NULL;
- char *k1, *d1, *k2, *d2;
- xbt_dict_foreach(as->to_index, c1, k1, d1) {
- xbt_dict_foreach(as->to_index, c2, k2, d2) {
- route_t route = xbt_new0(s_route_t,1);
- route->link_list = xbt_dynar_new(global_routing->size_of_link,NULL);
- dijkstra_get_route_and_latency(as, k1, k2,route, NULL);
-
- if (xbt_dynar_length(route->link_list) == 1) {
- void *link =
- *(void **) xbt_dynar_get_ptr(route->link_list, 0);
- onelink_t onelink = xbt_new0(s_onelink_t, 1);
- onelink->link_ptr = link;
- if (as->hierarchy == SURF_ROUTING_BASE) {
- onelink->src = xbt_strdup(k1);
- onelink->dst = xbt_strdup(k2);
- } else if (as->hierarchy ==
- SURF_ROUTING_RECURSIVE) {
- onelink->src = xbt_strdup(route->src_gateway);
- onelink->dst = xbt_strdup(route->dst_gateway);
- }
- xbt_dynar_push(ret, &onelink);
- }
- }
- }
+ THROW_UNIMPLEMENTED;
+// //size_t table_size = xbt_dict_length(routing->generic_routing.to_index);
+// xbt_dict_cursor_t c1 = NULL, c2 = NULL;
+// char *k1, *d1, *k2, *d2;
+// xbt_dict_foreach(as->to_index, c1, k1, d1) {
+// xbt_dict_foreach(as->to_index, c2, k2, d2) {
+// route_t route = xbt_new0(s_route_t,1);
+// route->link_list = xbt_dynar_new(global_routing->size_of_link,NULL);
+// dijkstra_get_route_and_latency(as, k1, k2,route, NULL);
+//
+// if (xbt_dynar_length(route->link_list) == 1) {
+// void *link =
+// *(void **) xbt_dynar_get_ptr(route->link_list, 0);
+// onelink_t onelink = xbt_new0(s_onelink_t, 1);
+// onelink->link_ptr = link;
+// if (as->hierarchy == SURF_ROUTING_BASE) {
+// onelink->src = xbt_strdup(k1);
+// onelink->dst = xbt_strdup(k2);
+// } else if (as->hierarchy ==
+// SURF_ROUTING_RECURSIVE) {
+// onelink->src = route->src_gateway;
+// onelink->dst = route->dst_gateway;
+// }
+// xbt_dynar_push(ret, &onelink);
+// }
+// }
+// }
return ret;
}
static void dijkstra_get_route_and_latency(AS_t asg,
- const char *src, const char *dst,
+ network_element_t src, network_element_t dst,
route_t route, double *lat)
{
as_dijkstra_t as = (as_dijkstra_t) asg;
generic_src_dst_check(asg, src, dst);
- int *src_id = xbt_dict_get_or_null(asg->to_index, src);
- int *dst_id = xbt_dict_get_or_null(asg->to_index, dst);
+ int *src_id = &(src->id);
+ int *dst_id = &(dst->id);
+
if (!src_id || !dst_id)
- THROWF(arg_error,0,"No route from '%s' to '%s'",src,dst);
+ THROWF(arg_error,0,"No route from '%s' to '%s'",src->name,dst->name);
int *pred_arr = NULL;
int src_node_id = 0;
xbt_graph_get_edge(as->route_graph, node_s_v, node_e_v);
if (edge == NULL)
- THROWF(arg_error,0,"No route from '%s' to '%s'",src,dst);
+ THROWF(arg_error,0,"No route from '%s' to '%s'",src->name,dst->name);
e_route = (route_t) xbt_graph_edge_get_data(edge);
}
/* compose route path with links */
- char *gw_src = NULL, *gw_dst = NULL, *prev_gw_src, *first_gw = NULL;
+ network_element_t gw_src, gw_dst, prev_gw_src, first_gw;
+ network_element_t gw_dst_net_elm = NULL, prev_gw_src_net_elm = NULL;
for (v = dst_node_id; v != src_node_id; v = pred_arr[v]) {
xbt_node_t node_pred_v =
xbt_graph_get_edge(as->route_graph, node_pred_v, node_v);
if (edge == NULL)
- THROWF(arg_error,0,"No route from '%s' to '%s'",src,dst);
+ THROWF(arg_error,0,"No route from '%s' to '%s'",src->name,dst->name);
prev_gw_src = gw_src;
first_gw = gw_dst;
if (asg->hierarchy == SURF_ROUTING_RECURSIVE && v != dst_node_id
- && strcmp(gw_dst, prev_gw_src)) {
+ && strcmp(gw_dst->name, prev_gw_src->name)) {
xbt_dynar_t e_route_as_to_as=NULL;
- routing_get_route_and_latency(gw_dst, prev_gw_src,&e_route_as_to_as,NULL);
+ routing_get_route_and_latency(gw_dst_net_elm, prev_gw_src_net_elm, &e_route_as_to_as, NULL);
if (edge == NULL)
- THROWF(arg_error,0,"No route from '%s' to '%s'",src,dst);
+ THROWF(arg_error,0,"No route from '%s' to '%s'",src->name,dst->name);
links = e_route_as_to_as;
int pos = 0;
xbt_dynar_foreach(links, cpt, link) {
}
if (asg->hierarchy == SURF_ROUTING_RECURSIVE) {
- route->src_gateway = xbt_strdup(gw_src);
- route->dst_gateway = xbt_strdup(first_gw);
+ route->src_gateway = gw_src;
+ route->dst_gateway = first_gw;
}
if (as->cached && elm == NULL) {
const char *dst, route_t route)
{
as_dijkstra_t as = (as_dijkstra_t) asg;
- int *src_id, *dst_id;
- src_id = xbt_dict_get_or_null(asg->to_index, src);
- dst_id = xbt_dict_get_or_null(asg->to_index, dst);
+ network_element_t src_net_elm, dst_net_elm;
+
+ src_net_elm = (network_element_t)xbt_lib_get_or_null(host_lib, src, ROUTING_HOST_LEVEL);
+ dst_net_elm = (network_element_t)xbt_lib_get_or_null(host_lib, dst, ROUTING_HOST_LEVEL);
+ if(!src_net_elm) src_net_elm = (network_element_t)xbt_lib_get_or_null(as_router_lib, src, ROUTING_ASR_LEVEL);
+ if(!dst_net_elm) dst_net_elm = (network_element_t)xbt_lib_get_or_null(as_router_lib, dst, ROUTING_ASR_LEVEL);
- xbt_assert(src_id, "Network elements %s not found", src);
- xbt_assert(dst_id, "Network elements %s not found", dst);
+ xbt_assert(src_net_elm, "Network elements %s not found", src);
+ xbt_assert(dst_net_elm, "Network elements %s not found", dst);
/* Create the topology graph */
if(!as->route_graph)
XBT_DEBUG("Load Route from \"%s\" to \"%s\"", src, dst);
else{
XBT_DEBUG("Load ASroute from \"%s(%s)\" to \"%s(%s)\"", src,
- route->src_gateway, dst, route->dst_gateway);
- if(routing_get_network_element_type((const char*)route->dst_gateway) == SURF_NETWORK_ELEMENT_NULL)
- xbt_die("The dst_gateway '%s' does not exist!",route->dst_gateway);
- if(routing_get_network_element_type((const char*)route->src_gateway) == SURF_NETWORK_ELEMENT_NULL)
- xbt_die("The src_gateway '%s' does not exist!",route->src_gateway);
+ route->src_gateway->name, dst, route->dst_gateway->name);
+ if(route->dst_gateway->rc_type == SURF_NETWORK_ELEMENT_NULL)
+ xbt_die("The dst_gateway '%s' does not exist!",route->dst_gateway->name);
+ if(route->src_gateway->rc_type == SURF_NETWORK_ELEMENT_NULL)
+ xbt_die("The src_gateway '%s' does not exist!",route->src_gateway->name);
}
route_t e_route = generic_new_extended_route(asg->hierarchy, route, 1);
- route_new_dijkstra(as, *src_id, *dst_id, e_route);
+ route_new_dijkstra(as, src_net_elm->id, dst_net_elm->id, e_route);
}
route_t *link_table;
} s_as_floyd_t, *as_floyd_t;
-static void floyd_get_route_and_latency(AS_t asg, const char *src, const char *dst,
+static void floyd_get_route_and_latency(AS_t asg, network_element_t src, network_element_t dst,
route_t res, double *lat);
/* Business methods */
static xbt_dynar_t floyd_get_onelink_routes(AS_t asg)
{
xbt_dynar_t ret = xbt_dynar_new(sizeof(onelink_t), xbt_free);
-
- route_t route = xbt_new0(s_route_t, 1);
- route->link_list = xbt_dynar_new(global_routing->size_of_link, NULL);
-
- xbt_dict_cursor_t c1 = NULL, c2 = NULL;
- char *k1, *d1, *k2, *d2;
- xbt_dict_foreach(asg->to_index, c1, k1, d1) {
- xbt_dict_foreach(asg->to_index, c2, k2, d2) {
- xbt_dynar_reset(route->link_list);
- floyd_get_route_and_latency(asg, k1, k2, route, NULL);
- if (xbt_dynar_length(route->link_list) == 1) {
- void *link = *(void **) xbt_dynar_get_ptr(route->link_list, 0);
- onelink_t onelink = xbt_new0(s_onelink_t, 1);
- onelink->link_ptr = link;
- if (asg->hierarchy == SURF_ROUTING_BASE) {
- onelink->src = xbt_strdup(k1);
- onelink->dst = xbt_strdup(k2);
- } else if (asg->hierarchy == SURF_ROUTING_RECURSIVE) {
- onelink->src = xbt_strdup(route->src_gateway);
- onelink->dst = xbt_strdup(route->dst_gateway);
- }
- xbt_dynar_push(ret, &onelink);
- }
- }
- }
+ THROW_UNIMPLEMENTED;
+// route_t route = xbt_new0(s_route_t, 1);
+// route->link_list = xbt_dynar_new(global_routing->size_of_link, NULL);
+//
+// xbt_dict_cursor_t c1 = NULL, c2 = NULL;
+// char *k1, *d1, *k2, *d2;
+// xbt_dict_foreach(asg->to_index, c1, k1, d1) {
+// xbt_dict_foreach(asg->to_index, c2, k2, d2) {
+// xbt_dynar_reset(route->link_list);
+// floyd_get_route_and_latency(asg, k1, k2, route, NULL);
+// if (xbt_dynar_length(route->link_list) == 1) {
+// void *link = *(void **) xbt_dynar_get_ptr(route->link_list, 0);
+// onelink_t onelink = xbt_new0(s_onelink_t, 1);
+// onelink->link_ptr = link;
+// if (asg->hierarchy == SURF_ROUTING_BASE) {
+// onelink->src = xbt_strdup(k1);
+// onelink->dst = xbt_strdup(k2);
+// } else if (asg->hierarchy == SURF_ROUTING_RECURSIVE) {
+// onelink->src = route->src_gateway;
+// onelink->dst = route->dst_gateway;
+// }
+// xbt_dynar_push(ret, &onelink);
+// }
+// }
+// }
return ret;
}
-static void floyd_get_route_and_latency(AS_t asg, const char *src, const char *dst,
+static void floyd_get_route_and_latency(AS_t asg, network_element_t src, network_element_t dst,
route_t res, double *lat)
{
/* set utils vars */
as_floyd_t as = (as_floyd_t)asg;
- size_t table_size = xbt_dict_length(asg->to_index);
+ size_t table_size = asg->nb_index;
generic_src_dst_check(asg, src, dst);
- int *src_id = xbt_dict_get_or_null(asg->to_index, src);
- int *dst_id = xbt_dict_get_or_null(asg->to_index, dst);
+ int *src_id = &(src->id);
+ int *dst_id = &(dst->id);
if (src_id == NULL || dst_id == NULL)
- THROWF(arg_error,0,"No route from '%s' to '%s'",src,dst);
+ THROWF(arg_error,0,"No route from '%s' to '%s'",
+ src->name,
+ dst->name);
/* create a result route */
int first = 1;
int pred = *dst_id;
int prev_pred = 0;
- char *gw_src = NULL, *gw_dst = NULL, *prev_gw_src, *first_gw = NULL;
+ network_element_t gw_src, gw_dst, prev_gw_src, first_gw;
unsigned int cpt;
void *link;
xbt_dynar_t links;
if (pred == -1) /* if no pred in route -> no route to host */
break;
xbt_assert(TO_FLOYD_LINK(pred, prev_pred),
- "Invalid link for the route between \"%s\" or \"%s\"", src,
- dst);
+ "Invalid link for the route between \"%s\" or \"%s\"",
+ src->name,
+ dst->name);
prev_gw_src = gw_src;
first_gw = gw_dst;
if (asg->hierarchy == SURF_ROUTING_RECURSIVE && !first
- && strcmp(gw_dst, prev_gw_src)) {
+ && strcmp(gw_dst->name, prev_gw_src->name)) {
xbt_dynar_t e_route_as_to_as;
e_route_as_to_as = xbt_dynar_new(global_routing->size_of_link, NULL);
routing_get_route_and_latency(gw_dst, prev_gw_src,&e_route_as_to_as,NULL);
} while (pred != *src_id);
if (pred == -1)
- THROWF(arg_error,0,"No route from '%s' to '%s'",src,dst);
+ THROWF(arg_error,0,"No route from '%s' to '%s'",
+ src->name,
+ dst->name);
if (asg->hierarchy == SURF_ROUTING_RECURSIVE) {
- res->src_gateway = xbt_strdup(gw_src);
- res->dst_gateway = xbt_strdup(first_gw);
+ res->src_gateway = gw_src;
+ res->dst_gateway = first_gw;
}
}
int i, j;
size_t table_size;
if (as) {
- table_size = xbt_dict_length(as->generic_routing.to_index);
+ table_size = as->generic_routing.nb_index;
/* Delete link_table */
for (i = 0; i < table_size; i++)
for (j = 0; j < table_size; j++)
xbt_free(as->link_table);
/* Delete bypass dict */
xbt_dict_free(&as->generic_routing.bypassRoutes);
- /* Delete index dict */
- xbt_dict_free(&(as->generic_routing.to_index));
/* Delete predecessor and cost table */
xbt_free(as->predecessor_table);
xbt_free(as->cost_table);
unsigned int i, j, a, b, c;
/* set the size of table routing */
- size_t table_size = xbt_dict_length(as->generic_routing.to_index);
+ size_t table_size = as->generic_routing.nb_index;
if(!as->link_table)
{
as_floyd_t as = (as_floyd_t) rc;
/* set the size of table routing */
- size_t table_size = xbt_dict_length(rc->to_index);
- int *src_id, *dst_id;
+ size_t table_size = rc->nb_index;
+ network_element_t src_net_elm, dst_net_elm;
- src_id = xbt_dict_get_or_null(rc->to_index, src);
- dst_id = xbt_dict_get_or_null(rc->to_index, dst);
+ src_net_elm = (network_element_t)xbt_lib_get_or_null(host_lib, src, ROUTING_HOST_LEVEL);
+ dst_net_elm = (network_element_t)xbt_lib_get_or_null(host_lib, dst, ROUTING_HOST_LEVEL);
+ if(!src_net_elm) src_net_elm = (network_element_t)xbt_lib_get_or_null(as_router_lib, src, ROUTING_ASR_LEVEL);
+ if(!dst_net_elm) dst_net_elm = (network_element_t)xbt_lib_get_or_null(as_router_lib, dst, ROUTING_ASR_LEVEL);
- xbt_assert(src_id, "Network elements %s not found", src);
- xbt_assert(dst_id, "Network elements %s not found", dst);
+ xbt_assert(src_net_elm, "Network elements %s not found", src);
+ xbt_assert(dst_net_elm, "Network elements %s not found", dst);
if(!as->link_table)
{
}
}
- if(TO_FLOYD_LINK(*src_id, *dst_id))
+ if(TO_FLOYD_LINK(src_net_elm->id, dst_net_elm->id))
{
if(!route->dst_gateway && !route->src_gateway)
XBT_DEBUG("See Route from \"%s\" to \"%s\"", src, dst);
else
XBT_DEBUG("See ASroute from \"%s(%s)\" to \"%s(%s)\"", src,
- route->src_gateway, dst, route->dst_gateway);
+ route->src_gateway->name, dst, route->dst_gateway->name);
char * link_name;
unsigned int cpt;
xbt_dynar_t link_route_to_test = xbt_dynar_new(global_routing->size_of_link, NULL);
xbt_dynar_push(link_route_to_test,&link);
}
xbt_assert(!xbt_dynar_compare(
- (void*)TO_FLOYD_LINK(*src_id, *dst_id)->link_list,
+ (void*)TO_FLOYD_LINK(src_net_elm->id, dst_net_elm->id)->link_list,
(void*)link_route_to_test,
(int_f_cpvoid_cpvoid_t) floyd_pointer_resource_cmp),
"The route between \"%s\" and \"%s\" already exists", src,dst);
XBT_DEBUG("Load Route from \"%s\" to \"%s\"", src, dst);
else{
XBT_DEBUG("Load ASroute from \"%s(%s)\" to \"%s(%s)\"", src,
- route->src_gateway, dst, route->dst_gateway);
- if(routing_get_network_element_type((const char*)route->dst_gateway) == SURF_NETWORK_ELEMENT_NULL)
- xbt_die("The dst_gateway '%s' does not exist!",route->dst_gateway);
- if(routing_get_network_element_type((const char*)route->src_gateway) == SURF_NETWORK_ELEMENT_NULL)
- xbt_die("The src_gateway '%s' does not exist!",route->src_gateway);
+ route->src_gateway->name, dst, route->dst_gateway->name);
+ if(route->dst_gateway->rc_type == SURF_NETWORK_ELEMENT_NULL)
+ xbt_die("The dst_gateway '%s' does not exist!",route->dst_gateway->name);
+ if(route->src_gateway->rc_type == SURF_NETWORK_ELEMENT_NULL)
+ xbt_die("The src_gateway '%s' does not exist!",route->src_gateway->name);
}
- TO_FLOYD_LINK(*src_id, *dst_id) =
+ TO_FLOYD_LINK(src_net_elm->id, dst_net_elm->id) =
generic_new_extended_route(rc->hierarchy, route, 1);
- TO_FLOYD_PRED(*src_id, *dst_id) = *src_id;
- TO_FLOYD_COST(*src_id, *dst_id) =
- ((TO_FLOYD_LINK(*src_id, *dst_id))->link_list)->used; /* count of links, old model assume 1 */
+ TO_FLOYD_PRED(src_net_elm->id, dst_net_elm->id) = src_net_elm->id;
+ TO_FLOYD_COST(src_net_elm->id, dst_net_elm->id) =
+ ((TO_FLOYD_LINK(src_net_elm->id, dst_net_elm->id))->link_list)->used; /* count of links, old model assume 1 */
}
if( A_surfxml_route_symmetrical == A_surfxml_route_symmetrical_YES
|| A_surfxml_ASroute_symmetrical == A_surfxml_ASroute_symmetrical_YES )
{
- if(TO_FLOYD_LINK(*dst_id, *src_id))
+ if(TO_FLOYD_LINK(dst_net_elm->id, src_net_elm->id))
{
if(!route->dst_gateway && !route->src_gateway)
XBT_DEBUG("See Route from \"%s\" to \"%s\"", dst, src);
else
XBT_DEBUG("See ASroute from \"%s(%s)\" to \"%s(%s)\"", dst,
- route->src_gateway, src, route->dst_gateway);
+ route->src_gateway->name, src, route->dst_gateway->name);
char * link_name;
unsigned int i;
xbt_dynar_t link_route_to_test = xbt_dynar_new(global_routing->size_of_link, NULL);
xbt_dynar_push(link_route_to_test,&link);
}
xbt_assert(!xbt_dynar_compare(
- (void*)TO_FLOYD_LINK(*dst_id, *src_id)->link_list,
+ (void*)TO_FLOYD_LINK(dst_net_elm->id, src_net_elm->id)->link_list,
(void*)link_route_to_test,
(int_f_cpvoid_cpvoid_t) floyd_pointer_resource_cmp),
"The route between \"%s\" and \"%s\" already exists", src,dst);
{
if(route->dst_gateway && route->src_gateway)
{
- char *gw_src = route->src_gateway;
- char *gw_dst = route->dst_gateway;
+ network_element_t gw_src = route->src_gateway;
+ network_element_t gw_dst = route->dst_gateway;
route->src_gateway = gw_dst;
route->dst_gateway = gw_src;
}
XBT_DEBUG("Load Route from \"%s\" to \"%s\"", dst, src);
else
XBT_DEBUG("Load ASroute from \"%s(%s)\" to \"%s(%s)\"", dst,
- route->src_gateway, src, route->dst_gateway);
+ route->src_gateway->name, src, route->dst_gateway->name);
- TO_FLOYD_LINK(*dst_id, *src_id) =
+ TO_FLOYD_LINK(dst_net_elm->id, src_net_elm->id) =
generic_new_extended_route(rc->hierarchy, route, 0);
- TO_FLOYD_PRED(*dst_id, *src_id) = *dst_id;
- TO_FLOYD_COST(*dst_id, *src_id) =
- ((TO_FLOYD_LINK(*dst_id, *src_id))->link_list)->used; /* count of links, old model assume 1 */
+ TO_FLOYD_PRED(dst_net_elm->id, src_net_elm->id) = dst_net_elm->id;
+ TO_FLOYD_COST(dst_net_elm->id, src_net_elm->id) =
+ ((TO_FLOYD_LINK(dst_net_elm->id, src_net_elm->id))->link_list)->used; /* count of links, old model assume 1 */
}
}
}
static xbt_dynar_t full_get_onelink_routes(AS_t rc)
{
xbt_dynar_t ret = xbt_dynar_new(sizeof(onelink_t), xbt_free);
-
- routing_component_full_t routing = (routing_component_full_t) rc;
- size_t table_size = xbt_dict_length(routing->generic_routing.to_index);
- xbt_dict_cursor_t c1 = NULL, c2 = NULL;
- char *k1, *d1, *k2, *d2;
- xbt_dict_foreach(routing->generic_routing.to_index, c1, k1, d1) {
- xbt_dict_foreach(routing->generic_routing.to_index, c2, k2, d2) {
- int *src_id = xbt_dict_get_or_null(routing->generic_routing.to_index, k1);
- int *dst_id = xbt_dict_get_or_null(routing->generic_routing.to_index, k2);
- xbt_assert(src_id && dst_id,
- "Ask for route \"from\"(%s) or \"to\"(%s) "
- "no found in the local table", k1, k2);
- route_t route = TO_ROUTE_FULL(*src_id, *dst_id);
- if (route) {
- if (xbt_dynar_length(route->link_list) == 1) {
- void *link = *(void **) xbt_dynar_get_ptr(route->link_list, 0);
- onelink_t onelink = xbt_new0(s_onelink_t, 1);
- onelink->link_ptr = link;
- if (routing->generic_routing.hierarchy == SURF_ROUTING_BASE) {
- onelink->src = xbt_strdup(k1);
- onelink->dst = xbt_strdup(k2);
- } else if (routing->generic_routing.hierarchy ==
- SURF_ROUTING_RECURSIVE) {
- onelink->src = xbt_strdup(route->src_gateway);
- onelink->dst = xbt_strdup(route->dst_gateway);
- }
- xbt_dynar_push(ret, &onelink);
- }
- }
- }
- }
+THROW_UNIMPLEMENTED;
+// routing_component_full_t routing = (routing_component_full_t) rc;
+// size_t table_size = routing->generic_routing.nb_index;
+// xbt_dict_cursor_t c1 = NULL, c2 = NULL;
+// char *k1, *d1, *k2, *d2;
+// xbt_dict_foreach(routing->generic_routing.to_index, c1, k1, d1) {
+// xbt_dict_foreach(routing->generic_routing.to_index, c2, k2, d2) {
+// int *src_id = xbt_dict_get_or_null(routing->generic_routing.to_index, k1);
+// int *dst_id = xbt_dict_get_or_null(routing->generic_routing.to_index, k2);
+// xbt_assert(src_id && dst_id,
+// "Ask for route \"from\"(%s) or \"to\"(%s) "
+// "no found in the local table", k1, k2);
+// route_t route = TO_ROUTE_FULL(*src_id, *dst_id);
+// if (route) {
+// if (xbt_dynar_length(route->link_list) == 1) {
+// void *link = *(void **) xbt_dynar_get_ptr(route->link_list, 0);
+// onelink_t onelink = xbt_new0(s_onelink_t, 1);
+// onelink->link_ptr = link;
+// if (routing->generic_routing.hierarchy == SURF_ROUTING_BASE) {
+// onelink->src->routing_obj->name = xbt_strdup(k1);
+// onelink->src->routing_obj->id = atoi(k1);
+// onelink->dst->routing_obj->name = xbt_strdup(k2);
+// onelink->dst->routing_obj->id = atoi(k2);
+// } else if (routing->generic_routing.hierarchy ==
+// SURF_ROUTING_RECURSIVE) {
+// onelink->src = route->src_gateway;
+// onelink->dst = route->dst_gateway;
+// }
+// xbt_dynar_push(ret, &onelink);
+// }
+// }
+// }
+// }
return ret;
}
static void full_get_route_and_latency(AS_t rc,
- const char *src, const char *dst,
+ network_element_t src, network_element_t dst,
route_t res, double *lat)
{
+ XBT_DEBUG("full_get_route_and_latency from %s[%d] to %s[%d]",
+ src->name,
+ src->id,
+ dst->name,
+ dst->id );
/* set utils vars */
routing_component_full_t routing = (routing_component_full_t) rc;
- size_t table_size = xbt_dict_length(routing->generic_routing.to_index);
-
- int *src_id = xbt_dict_get_or_null(routing->generic_routing.to_index, src);
- int *dst_id = xbt_dict_get_or_null(routing->generic_routing.to_index, dst);
-
- if (!src_id || !dst_id)
- THROWF(arg_error, 0, "No route from '%s' to '%s'", src, dst);
+ size_t table_size = routing->generic_routing.nb_index;
route_t e_route = NULL;
void *link;
unsigned int cpt = 0;
- e_route = TO_ROUTE_FULL(*src_id, *dst_id);
+ e_route = TO_ROUTE_FULL(src->id, dst->id);
if (e_route) {
- res->src_gateway = xbt_strdup(e_route->src_gateway);
- res->dst_gateway = xbt_strdup(e_route->dst_gateway);
+ res->src_gateway = e_route->src_gateway;
+ res->dst_gateway = e_route->dst_gateway;
xbt_dynar_foreach(e_route->link_list, cpt, link) {
xbt_dynar_push(res->link_list, &link);
if (lat)
static void full_finalize(AS_t rc)
{
routing_component_full_t routing = (routing_component_full_t) rc;
- size_t table_size = xbt_dict_length(routing->generic_routing.to_index);
+ size_t table_size = routing->generic_routing.nb_index;
int i, j;
if (routing) {
/* Delete routing table */
/* set utils vars */
routing_component_full_t routing =
((routing_component_full_t) current_routing);
- size_t table_size = xbt_dict_length(routing->generic_routing.to_index);
+ size_t table_size = routing->generic_routing.nb_index;
/* Create table if necessary */
if (!routing->routing_table)
void model_full_set_route(AS_t rc, const char *src,
const char *dst, route_t route)
{
- 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);
- routing_component_full_t routing = (routing_component_full_t) rc;
- size_t table_size = xbt_dict_length(routing->generic_routing.to_index);
+ network_element_t src_net_elm, dst_net_elm;
+
+ src_net_elm = (network_element_t)xbt_lib_get_or_null(host_lib, src, ROUTING_HOST_LEVEL);
+ dst_net_elm = (network_element_t)xbt_lib_get_or_null(host_lib, dst, ROUTING_HOST_LEVEL);
+ if(!src_net_elm) src_net_elm = (network_element_t)xbt_lib_get_or_null(as_router_lib, src, ROUTING_ASR_LEVEL);
+ if(!dst_net_elm) dst_net_elm = (network_element_t)xbt_lib_get_or_null(as_router_lib, dst, ROUTING_ASR_LEVEL);
- xbt_assert(src_id, "Network elements %s not found", src);
- xbt_assert(dst_id, "Network elements %s not found", dst);
+ xbt_assert(src_net_elm, "Network elements %s not found", src);
+ xbt_assert(dst_net_elm, "Network elements %s not found", dst);
+
+ routing_component_full_t routing = (routing_component_full_t) rc;
+ size_t table_size = routing->generic_routing.nb_index;
xbt_assert(!xbt_dynar_is_empty(route->link_list),
"Invalid count of links, must be greater than zero (%s,%s)",
if (!routing->routing_table)
routing->routing_table = xbt_new0(route_t, table_size * table_size);
- if (TO_ROUTE_FULL(*src_id, *dst_id)) {
+ if (TO_ROUTE_FULL(src_net_elm->id, dst_net_elm->id)) {
char *link_name;
unsigned int i;
xbt_dynar_t link_route_to_test =
xbt_assert(link, "Link : '%s' doesn't exists.", link_name);
xbt_dynar_push(link_route_to_test, &link);
}
- if (xbt_dynar_compare(TO_ROUTE_FULL(*src_id, *dst_id)->link_list,
+ if (xbt_dynar_compare(TO_ROUTE_FULL(src_net_elm->id, dst_net_elm->id)->link_list,
link_route_to_test, full_pointer_resource_cmp)) {
surf_parse_error("A route between \"%s\" and \"%s\" already exists "
"with a different content. "
// route->dst_gateway, subas->name);
XBT_DEBUG("Load ASroute from \"%s(%s)\" to \"%s(%s)\"",
- src, route->src_gateway, dst, route->dst_gateway);
- if (routing_get_network_element_type(route->dst_gateway) ==
- SURF_NETWORK_ELEMENT_NULL)
- xbt_die("The dst_gateway '%s' does not exist!", route->dst_gateway);
- if (routing_get_network_element_type(route->src_gateway) ==
- SURF_NETWORK_ELEMENT_NULL)
- xbt_die("The src_gateway '%s' does not exist!", route->src_gateway);
+ src, route->src_gateway->name, dst, route->dst_gateway->name);
+ if (route->dst_gateway->rc_type == SURF_NETWORK_ELEMENT_NULL)
+ xbt_die("The dst_gateway '%s' does not exist!", route->dst_gateway->name);
+ if (route->src_gateway->rc_type == SURF_NETWORK_ELEMENT_NULL)
+ xbt_die("The src_gateway '%s' does not exist!", route->src_gateway->name);
}
- TO_ROUTE_FULL(*src_id, *dst_id) =
+ TO_ROUTE_FULL(src_net_elm->id, dst_net_elm->id) =
generic_new_extended_route(rc->hierarchy, route, 1);
- xbt_dynar_shrink(TO_ROUTE_FULL(*src_id, *dst_id)->link_list, 0);
+ xbt_dynar_shrink(TO_ROUTE_FULL(src_net_elm->id, dst_net_elm->id)->link_list, 0);
}
if (A_surfxml_route_symmetrical == A_surfxml_route_symmetrical_YES
|| A_surfxml_ASroute_symmetrical == A_surfxml_ASroute_symmetrical_YES) {
if (route->dst_gateway && route->src_gateway) {
- char *gw_tmp;
+ network_element_t gw_tmp;
gw_tmp = route->src_gateway;
route->src_gateway = route->dst_gateway;
route->dst_gateway = gw_tmp;
}
- if (TO_ROUTE_FULL(*dst_id, *src_id)) {
+ if (TO_ROUTE_FULL(dst_net_elm->id, src_net_elm->id)) {
char *link_name;
unsigned int i;
xbt_dynar_t link_route_to_test =
xbt_assert(link, "Link : '%s' doesn't exists.", link_name);
xbt_dynar_push(link_route_to_test, &link);
}
- xbt_assert(!xbt_dynar_compare(TO_ROUTE_FULL(*dst_id, *src_id)->link_list,
+ xbt_assert(!xbt_dynar_compare(TO_ROUTE_FULL(dst_net_elm->id, src_net_elm->id)->link_list,
link_route_to_test,
full_pointer_resource_cmp),
"The route between \"%s\" and \"%s\" already exists", src,
XBT_DEBUG("Load Route from \"%s\" to \"%s\"", dst, src);
else
XBT_DEBUG("Load ASroute from \"%s(%s)\" to \"%s(%s)\"",
- dst, route->src_gateway, src, route->dst_gateway);
- TO_ROUTE_FULL(*dst_id, *src_id) =
+ dst, route->src_gateway->name, src, route->dst_gateway->name);
+ TO_ROUTE_FULL(dst_net_elm->id, src_net_elm->id) =
generic_new_extended_route(rc->hierarchy, route, 0);
- xbt_dynar_shrink(TO_ROUTE_FULL(*dst_id, *src_id)->link_list, 0);
+ xbt_dynar_shrink(TO_ROUTE_FULL(dst_net_elm->id, src_net_elm->id)->link_list, 0);
}
}
}
generic_get_bypassroute;
new_component->finalize = model_generic_finalize;
- new_component->to_index = xbt_dict_new_homogeneous(xbt_free);
+ new_component->nb_index = 0;
new_component->bypassRoutes = xbt_dict_new_homogeneous((void (*)(void *)) generic_free_route);
return new_component;
}
void model_generic_finalize(AS_t as) {
- xbt_dict_free(&as->to_index);
xbt_dict_free(&as->bypassRoutes);
model_none_finalize(as);
}
-void generic_parse_PU(AS_t as, const char *name)
+int generic_parse_PU(AS_t as, const char *name)
{
XBT_DEBUG("Load process unit \"%s\"", name);
- int *id = xbt_new0(int, 1);
- xbt_dict_t _to_index;
- _to_index = as->to_index;
- *id = xbt_dict_length(_to_index);
- xbt_dict_set(_to_index, name, id, NULL);
+ int id = as->nb_index;
+ (as->nb_index)++;
+ return id;
}
-void generic_parse_AS(AS_t as, const char *name)
+int generic_parse_AS(AS_t as, const char *name)
{
XBT_DEBUG("Load Autonomous system \"%s\"", name);
- int *id = xbt_new0(int, 1);
- xbt_dict_t _to_index;
- _to_index = as->to_index;
- *id = xbt_dict_length(_to_index);
- xbt_dict_set(_to_index, name, id, NULL);
+ int id = as->nb_index;
+ as->nb_index++;
+ return id;
}
void generic_parse_bypassroute(AS_t rc,
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);
+ src, e_route->src_gateway->name, dst, e_route->dst_gateway->name);
route_t new_e_route =
generic_new_extended_route(SURF_ROUTING_RECURSIVE, e_route, 0);
return NULL;
}
-route_t generic_get_bypassroute(AS_t rc, const char *src, const char *dst)
+route_t generic_get_bypassroute(AS_t rc, network_element_t src, network_element_t dst)
{
// If never set a bypass route return NULL without any further computations
if(no_bypassroute_declared)
AS_t *current_src = NULL;
AS_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);
+ char* src_name = src->name;
+ char* dst_name = dst->name;
- if (src_data == NULL || dst_data == NULL)
+ if (src == NULL || dst == NULL)
xbt_die("Ask for route \"from\"(%s) or \"to\"(%s) no found at AS \"%s\"",
- src, dst, rc->name);
+ src_name, dst_name, rc->name);
- src_as = ((network_element_info_t) src_data)->rc_component;
- dst_as = ((network_element_info_t) dst_data)->rc_component;
+ src_as = src->rc_component;
+ dst_as = dst->rc_component;
/* (2) find the path to the root routing component */
path_src = xbt_dynar_new(sizeof(AS_t), NULL);
void *link;
unsigned int cpt = 0;
new_e_route = xbt_new0(s_route_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->src_gateway = e_route_bypass->src_gateway;
+ new_e_route->dst_gateway = e_route_bypass->dst_gateway;
new_e_route->link_list =
xbt_dynar_new(global_routing->size_of_link, NULL);
xbt_dynar_foreach(e_route_bypass->link_list, cpt, link) {
links = e_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);
+ new_e_route->src_gateway = e_route->src_gateway;
+ new_e_route->dst_gateway = e_route->dst_gateway;
}
links_id = new_e_route->link_list;
{
if (route) {
xbt_dynar_free(&route->link_list);
- xbt_free(route->src_gateway);
- xbt_free(route->dst_gateway);
xbt_free(route);
}
}
AS_t element_as, result, elem;
xbt_dict_cursor_t cursor = NULL;
char *key;
- element_as = ((network_element_info_t)
+ element_as = ((network_element_t)
xbt_lib_get_or_null(as_router_lib, element,
ROUTING_ASR_LEVEL))->rc_component;
result = ((AS_t) - 1);
generic_processing_units_exist(AS_t rc, char *element)
{
AS_t element_as;
- element_as = ((network_element_info_t)
+ element_as = ((network_element_t)
xbt_lib_get_or_null(host_lib,
element, ROUTING_HOST_LEVEL))->rc_component;
if (element_as == rc)
return generic_as_exist(rc, element_as);
}
-void generic_src_dst_check(AS_t rc, const char *src,
- const char *dst)
+void generic_src_dst_check(AS_t rc, network_element_t src,
+ network_element_t dst)
{
- 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);
+ network_element_t src_data = src;
+ network_element_t dst_data = dst;
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->name,
+ dst->name,
+ rc->name);
AS_t src_as =
- ((network_element_info_t) src_data)->rc_component;
+ (src_data)->rc_component;
AS_t dst_as =
- ((network_element_info_t) dst_data)->rc_component;
+ (dst_data)->rc_component;
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);
+ src->name, src_as->name,
+ dst->name, 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);
+ src->name,
+ dst->name,
+ src_as->name,
+ dst_as->name,
+ rc->name);
}
return NULL;
}
-static void none_get_route_and_latency(AS_t rc, const char *src, const char *dst,
+static void none_get_route_and_latency(AS_t rc, network_element_t src, network_element_t dst,
route_t res,double *lat)
{
}
static route_t none_get_bypass_route(AS_t rc,
- const char *src,
- const char *dst) {
+ network_element_t src,
+ network_element_t dst) {
return NULL;
}
-static void none_parse_PU(AS_t rc, const char *name) {
+static int none_parse_PU(AS_t rc, const char *name) {
/* don't care about PUs */
+ return -1;
}
-static void none_parse_AS(AS_t rc, const char *name) {
+static int none_parse_AS(AS_t rc, const char *name) {
/* even don't care about sub-ASes -- I'm as nihilist as an old punk*/
+ return -1;
}
/* Creation routing model functions */
AS_t model_generic_create_sized(size_t childsize);
void model_generic_finalize(AS_t as);
-void generic_parse_PU(AS_t rc, const char *name);
-void generic_parse_AS(AS_t rc, const char *name);
+int generic_parse_PU(AS_t rc, const char *name);
+int generic_parse_AS(AS_t rc, const char *name);
void generic_parse_bypassroute(AS_t rc, const char *src, const char *dst,
route_t e_route);
xbt_dynar_t generic_get_onelink_routes(AS_t rc);
route_t generic_get_bypassroute(AS_t rc,
- const char *src,
- const char *dst);
+ network_element_t src,
+ network_element_t dst);
/* ************************************************************************** */
/* ****************** GENERIC AUX FUNCTIONS (declarations) ****************** */
generic_autonomous_system_exist(AS_t rc, char *element);
AS_t
generic_processing_units_exist(AS_t rc, char *element);
-void generic_src_dst_check(AS_t rc, const char *src,
- const char *dst);
+void generic_src_dst_check(AS_t rc, network_element_t src,
+ network_element_t dst);
/* ************************************************************************** */
typedef struct {
s_as_t generic_routing;
- xbt_dict_t dict_processing_units;
- xbt_dict_t dict_autonomous_systems;
+ int nb_processing_units;
+ int nb_autonomous_systems;
xbt_dynar_t list_route;
xbt_dynar_t list_ASroute;
} s_AS_rulebased_t, *AS_rulebased_t;
/* Parse routing model functions */
-static void model_rulebased_parse_PU(AS_t rc, const char *name)
+static int model_rulebased_parse_PU(AS_t rc, const char *name)
{
AS_rulebased_t routing = (AS_rulebased_t) rc;
- xbt_dict_set(routing->dict_processing_units, name, (void *) (-1), NULL);
+ routing->nb_processing_units++;
+ return -1;
}
-static void model_rulebased_parse_AS(AS_t rc, const char *name)
+static int model_rulebased_parse_AS(AS_t rc, const char *name)
{
AS_rulebased_t routing = (AS_rulebased_t) rc;
- xbt_dict_set(routing->dict_autonomous_systems, name, (void *) (-1), NULL);
+ routing->nb_autonomous_systems++;
+ return -1;
}
static void model_rulebased_parse_route(AS_t rc,
erroffset, dst, error);
ruleroute_e->generic_rule_route.re_str_link =
route->link_list;
- ruleroute_e->re_src_gateway = route->src_gateway;
- ruleroute_e->re_dst_gateway = route->dst_gateway;
+ ruleroute_e->re_src_gateway = xbt_strdup((char *)route->src_gateway); // DIRTY HACK possible only
+ ruleroute_e->re_dst_gateway = xbt_strdup((char *)route->dst_gateway); // because of what is in routing_parse_E_ASroute
xbt_dynar_push(routing->list_ASroute, &ruleroute_e);
/* make sure that they don't get freed */
}
static void rulebased_get_route_and_latency(AS_t rc,
- const char *src, const char *dst,
+ network_element_t src, network_element_t dst,
route_t res,double*lat);
static xbt_dynar_t rulebased_get_onelink_routes(AS_t rc)
{
xbt_dynar_t ret = xbt_dynar_new (sizeof(onelink_t), xbt_free);
-
- //We have already bypass cluster routes with network NS3
- if(!strcmp(surf_network_model->name,"network NS3"))
- return ret;
-
- AS_rulebased_t routing = (AS_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 (routing_get_network_element_type(k1) == SURF_NETWORK_ELEMENT_ROUTER){
- router = k1;
- break;
- }
- }
-
- 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_t route = xbt_new0(s_route_t,1);
- route->link_list = xbt_dynar_new(global_routing->size_of_link,NULL);
- rulebased_get_route_and_latency (rc, router, k1, route,NULL);
-
- int number_of_links = xbt_dynar_length(route->link_list);
-
- if(number_of_links == 1) {
- //loopback
- }
- else{
- if (number_of_links != 2) {
- xbt_die ("rulebased_get_onelink_routes works only if the AS is a cluster, sorry.");
- }
-
- void *link_ptr;
- xbt_dynar_get_cpy (route->link_list, 1, &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);
- }
- }
+ THROW_UNIMPLEMENTED;
+// //We have already bypass cluster routes with network NS3
+// if(!strcmp(surf_network_model->name,"network NS3"))
+// return ret;
+//
+// AS_rulebased_t routing = (AS_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 (routing_get_network_element_type(k1) == SURF_NETWORK_ELEMENT_ROUTER){
+// router = k1;
+// break;
+// }
+// }
+//
+// 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_t route = xbt_new0(s_route_t,1);
+// route->link_list = xbt_dynar_new(global_routing->size_of_link,NULL);
+// rulebased_get_route_and_latency (rc, router, k1, route,NULL);
+//
+// int number_of_links = xbt_dynar_length(route->link_list);
+//
+// if(number_of_links == 1) {
+// //loopback
+// }
+// else{
+// if (number_of_links != 2) {
+// xbt_die ("rulebased_get_onelink_routes works only if the AS is a cluster, sorry.");
+// }
+//
+// void *link_ptr;
+// xbt_dynar_get_cpy (route->link_list, 1, &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 void rulebased_get_route_and_latency(AS_t rc,
- const char *src, const char *dst,
+ network_element_t src, network_element_t dst,
route_t route, double *lat)
{
+ XBT_DEBUG("rulebased_get_route_and_latency from '%s' to '%s'",src->name,dst->name);
xbt_assert(rc && src
&& dst,
"Invalid params for \"get_route\" function at AS \"%s\"",
/* set utils vars */
AS_rulebased_t routing = (AS_rulebased_t) rc;
+ char* src_name = src->name;
+ char* dst_name = dst->name;
+
int are_processing_units=0;
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)) {
+ if ((src->rc_type == SURF_NETWORK_ELEMENT_HOST || src->rc_type == SURF_NETWORK_ELEMENT_ROUTER)&&
+ (dst->rc_type == SURF_NETWORK_ELEMENT_HOST || dst->rc_type == SURF_NETWORK_ELEMENT_ROUTER)){
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)) {
+ } else if (src->rc_type == SURF_NETWORK_ELEMENT_AS && dst->rc_type == SURF_NETWORK_ELEMENT_AS) {
are_processing_units = 0;
rule_list = routing->list_ASroute;
} else
- THROWF(arg_error,0,"No route from '%s' to '%s'",src,dst);
+ THROWF(arg_error,0,"No route from '%s' to '%s'",src_name,dst_name);
int rc_src = -1;
int rc_dst = -1;
- int src_length = (int) strlen(src);
- int dst_length = (int) strlen(dst);
+ int src_length = (int) strlen(src_name);
+ int dst_length = (int) strlen(dst_name);
rule_route_t ruleroute;
unsigned int cpt;
_XBT_GNUC_UNUSED int res;
xbt_dynar_foreach(rule_list, cpt, ruleroute) {
rc_src =
- pcre_exec(ruleroute->re_src, NULL, src, src_length, 0, 0,
+ pcre_exec(ruleroute->re_src, NULL, src_name, src_length, 0, 0,
ovector_src, OVECCOUNT);
if (rc_src >= 0) {
rc_dst =
- pcre_exec(ruleroute->re_dst, NULL, dst, dst_length, 0, 0,
+ pcre_exec(ruleroute->re_dst, NULL, dst_name, dst_length, 0, 0,
ovector_dst, OVECCOUNT);
if (rc_dst >= 0) {
- res = pcre_get_substring_list(src, ovector_src, rc_src, &list_src);
- xbt_assert(!res, "error solving substring list for src \"%s\"", src);
- res = pcre_get_substring_list(dst, ovector_dst, rc_dst, &list_dst);
- xbt_assert(!res, "error solving substring list for src \"%s\"", dst);
+ res = pcre_get_substring_list(src_name, ovector_src, rc_src, &list_src);
+ xbt_assert(!res, "error solving substring list for src \"%s\"", src_name);
+ res = pcre_get_substring_list(dst_name, ovector_dst, rc_dst, &list_dst);
+ xbt_assert(!res, "error solving substring list for dst \"%s\"", dst_name);
char *link_name;
xbt_dynar_foreach(ruleroute->re_str_link, cpt, link_name) {
char *new_link_name =
if (rc_src >= 0 && rc_dst >= 0) {
/* matched src and dest, nothing more to do (?) */
- } else if (!strcmp(src, dst) && are_processing_units) {
+ } else if (!strcmp(src_name, dst_name) && are_processing_units) {
xbt_dynar_push(route->link_list, &(global_routing->loopback));
if (lat)
*lat += surf_network_model->extension.network.get_link_latency(global_routing->loopback);
} else {
- THROWF(arg_error,0,"No route from '%s' to '%s'??",src,dst);
+ THROWF(arg_error,0,"No route from '%s' to '%s'??",src_name,dst_name);
//xbt_dynar_reset(route->link_list);
}
if (!are_processing_units && !xbt_dynar_is_empty(route->link_list)) {
rule_route_extended_t ruleroute_extended =
(rule_route_extended_t) ruleroute;
- route->src_gateway =
- remplace(ruleroute_extended->re_src_gateway, list_src, rc_src,
- list_dst, rc_dst);
- route->dst_gateway =
- remplace(ruleroute_extended->re_dst_gateway, list_src, rc_src,
- list_dst, rc_dst);
+ char *gw_src_name = remplace(ruleroute_extended->re_src_gateway, list_src, rc_src,
+ list_dst, rc_dst);
+ route->src_gateway = (network_element_t)xbt_lib_get_or_null(host_lib, gw_src_name, ROUTING_HOST_LEVEL);
+ route->src_gateway = (network_element_t)xbt_lib_get_or_null(host_lib, gw_src_name, ROUTING_HOST_LEVEL);
+ if(!route->src_gateway)
+ route->src_gateway = (network_element_t)xbt_lib_get_or_null(as_router_lib, gw_src_name, ROUTING_ASR_LEVEL);
+ if(!route->src_gateway)
+ route->src_gateway = (network_element_t)xbt_lib_get_or_null(as_router_lib, gw_src_name, ROUTING_ASR_LEVEL);
+
+ char *gw_dst_name = remplace(ruleroute_extended->re_dst_gateway, list_src, rc_src,
+ list_dst, rc_dst);
+ route->dst_gateway = (network_element_t)xbt_lib_get_or_null(host_lib, gw_dst_name, ROUTING_HOST_LEVEL);
+ route->dst_gateway = (network_element_t)xbt_lib_get_or_null(host_lib, gw_dst_name, ROUTING_HOST_LEVEL);
+ if(!route->dst_gateway)
+ route->dst_gateway = (network_element_t)xbt_lib_get_or_null(as_router_lib, gw_dst_name, ROUTING_ASR_LEVEL);
+ if(!route->dst_gateway)
+ route->dst_gateway = (network_element_t)xbt_lib_get_or_null(as_router_lib, gw_dst_name, ROUTING_ASR_LEVEL);
}
if (list_src)
pcre_free_substring_list(list_dst);
}
-static route_t rulebased_get_bypass_route(AS_t rc, const char *src, const char *dst) {
+static route_t rulebased_get_bypass_route(AS_t rc, network_element_t src, network_element_t dst) {
return NULL;
}
AS_rulebased_t routing =
(AS_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);
-
model_generic_finalize(rc);
}
}
new_component->generic_routing.get_bypass_route = rulebased_get_bypass_route;
new_component->generic_routing.finalize = rulebased_finalize;
/* initialization of internal structures */
- new_component->dict_processing_units = xbt_dict_new_homogeneous(NULL);
- new_component->dict_autonomous_systems = xbt_dict_new_homogeneous(NULL);
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),
}
static void vivaldi_get_route_and_latency(
- AS_t rc, const char *src_p, const char *dst_p,
+ AS_t rc, network_element_t src_p, network_element_t dst_p,
route_t route, double *lat)
{
- char *src = (char*)src_p;
- char *dst = (char*)dst_p;
+ XBT_DEBUG("vivaldi_get_route_and_latency from '%s'[%d] '%s'[%d]",src_p->name,src_p->id,dst_p->name,dst_p->id);
+ char *src = (char*)src_p->name;
+ char *dst = (char*)dst_p->name;
if(routing_get_network_element_type(src) == SURF_NETWORK_ELEMENT_AS) {
- src = route->src_gateway = ROUTER_PEER(src);
- dst = route->dst_gateway = ROUTER_PEER(dst);
+ route->src_gateway = xbt_lib_get_or_null(as_router_lib,ROUTER_PEER(src),ROUTING_ASR_LEVEL);
+ route->dst_gateway = xbt_lib_get_or_null(as_router_lib,ROUTER_PEER(dst),ROUTING_ASR_LEVEL);
}
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);
+ char *tmp_src_name, *tmp_dst_name;
- xbt_assert(src_ctn,"No coordinate found for element '%s'",src);
- xbt_assert(dst_ctn,"No coordinate found for element '%s'",dst);
+ if(src_p->rc_type == SURF_NETWORK_ELEMENT_HOST){
+ tmp_src_name = HOST_PEER(src);
+ src_ctn = xbt_lib_get_or_null(host_lib, tmp_src_name, COORD_HOST_LEVEL);
+ if(!src_ctn ) src_ctn = xbt_lib_get_or_null(host_lib, src, COORD_HOST_LEVEL);
+ }
+ else if(src_p->rc_type == SURF_NETWORK_ELEMENT_ROUTER || src_p->rc_type == SURF_NETWORK_ELEMENT_AS){
+ tmp_src_name = ROUTER_PEER(src);
+ src_ctn = xbt_lib_get_or_null(as_router_lib, tmp_src_name, COORD_ASR_LEVEL);
+ }
+ else{
+ xbt_die(" ");
+ }
+
+ if(dst_p->rc_type == SURF_NETWORK_ELEMENT_HOST){
+ tmp_dst_name = HOST_PEER(dst);
+ dst_ctn = xbt_lib_get_or_null(host_lib, tmp_dst_name, COORD_HOST_LEVEL);
+ if(!dst_ctn ) dst_ctn = xbt_lib_get_or_null(host_lib, dst, COORD_HOST_LEVEL);
+ }
+ else if(dst_p->rc_type == SURF_NETWORK_ELEMENT_ROUTER || dst_p->rc_type == SURF_NETWORK_ELEMENT_AS){
+ tmp_dst_name = ROUTER_PEER(dst);
+ dst_ctn = xbt_lib_get_or_null(as_router_lib, tmp_dst_name, COORD_ASR_LEVEL);
+ }
+ else{
+ xbt_die(" ");
+ }
+
+ xbt_assert(src_ctn,"No coordinate found for element '%s'",tmp_src_name);
+ xbt_assert(dst_ctn,"No coordinate found for element '%s'",tmp_dst_name);
+ free(tmp_src_name);
+ free(tmp_dst_name);
euclidean_dist = sqrt (euclidean_dist_comp(0,src_ctn,dst_ctn)+euclidean_dist_comp(1,src_ctn,dst_ctn))
- + fabs(xbt_dynar_get_as(src_ctn, 2, double))+fabs(xbt_dynar_get_as(dst_ctn, 2, double));
+ + fabs(xbt_dynar_get_as(src_ctn, 2, double))+fabs(xbt_dynar_get_as(dst_ctn, 2, double));
if (lat)
*lat += euclidean_dist / 1000; //From .ms to .s
-
}
typedef struct workstation_CLM03 {
s_surf_resource_t generic_resource; /* Must remain first to add this to a trace */
void *cpu;
- void *net_card;
+ void *net_elm;
xbt_dynar_t storage;
} s_workstation_CLM03_t, *workstation_CLM03_t;
workstation->generic_resource.name = xbt_strdup(host->id);
workstation->cpu = xbt_lib_get_or_null(host_lib, host->id, SURF_CPU_LEVEL);
workstation->storage = xbt_lib_get_or_null(storage_lib,host->id,ROUTING_STORAGE_HOST_LEVEL);
+ workstation->net_elm = xbt_lib_get_or_null(host_lib,host->id,ROUTING_HOST_LEVEL);
XBT_DEBUG("Create workstation %s with %ld mounted disks",host->id,xbt_dynar_length(workstation->storage));
xbt_lib_set(host_lib, host->id, SURF_WKS_LEVEL, workstation);
}
workstation_CLM03_t src = (workstation_CLM03_t) workstation_src;
workstation_CLM03_t dst = (workstation_CLM03_t) workstation_dst;
return surf_network_model->extension.network.
- communicate(surf_resource_name(src->cpu),
- surf_resource_name(dst->cpu), size, rate);
+ communicate(src->net_elm,
+ dst->net_elm, size, rate);
}
static e_surf_resource_state_t ws_get_state(void *workstation)
/* returns an array of network_link_CM02_t */
-static xbt_dynar_t ws_get_route(void *src, void *dst)
+static xbt_dynar_t ws_get_route(void *workstation_src, void *workstation_dst)
{
+ XBT_INFO("ws_get_route");
+ workstation_CLM03_t src = (workstation_CLM03_t) workstation_src;
+ workstation_CLM03_t dst = (workstation_CLM03_t) workstation_dst;
return surf_network_model->extension.
- network.get_route(surf_resource_name(src), surf_resource_name(dst));
+ network.get_route(src->net_elm,
+ dst->net_elm);
}
static double ws_get_link_bandwidth(const void *link)
tmgr_trace_event_t power_event;
tmgr_trace_event_t state_event;
e_surf_resource_state_t state_current;
- int id; /* cpu and network card are a single object... */
+ network_element_t info;
} s_cpu_L07_t, *cpu_L07_t;
/**************************************/
static xbt_dict_t ptask_parallel_task_link_set = NULL;
lmm_system_t ptask_maxmin_system = NULL;
-static surf_action_t die_impossible_communicate (const char *src_name, const char *dst_name, double size, double rate)
+static surf_action_t die_impossible_communicate (void *src, void *dst, double size, double rate)
{
DIE_IMPOSSIBLE;
return NULL;
}
-static xbt_dynar_t die_impossible_get_route(const char *src_name, const char *dst_name)
+static xbt_dynar_t die_impossible_get_route(void *src, void *dst)
{
DIE_IMPOSSIBLE;
return NULL;
if (action->communication_amount[i * workstation_nb + j] > 0) {
double lat = 0.0;
- routing_get_route_and_latency(surf_resource_name
- (action->workstation_list[i]),
- surf_resource_name(action->workstation_list[j]),
+ routing_get_route_and_latency(action->workstation_list[i]->info,
+ action->workstation_list[j]->info,
&route, &lat);
lat_current =
MAX(lat_current,
link_L07_t link;
routing_get_route_and_latency(
- surf_resource_name(workstation_list[i]),
- surf_resource_name(workstation_list[j]),
+ ((cpu_L07_t)workstation_list[i])->info,
+ ((cpu_L07_t)workstation_list[j])->info,
&route,&lat);
latency = MAX(latency, lat);
continue;
routing_get_route_and_latency(
- surf_resource_name(workstation_list[i]),
- surf_resource_name(workstation_list[j]),
+ ((cpu_L07_t)workstation_list[i])->info,
+ ((cpu_L07_t)workstation_list[j])->info,
&route,NULL);
xbt_dynar_foreach(route, cpt, link) {
{
xbt_dynar_t route=NULL;
routing_get_route_and_latency(
- surf_resource_name(src), surf_resource_name(dst),
+ ((cpu_L07_t)src)->info, ((cpu_L07_t)dst)->info,
&route,NULL);
return route;
}
surf_workstation_model, name,cpu_properties);
cpu->type = SURF_WORKSTATION_RESOURCE_CPU;
- cpu->id = ptask_host_count++;
+ cpu->info = (network_element_t)xbt_lib_get_or_null(host_lib,name,ROUTING_HOST_LEVEL);
+ if(!(cpu->info)) xbt_die("Don't find ROUTING_HOST_LEVEL for '%s'",name);
cpu->power_scale = power_scale;
xbt_assert(cpu->power_scale > 0, "Power has to be >0");
xbt_lib_cursor_t cursor_src = NULL;
xbt_lib_cursor_t cursor_dst = NULL;
char *src,*dst,*key,*data;
- char **value;
+ network_element_t value1;
+ network_element_t value2;
xbt_ex_t e;
const SD_workstation_t *hosts;
}
// Routers
- xbt_lib_foreach(as_router_lib, cursor_src, key, value) {
- if(((network_element_info_t)xbt_lib_get_or_null(as_router_lib, key,
+ xbt_lib_foreach(as_router_lib, cursor_src, key, value1) {
+ if(((network_element_t)xbt_lib_get_or_null(as_router_lib, key,
ROUTING_ASR_LEVEL))->rc_type == SURF_NETWORK_ELEMENT_ROUTER)
{
printf(" <router id=\"%s\"/>\n",key);
}
- xbt_lib_foreach(host_lib, cursor_src, src, value) // Routes from host
+ xbt_lib_foreach(host_lib, cursor_src, src, value1) // Routes from host
{
- xbt_lib_foreach(host_lib, cursor_dst, dst, value) //to host
+ value1 = xbt_lib_get_or_null(host_lib,src,ROUTING_HOST_LEVEL);
+ xbt_lib_foreach(host_lib, cursor_dst, dst, value2) //to host
{
printf(" <route src=\"%s\" dst=\"%s\">\n "
,src
,dst);
xbt_dynar_t route=NULL;
- routing_get_route_and_latency(src,dst,&route,NULL);
+ value2 = xbt_lib_get_or_null(host_lib,dst,ROUTING_HOST_LEVEL);
+ routing_get_route_and_latency(value1,value2,&route,NULL);
for(i=0;i<xbt_dynar_length(route) ;i++)
{
void *link = xbt_dynar_get_as(route,i,void *);
}
printf("\n </route>\n");
}
- xbt_lib_foreach(as_router_lib, cursor_dst, dst, value) //to router
+ xbt_lib_foreach(as_router_lib, cursor_dst, dst, value2) //to router
{
if(routing_get_network_element_type(dst) == SURF_NETWORK_ELEMENT_ROUTER){
printf(" <route src=\"%s\" dst=\"%s\">\n "
,src
,dst);
xbt_dynar_t route=NULL;
- routing_get_route_and_latency(src,dst,&route,NULL);
+ value2 = xbt_lib_get_or_null(as_router_lib,dst,ROUTING_ASR_LEVEL);
+ routing_get_route_and_latency((network_element_t)value1,(network_element_t)value2,&route,NULL);
for(i=0;i<xbt_dynar_length(route) ;i++)
{
void *link = xbt_dynar_get_as(route,i,void *);
}
}
- xbt_lib_foreach(as_router_lib, cursor_src, src, value) // Routes from router
+ xbt_lib_foreach(as_router_lib, cursor_src, src, value1) // Routes from router
{
+ value1 = xbt_lib_get_or_null(as_router_lib,src,ROUTING_ASR_LEVEL);
if(routing_get_network_element_type(src) == SURF_NETWORK_ELEMENT_ROUTER){
- xbt_lib_foreach(as_router_lib, cursor_dst, dst, value) //to router
+ xbt_lib_foreach(as_router_lib, cursor_dst, dst, value2) //to router
{
if(routing_get_network_element_type(dst) == SURF_NETWORK_ELEMENT_ROUTER){
printf(" <route src=\"%s\" dst=\"%s\">\n "
,src
,dst);
xbt_dynar_t route=NULL;
- routing_get_route_and_latency(src,dst,&route,NULL);
+ value2 = xbt_lib_get_or_null(as_router_lib,dst,ROUTING_ASR_LEVEL);
+ routing_get_route_and_latency((network_element_t)value1,(network_element_t)value2,&route,NULL);
for(i=0;i<xbt_dynar_length(route) ;i++)
{
void *link = xbt_dynar_get_as(route,i,void *);
printf("\n </route>\n");
}
}
- xbt_lib_foreach(host_lib, cursor_dst, dst, value) //to host
+ xbt_lib_foreach(host_lib, cursor_dst, dst, value2) //to host
{
printf(" <route src=\"%s\" dst=\"%s\">\n "
,src, dst);
xbt_dynar_t route=NULL;
- routing_get_route_and_latency(src,dst,&route, NULL);
+ value2 = xbt_lib_get_or_null(host_lib,dst,ROUTING_HOST_LEVEL);
+ routing_get_route_and_latency((network_element_t)value1,(network_element_t)value2,&route, NULL);
for(i=0;i<xbt_dynar_length(route) ;i++)
{
void *link = xbt_dynar_get_as(route,i,void *);
XBT_DEBUG("%s : %p", surf_resource_name(cardB), cardB);
/* Let's do something on it */
- surf_network_model->extension.network.communicate("Cpu A", "Cpu B",
+ surf_network_model->extension.network.communicate(cpuA, cpuB,
150.0, -1.0);
surf_solve(-1.0); /* Takes traces into account. Returns 0.0 */