#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
{"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},
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);
+ 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);
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);
+ 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);
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);
xbt_dict_set(current_routing->routing_sons, AS_id,
(void *) new_as, NULL);
/* add to the father element list */
- info->id = 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");
}
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);
/**
* \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(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) {
"Reading a storage, processing unit \"%s\" already exists", storage->id);
// Verification of an existing type_id
+#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_DEBUG("ROUTING Create a storage name '%s' with type_id '%s'",
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_type_lib, storage_type->id,ROUTING_STORAGE_TYPE_LEVEL),
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_DEBUG("ROUTING Create a storage type id '%s' with model '%s' content '%s' and properties '%p'",
stype->type_id,
stype->model,
- stype->content,
+ storage_type->content,
stype->properties);
xbt_lib_set(storage_type_lib,
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);
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