static xbt_dict_t random_value = NULL;
-xbt_lib_t storage_lib;
-int ROUTING_STORAGE_LEVEL; //Routing for storagelevel
-int ROUTING_STORAGE_HOST_LEVEL;
-int SURF_STORAGE_LEVEL;
-
-xbt_lib_t storage_type_lib;
-int ROUTING_STORAGE_TYPE_LEVEL; //Routing for storage_type level
-
/* Global vars */
routing_global_t global_routing = NULL;
AS_t current_routing = NULL;
/* global parse functions */
xbt_dynar_t parsed_link_list = NULL; /* temporary store of current list link of a route */
-xbt_dynar_t mount_list = NULL; /* temporary store of current mount storage */
+extern xbt_dynar_t mount_list;
+
static const char *src = NULL; /* temporary store the source name of a route */
static const char *dst = NULL; /* temporary store the destination name of a route */
static char *gw_src = NULL; /* temporary store the gateway source name of a route */
{"DijkstraCache",
"Dijkstra routing data (fast initialization, fast lookup, small memory requirements, shortest path routing only)",
model_dijkstracache_create, model_dijkstra_both_end},
- {"none", "No routing (usable with Constant network only)",
+ {"none", "No routing (Unless you know what you are doing, avoid using this mode in combination with a non Constant network model).",
model_none_create, NULL},
{"RuleBased", "Rule-Based routing data (...)",
model_rulebased_create, NULL},
route_t e_route = xbt_new0(s_route_t, 1);
e_route->link_list = parsed_link_list;
- if(!strcmp(current_routing->model_desc->name,"RuleBased")) {
+ 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));
+ } else {
+ e_route->src_gateway = xbt_lib_get_or_null(as_router_lib, gw_src,
+ ROUTING_ASR_LEVEL);
+ if (!e_route->src_gateway)
+ e_route->src_gateway = xbt_lib_get_or_null(host_lib, gw_src,
+ ROUTING_HOST_LEVEL);
+ e_route->dst_gateway = xbt_lib_get_or_null(as_router_lib, gw_dst,
+ ROUTING_ASR_LEVEL);
+ if (!e_route->dst_gateway)
+ e_route->dst_gateway = 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\"",
{
route_t e_route = xbt_new0(s_route_t, 1);
e_route->link_list = parsed_link_list;
- 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));
+ e_route->src_gateway = xbt_lib_get_or_null(as_router_lib, gw_src,
+ ROUTING_ASR_LEVEL);
+ if (!e_route->src_gateway)
+ e_route->src_gateway = xbt_lib_get_or_null(host_lib, gw_src,
+ ROUTING_HOST_LEVEL);
+ e_route->dst_gateway = xbt_lib_get_or_null(as_router_lib, gw_dst,
+ ROUTING_ASR_LEVEL);
+ if (!e_route->dst_gateway)
+ e_route->dst_gateway = 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);
network_element_t dst_data = dst;
src_as = src_data->rc_component;
dst_as = dst_data->rc_component;
+#ifndef NDEBUG
char* src_name = src_data->name;
char* dst_name = dst_data->name;
+#endif
xbt_assert(src_as && dst_as,
"Ask for route \"from\"(%s) or \"to\"(%s) no found", src_name, dst_name);
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->name, src_gateway_net_elm->name))
+ if (src != src_gateway_net_elm)
_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_net_elm->name, dst->name)) {
+ if (dst_gateway_net_elm != dst) {
_get_route_and_latency(dst_gateway_net_elm, dst, links, latency);
}
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(network_element_t src, network_element_t dst,
+void routing_get_route_and_latency(network_element_t src,
+ network_element_t dst,
xbt_dynar_t * route, double *latency)
{
if (!*route) {
/* ************************************************************************** */
/* ************************* GENERIC PARSE FUNCTIONS ************************ */
-static void routing_parse_storage(sg_platf_storage_cbarg_t storage)
-{
- xbt_assert(!xbt_lib_get_or_null(storage_lib, storage->id,ROUTING_STORAGE_LEVEL),
- "Reading a storage, processing unit \"%s\" already exists", storage->id);
-
- // Verification of an existing type_id
- void* storage_type = xbt_lib_get_or_null(storage_type_lib, storage->type_id,ROUTING_STORAGE_TYPE_LEVEL);
- xbt_assert(storage_type,"Reading a storage, type id \"%s\" does not exists", storage->type_id);
-
- XBT_DEBUG("ROUTING Create a storage name '%s' with type_id '%s'",
- storage->id,
- storage->type_id);
-
- xbt_lib_set(storage_lib,
- storage->id,
- ROUTING_STORAGE_LEVEL,
- (void *) xbt_strdup(storage->type_id));
-}
-static void routing_parse_storage_type(sg_platf_storage_type_cbarg_t storage_type)
-{
- xbt_assert(!xbt_lib_get_or_null(storage_type_lib, storage_type->id,ROUTING_STORAGE_TYPE_LEVEL),
- "Reading a storage type, processing unit \"%s\" already exists", storage_type->id);
-
- storage_type_t stype = xbt_new0(s_storage_type_t, 1);
- stype->model = xbt_strdup(storage_type->model);
- stype->properties = storage_type->properties;
- stype->content = xbt_strdup(storage_type->content);
- stype->type_id = xbt_strdup(storage_type->id);
-
- XBT_DEBUG("ROUTING Create a storage type id '%s' with model '%s' content '%s' and properties '%p'",
- stype->type_id,
- stype->model,
- stype->content,
- stype->properties);
-
- xbt_lib_set(storage_type_lib,
- stype->type_id,
- ROUTING_STORAGE_TYPE_LEVEL,
- (void *) stype);
-}
-static void routing_parse_mstorage(sg_platf_mstorage_cbarg_t mstorage)
-{
- THROW_UNIMPLEMENTED;
-// mount_t mnt = xbt_new0(s_mount_t, 1);
-// mnt->id = xbt_strdup(mstorage->type_id);
-// mnt->name = xbt_strdup(mstorage->name);
-//
-// if(!mount_list){
-// XBT_DEBUG("Creata a Mount list for %s",A_surfxml_host_id);
-// mount_list = xbt_dynar_new(sizeof(char *), NULL);
-// }
-// xbt_dynar_push(mount_list,(void *) mnt);
-// free(mnt->id);
-// free(mnt->name);
-// xbt_free(mnt);
-// XBT_DEBUG("ROUTING Mount a storage name '%s' with type_id '%s'",mstorage->name, mstorage->id);
-}
-
-static void mount_free(void *p)
-{
- mount_t mnt = p;
- xbt_free(mnt->name);
-}
-
-static void routing_parse_mount(sg_platf_mount_cbarg_t mount)
-{
- // Verification of an existing storage
- void* storage = xbt_lib_get_or_null(storage_lib, mount->id,ROUTING_STORAGE_LEVEL);
- xbt_assert(storage,"Disk id \"%s\" does not exists", mount->id);
-
- XBT_DEBUG("ROUTING Mount '%s' on '%s'",mount->id, mount->name);
-
- s_mount_t mnt;
- mnt.id = surf_storage_resource_by_name(mount->id);
- mnt.name = xbt_strdup(mount->name);
-
- if(!mount_list){
- XBT_DEBUG("Create a Mount list for %s",A_surfxml_host_id);
- mount_list = xbt_dynar_new(sizeof(s_mount_t), mount_free);
- }
- xbt_dynar_push(mount_list,&mnt);
-}
-
static void routing_parse_cluster(sg_platf_cluster_cbarg_t cluster)
{
char *host_id, *groups, *link_id = NULL;
sg_platf_peer_add_cb(routing_parse_peer);
sg_platf_postparse_add_cb(routing_parse_postparse);
- sg_platf_storage_add_cb(routing_parse_storage);
- sg_platf_mstorage_add_cb(routing_parse_mstorage);
- sg_platf_storage_type_add_cb(routing_parse_storage_type);
- sg_platf_mount_add_cb(routing_parse_mount);
-
/* we care about the ASes while parsing the platf. Incredible, isnt it? */
sg_platf_AS_end_add_cb(routing_AS_end);
sg_platf_AS_begin_add_cb(routing_AS_begin);
