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 */
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 */
info->rc_component = current_routing;
info->rc_type = SURF_NETWORK_ELEMENT_HOST;
xbt_lib_set(host_lib, host->id, ROUTING_HOST_LEVEL, (void *) info);
+
+ if(mount_list){
+ xbt_lib_set(storage_lib, host->id, ROUTING_STORAGE_HOST_LEVEL, (void *) mount_list);
+ mount_list = NULL;
+ }
+
if (host->coord && strcmp(host->coord, "")) {
unsigned int cursor;
char*str;
for (cpt = 0; routing_models[cpt].name; cpt++)
fprintf(stderr, " %s: %s\n", routing_models[cpt].name,
routing_models[cpt].desc);
- xbt_die(NULL);
+ xbt_die("dying");
}
/* make a new routing component */
void routing_get_route_and_latency(const char *src, const char *dst,
xbt_dynar_t * route, double *latency)
{
- static xbt_dynar_t last_route = NULL;
-
- int need_cleanup = !(*route);
-
- if (need_cleanup) {
- xbt_dynar_free(&last_route);
- last_route = *route = xbt_dynar_new(global_routing->size_of_link,NULL);
+ if (!*route) {
+ xbt_dynar_reset(global_routing->last_route);
+ *route = global_routing->last_route;
}
_get_route_and_latency(src, dst, route, latency);
global_routing->get_onelink_routes = get_onelink_routes;
global_routing->loopback = loopback;
global_routing->size_of_link = size_of_links;
+ global_routing->last_route = xbt_dynar_new(global_routing->size_of_link,NULL);
/* no current routing at moment */
current_routing = NULL;
}
/* ************************************************************************** */
/* ************************* 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->id);
+ 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);
+
+ mount_t mnt = xbt_new0(s_mount_t, 1);
+ mnt->id = xbt_strdup(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)
{
if (strcmp(cluster->availability_trace, "")
|| strcmp(cluster->state_trace, "")) {
- patterns = xbt_dict_new();
- xbt_dict_set(patterns, "id", xbt_strdup(cluster->id), free);
- xbt_dict_set(patterns, "prefix", xbt_strdup(cluster->prefix), free);
- xbt_dict_set(patterns, "suffix", xbt_strdup(cluster->suffix), free);
+ patterns = xbt_dict_new_homogeneous(xbt_free_f);
+ xbt_dict_set(patterns, "id", xbt_strdup(cluster->id), NULL);
+ xbt_dict_set(patterns, "prefix", xbt_strdup(cluster->prefix), NULL);
+ xbt_dict_set(patterns, "suffix", xbt_strdup(cluster->suffix), NULL);
}
memset(&host, 0, sizeof(host));
host.id = host_id;
if (strcmp(cluster->availability_trace, "")) {
- xbt_dict_set(patterns, "radical", bprintf("%d", i), xbt_free);
+ xbt_dict_set(patterns, "radical", bprintf("%d", i), NULL);
char *avail_file = xbt_str_varsubst(cluster->availability_trace, patterns);
XBT_DEBUG("\tavailability_file=\"%s\"", avail_file);
host.power_trace = tmgr_trace_new(avail_file);
int start, end;
xbt_dynar_t radical_ends;
- random->generator = A_surfxml_random_generator;
+ switch (A_surfxml_random_generator) {
+ case AU_surfxml_random_generator:
+ case A_surfxml_random_generator_NONE:
+ random->generator = NONE;
+ break;
+ case A_surfxml_random_generator_DRAND48:
+ random->generator = DRAND48;
+ break;
+ case A_surfxml_random_generator_RAND:
+ random->generator = RAND;
+ break;
+ case A_surfxml_random_generator_RNGSTREAM:
+ random->generator = RNGSTREAM;
+ break;
+ default:
+ surf_parse_error("Invalid random generator");
+ break;
+ }
random->seed = seed;
random->min = min;
random->max = max;
XBT_DEBUG
("id = '%s' min = '%f' max = '%f' mean = '%f' std_deviatinon = '%f' generator = '%d' seed = '%ld' radical = '%s'",
random_id, random->min, random->max, random->mean, random->std,
- random->generator, random->seed, random_radical);
+ (int)random->generator, random->seed, random_radical);
if (!random_value)
- random_value = xbt_dict_new();
+ random_value = xbt_dict_new_homogeneous(free);
if (!strcmp(random_radical, "")) {
res = random_generate(random);
rd_value = bprintf("%f", res);
- xbt_dict_set(random_value, random_id, rd_value, free);
+ xbt_dict_set(random_value, random_id, rd_value, NULL);
} else {
radical_elements = xbt_str_split(random_radical, ",");
xbt_dynar_foreach(radical_elements, iter, groups) {
tmpbuf =
bprintf("%s%d", random_id,
atoi(xbt_dynar_getfirst_as(radical_ends, char *)));
- xbt_dict_set(random_value, tmpbuf, bprintf("%f", res), free);
+ xbt_dict_set(random_value, tmpbuf, bprintf("%f", res), NULL);
xbt_free(tmpbuf);
break;
i));
res = random_generate(random);
tmpbuf = bprintf("%s%d", random_id, i);
- xbt_dict_set(random_value, tmpbuf, bprintf("%f", res), free);
+ xbt_dict_set(random_value, tmpbuf, bprintf("%f", res), NULL);
xbt_free(tmpbuf);
}
break;
res = random_generate(random);
rd_name = bprintf("%s_router", random_id);
rd_value = bprintf("%f", res);
- xbt_dict_set(random_value, rd_name, rd_value, free);
+ xbt_dict_set(random_value, rd_name, rd_value, NULL);
xbt_dynar_free(&radical_ends);
}
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);
+
#ifdef HAVE_TRACING
instr_routing_define_callbacks();
#endif
void routing_exit(void) {
if (!global_routing)
return;
+ xbt_dynar_free(&global_routing->last_route);
finalize_rec(global_routing->root);
xbt_free(global_routing);
}
