#include "surf/surf_routing.h"
#include "surf/surfxml_parse_values.h"
+/**
+ * @ingroup SURF_build_api
+ * @brief A library containing all known workstations
+ */
xbt_lib_t host_lib;
+
int ROUTING_HOST_LEVEL; //Routing level
int SURF_CPU_LEVEL; //Surf cpu level
int SURF_WKS_LEVEL; //Surf workstation level
int COORD_HOST_LEVEL=0; //Coordinates level
int NS3_HOST_LEVEL; //host node for ns3
+/**
+ * @ingroup SURF_build_api
+ * @brief A library containing all known links
+ */
xbt_lib_t link_lib;
int SD_LINK_LEVEL; //Simdag level
int SURF_LINK_LEVEL; //Surf level
xbt_lib_t storage_lib;
int ROUTING_STORAGE_LEVEL; //Routing for storagelevel
-int ROUTING_STORAGE_TYPE_LEVEL; //Routing for storage_type level
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;
{"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},
*/
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, (void *) info);
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, (void *) info);
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 = 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\"",
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 = 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);
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, (void *) info);
} 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;
+#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, 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)
{
- void *link;
- unsigned int cpt;
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;
}
// // FIXME this path is never tested. I need examples to check the bypass mechanism...
// THROW_UNIMPLEMENTED; // let's warn the users of the problem
- xbt_dynar_foreach(e_route_bypass->link_list, cpt, link) {
- xbt_dynar_push(*links, &link);
- }
-
+ xbt_dynar_merge(links,&(e_route_bypass->link_list));
generic_free_route(e_route_bypass);
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 (src != src_gateway_net_elm)
+ _get_route_and_latency(src, src_gateway_net_elm, links, latency);
- xbt_dynar_foreach(route.link_list, cpt, link) {
- xbt_dynar_push(*links, &link);
- }
+ 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)) {
- xbt_dynar_t route_dst = xbt_dynar_new(global_routing->size_of_link,NULL);
-
- _get_route_and_latency(dst_gateway, dst, &route_dst, latency);
-
- xbt_dynar_foreach(route_dst, cpt, link) {
- xbt_dynar_push(*links, &link);
- }
- xbt_dynar_free(&route_dst);
+ if (dst_gateway_net_elm != dst) {
+ _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);
}
/**
* \brief Find a route between hosts
*
- * \param src the source host name
- * \param dst the destination host name
+ * \param src the network_element_t for src host
+ * \param dst the network_element_t for dst host
* \param route where to store the list of links.
* If *route=NULL, create a short lived dynar. Else, fill the provided dynar
* \param latency where to store the latency experienced on the path (or NULL if not interested)
* 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)
xbt_dynar_t ret = xbt_dynar_new(sizeof(onelink_t), xbt_free);
//adding my one link routes
- unsigned int cpt;
- void *link;
xbt_dynar_t onelink_mine = rc->get_onelink_routes(rc);
- if (onelink_mine) {
- xbt_dynar_foreach(onelink_mine, cpt, link) {
- xbt_dynar_push(ret, &link);
- }
- }
+ if (onelink_mine)
+ xbt_dynar_merge(&ret,&onelink_mine);
+
//recursing
char *key;
xbt_dict_cursor_t cursor = NULL;
AS_t rc_child;
xbt_dict_foreach(rc->routing_sons, cursor, key, rc_child) {
xbt_dynar_t onelink_child = recursive_get_onelink_routes(rc_child);
- if (onelink_child) {
- xbt_dynar_foreach(onelink_child, cpt, link) {
- xbt_dynar_push(ret, &link);
- }
- }
+ if (onelink_child)
+ xbt_dynar_merge(&ret,&onelink_child);
}
return ret;
}
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)
"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_lib, storage->type_id,ROUTING_STORAGE_TYPE_LEVEL);
+#ifndef NDEBUG
+ void* storage_type = xbt_lib_get_or_null(storage_type_lib, storage->type_id,ROUTING_STORAGE_TYPE_LEVEL);
+#endif
xbt_assert(storage_type,"Reading a storage, type id \"%s\" does not exists", storage->type_id);
- XBT_INFO("ROUTING Create a storage name '%s' with type_id '%s'",storage->id,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));
+ xbt_lib_set(storage_lib,
+ storage->id,
+ ROUTING_STORAGE_LEVEL,
+ (void *) xbt_strdup(storage->type_id));
}
+
+static void free_storage_content(void *p)
+{
+ content_t content = p;
+ free(content->date);
+ free(content->group);
+ free(content->time);
+ free(content->user);
+ free(content->user_rights);
+ free(content);
+}
+
+static xbt_dict_t parse_storage_content(const char *filename)
+{
+ if ((!filename) || (strcmp(filename, "") == 0))
+ return NULL;
+
+ xbt_dict_t parse_content = xbt_dict_new_homogeneous(free_storage_content);
+ FILE *file = NULL;
+
+ file = surf_fopen(filename, "r");
+ xbt_assert(file != NULL, "Cannot open file '%s' (path=%s)", filename,
+ xbt_str_join(surf_path, ":"));
+
+ char *line = NULL;
+ size_t len = 0;
+ ssize_t read;
+ char user_rights[12];
+ char user[100];
+ char group[100];
+ char date[12];
+ char time[12];
+ char path[1024];
+ int nb, size;
+
+ content_t content;
+
+ while ((read = getline(&line, &len, file)) != -1) {
+ content = xbt_new0(s_content_t,1);
+ if(sscanf(line,"%s %d %s %s %d %s %s %s",user_rights,&nb,user,group,&size,date,time,path)==8) {
+ content->date = xbt_strdup(date);
+ content->group = xbt_strdup(group);
+ content->size = size;
+ content->time = xbt_strdup(time);
+ content->user = xbt_strdup(user);
+ content->user_rights = xbt_strdup(user_rights);
+ xbt_dict_set(parse_content,path,content,NULL);
+ } else {
+ xbt_die("Be sure of passing a good format for content file.\n");
+ // You can generate this kind of file with command line:
+ // find /path/you/want -type f -exec ls -l {} \; 2>/dev/null > ./content.txt
+ }
+ }
+ if (line)
+ free(line);
+
+ fclose(file);
+ return parse_content;
+}
+
static void routing_parse_storage_type(sg_platf_storage_type_cbarg_t storage_type)
{
- xbt_assert(!xbt_lib_get_or_null(storage_lib, storage_type->id,ROUTING_STORAGE_TYPE_LEVEL),
+ 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);
- XBT_INFO("ROUTING Create a storage type_id '%s' with model '%s'",storage_type->id,storage_type->model);
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->content = parse_storage_content(storage_type->content);
stype->type_id = xbt_strdup(storage_type->id);
- xbt_lib_set(storage_lib,storage_type->id,ROUTING_STORAGE_TYPE_LEVEL,(void *) stype);
+ XBT_DEBUG("ROUTING Create a storage type id '%s' with model '%s' content '%s' and properties '%p'",
+ stype->type_id,
+ stype->model,
+ storage_type->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)
{
- mount_t mnt = xbt_new0(s_mount_t, 1);
- mnt->type_id = xbt_strdup(mstorage->type_id);
- mnt->name = xbt_strdup(mstorage->name);
+ 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);
+}
- if(!mount_list){
- XBT_INFO("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->type_id);
- free(mnt->name);
- xbt_free(mnt);
- XBT_INFO("ROUTING Mount a storage name '%s' with type_id '%s'",mstorage->name, mstorage->type_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
+#ifndef NDEBUG
void* storage = xbt_lib_get_or_null(storage_lib, mount->id,ROUTING_STORAGE_LEVEL);
+#endif
xbt_assert(storage,"Disk id \"%s\" does not exists", mount->id);
XBT_DEBUG("ROUTING Mount '%s' on '%s'",mount->id, mount->name);
- sg_platf_mstorage_cbarg_t mstorage = xbt_new0(s_sg_platf_mstorage_cbarg_t, 1);
- mstorage->name = xbt_strdup(mount->name);
- mstorage->type_id = xbt_strdup((const char*)storage);
-
- routing_parse_mstorage(mstorage);
- free(mstorage->name);
- free(mstorage->type_id);
- xbt_free(mstorage);
+
+ 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)
xbt_dict_set(patterns, "suffix", xbt_strdup(cluster->suffix), NULL);
}
-
XBT_DEBUG("<AS id=\"%s\"\trouting=\"Cluster\">", cluster->id);
sg_platf_new_AS_begin(cluster->id, "Cluster");
+ current_routing->link_up_down_list
+ = xbt_dynar_new(sizeof(s_surf_parsing_link_up_down_t),NULL);
+
//Make all hosts
radical_elements = xbt_str_split(cluster->radical, ",");
xbt_dynar_foreach(radical_elements, iter, groups) {
link.policy = cluster->sharing_policy;
sg_platf_new_link(&link);
- surf_parsing_link_up_down_t info =
- xbt_new0(s_surf_parsing_link_up_down_t, 1);
+ s_surf_parsing_link_up_down_t info;
+
if (link.policy == SURF_LINK_FULLDUPLEX) {
char *tmp_link = bprintf("%s_UP", link_id);
- info->link_up =
+ info.link_up =
xbt_lib_get_or_null(link_lib, tmp_link, SURF_LINK_LEVEL);
free(tmp_link);
tmp_link = bprintf("%s_DOWN", link_id);
- info->link_down =
+ info.link_down =
xbt_lib_get_or_null(link_lib, tmp_link, SURF_LINK_LEVEL);
free(tmp_link);
} else {
- info->link_up = xbt_lib_get_or_null(link_lib, link_id, SURF_LINK_LEVEL);
- info->link_down = info->link_up;
+ info.link_up = xbt_lib_get_or_null(link_lib, link_id, SURF_LINK_LEVEL);
+ info.link_down = info.link_up;
}
- surf_routing_cluster_add_link(host_id, info);
-
+ xbt_dynar_push(current_routing->link_up_down_list,&info);
xbt_free(link_id);
xbt_free(host_id);
}
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);
+
#ifdef HAVE_TRACING
instr_routing_define_callbacks();
#endif
