-/* Copyright (c) 2009, 2010. The SimGrid Team.
+/* Copyright (c) 2009, 2010, 2011. The SimGrid Team.
* All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
* under the terms of the license (GNU LGPL) which comes with this package. */
-#ifdef HAVE_PCRE_LIB
#include <pcre.h> /* regular expression library */
-#endif
+
+#include "simgrid/platf_interface.h" // platform creation API internal interface
+
#include "surf_routing_private.h"
#include "surf/surf_routing.h"
+#include "surf/surfxml_parse_values.h"
xbt_lib_t host_lib;
int ROUTING_HOST_LEVEL; //Routing level
static char *gw_src = NULL; /* temporary store the gateway source name of a route */
static char *gw_dst = NULL; /* temporary store the gateway destination name of a route */
static double_f_cpvoid_t get_link_latency = NULL;
+xbt_dict_t cluster_host_link = NULL; /* for tag cluster */
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_route, surf, "Routing part of surf");
static void routing_parse_Srandom(void); /* random bypass */
static void routing_parse_Erandom(void); /* random bypass */
-static void routing_parse_Sconfig(void); /* config Tag */
-static void routing_parse_Econfig(void); /* config Tag */
-
static char* replace_random_parameter(char * chaine);
-static void clean_dict_random(void);
+static void clean_routing_after_parse(void);
/* this lines are only for replace use like index in the model table */
typedef enum {
SURF_MODEL_DIJKSTRA,
SURF_MODEL_DIJKSTRACACHE,
SURF_MODEL_NONE,
-#ifdef HAVE_PCRE_LIB
- SURF_MODEL_RULEBASED
-#endif
+ SURF_MODEL_RULEBASED,
+ SURF_MODEL_VIVALDI,
+ SURF_MODEL_CLUSTER
} e_routing_types;
struct s_model_type routing_models[] = { {"Full",
model_dijkstra_both_unload, model_dijkstra_both_end},
{"none", "No routing (usable with Constant network only)",
model_none_create, model_none_load, model_none_unload, model_none_end},
-#ifdef HAVE_PCRE_LIB
{"RuleBased", "Rule-Based routing data (...)", model_rulebased_create,
model_rulebased_load, model_rulebased_unload, model_rulebased_end},
{"Vivaldi", "Vivaldi routing", model_rulebased_create,
model_rulebased_load, model_rulebased_unload, model_rulebased_end},
-#endif
+{"Cluster", "Cluster routing", model_cluster_create,
+ model_rulebased_load, model_rulebased_unload, model_rulebased_end},
{NULL, NULL, NULL, NULL, NULL, NULL}
};
xbt_assert(euclidean_dist>=0, "Euclidean Dist is less than 0\"%s\" and \"%.2f\"", src, euclidean_dist);
- return euclidean_dist;
+ //From .ms to .s
+ return euclidean_dist / 1000;
}
static double vivaldi_get_link_latency (routing_component_t rc,const char *src, const char *dst, route_extended_t e_route)
/*
* \brief Add a host to the network element list from XML
*/
-static void parse_S_host_XML(void)
+static void parse_S_host_XML(sg_platf_host_cbarg_t h)
{
- parse_S_host(A_surfxml_host_id, A_surfxml_host_coordinates);
+ parse_S_host(h->V_host_id, h->V_host_coord);
}
static void parse_E_host_XML(void)
{
/**
* \brief Add a "router" to the network element list
*/
-static void parse_S_router(const char *router_id)
+static void parse_S_router(sg_platf_router_cbarg_t router)
{
network_element_info_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,A_surfxml_router_id, ROUTING_ASR_LEVEL),
+ xbt_assert(!xbt_lib_get_or_null(as_router_lib,router->V_router_id, ROUTING_ASR_LEVEL),
"Reading a router, processing unit \"%s\" already exists",
- router_id);
+ router->V_router_id);
xbt_assert(current_routing->set_processing_unit,
"no defined method \"set_processing_unit\" in \"%s\"",
current_routing->name);
(*(current_routing->set_processing_unit)) (current_routing,
- router_id);
+ router->V_router_id);
info = xbt_new0(s_network_element_info_t, 1);
info->rc_component = current_routing;
info->rc_type = SURF_NETWORK_ELEMENT_ROUTER;
- xbt_lib_set(as_router_lib,router_id,ROUTING_ASR_LEVEL,(void *) info);
+ xbt_lib_set(as_router_lib,router->V_router_id,ROUTING_ASR_LEVEL,(void *) info);
if (strcmp(A_surfxml_router_coordinates,"")) {
if(!COORD_ASR_LEVEL) xbt_die("To use coordinates, you must set configuration 'coordinates' to 'yes'");
xbt_dynar_t ctn = xbt_str_split_str(A_surfxml_router_coordinates, " ");
xbt_dynar_shrink(ctn, 0);
- xbt_lib_set(as_router_lib,router_id,COORD_ASR_LEVEL,(void *) ctn);
+ xbt_lib_set(as_router_lib,router->V_router_id,COORD_ASR_LEVEL,(void *) ctn);
}
}
/**
* brief Add a "router" to the network element list from XML description
*/
-static void parse_S_router_XML(void)
-{
- return parse_S_router(A_surfxml_router_id);
-}
-
-/**
- * brief Add a "router" to the network element list from XML description
- */
-static void parse_S_router_lua(const char* router_id)
-{
- return parse_S_router(router_id);
+static void parse_S_router_lua(const char* router_id) {
+ s_sg_platf_router_cbarg_t router;
+ memset(&router,0,sizeof(router));
+ router.V_router_id = router_id;
+ router.V_router_coord = "";
+ return parse_S_router(&router);
}
/**
}
/**
- * \brief Make a new routing component
+ * \brief Make a new routing component to the platform
*
- * make the new structure and
- * set the parsing functions to allows parsing the part of the routing tree
+ * Add a new autonomous system to the platform. Any elements (such as host,
+ * router or sub-AS) added after this call and before the corresponding call
+ * to sg_platf_new_AS_close() will be added to this AS.
+ *
+ * Once this function was called, the configuration concerning the used
+ * models cannot be changed anymore.
+ *
+ * @param AS_id name of this autonomous system. Must be uniq in the platform
+ * @param wanted_routing_type one of Full, Floyd, Dijkstra or similar. Full list in the variable routing_models, in src/surf/surf_routing.c
*/
-static void parse_S_AS(char *AS_id, char *AS_routing)
+void sg_platf_new_AS_open(const char *AS_id, const char *wanted_routing_type)
{
routing_component_t new_routing;
model_type_t model = NULL;
- char *wanted = AS_routing;
int cpt;
- /* seach the routing model */
+
+ surf_parse_models_setup(); /* ensure that the models are created after the last <config> tag and before the first <AS>-like */
+
+ /* search the routing model */
for (cpt = 0; routing_models[cpt].name; cpt++)
- if (!strcmp(wanted, routing_models[cpt].name))
+ if (!strcmp(wanted_routing_type, routing_models[cpt].name))
model = &routing_models[cpt];
/* if its not exist, error */
if (model == NULL) {
fprintf(stderr, "Routing model %s not found. Existing models:\n",
- wanted);
+ wanted_routing_type);
for (cpt = 0; routing_models[cpt].name; cpt++)
- if (!strcmp(wanted, routing_models[cpt].name))
fprintf(stderr, " %s: %s\n", routing_models[cpt].name,
routing_models[cpt].desc);
xbt_die(NULL);
current_routing = new_routing;
}
-/*
- * Detect the routing model type of the routing component from XML platforms
- */
-static void parse_S_AS_XML(void)
-{
- parse_S_AS(A_surfxml_AS_id, A_surfxml_AS_routing);
-}
-
-/*
- * define the routing model type of routing component from lua script
- */
-static void parse_S_AS_lua(char *id, char *mode)
-{
- parse_S_AS(id, mode);
-}
-
-
/**
- * \brief Finish the creation of a new routing component
+ * \brief Specify that the current description of AS is finished
+ *
+ * Once you've declared all the content of your AS, you have to close
+ * it with this call. Your AS is not usable until you call this function.
+ *
+ * @fixme: this call is not as robust as wanted: bad things WILL happen
+ * if you call it twice for the same AS, or if you forget calling it, or
+ * even if you add stuff to a closed AS
*
- * When you finish to read the routing component, other structures must be created.
- * the "end" method allow to do that for any routing model type
*/
-static void parse_E_AS(const char *AS_id)
-{
+void sg_platf_new_AS_close() {
if (current_routing == NULL) {
- THROWF(arg_error, 0, "Close AS(%s), that never open", AS_id);
+ 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),
}
}
-/*
- * \brief Finish the creation of a new routing component from XML
- */
-static void parse_E_AS_XML(void)
-{
- parse_E_AS(A_surfxml_AS_id);
-}
-
-/*
- * \brief Finish the creation of a new routing component from lua
- */
-static void parse_E_AS_lua(const char *id)
-{
- parse_E_AS(id);
-}
-
/* Aux Business methods */
/**
/* (2) find the path to the root routing component */
for (current = src_as ; current != NULL ; current = current->routing_father) {
+ if (index_src >= ELEMENTS_FATHER_MAXDEPTH)
+ xbt_die("ELEMENTS_FATHER_MAXDEPTH should be increased for path_src");
path_src[index_src++] = current;
- xbt_assert(index_src <= ELEMENTS_FATHER_MAXDEPTH,
- "ELEMENTS_FATHER_MAXDEPTH should be increased for path_src");
}
for (current = dst_as ; current != NULL ; current = current->routing_father) {
+ if (index_dst >= ELEMENTS_FATHER_MAXDEPTH)
+ xbt_die("ELEMENTS_FATHER_MAXDEPTH should be increased for path_dst");
path_dst[index_dst++] = current;
- xbt_assert(index_dst <= ELEMENTS_FATHER_MAXDEPTH,
- "ELEMENTS_FATHER_MAXDEPTH should be increased for path_dst");
}
/* (3) find the common father */
/* Global Business methods */
/**
- * \brief Recursive function for get_route and get_latency
+ * \brief Recursive function for get_route_latency
*
* \param src the source host name
* \param dst the destination host name
* recursively through the routing components tree.
*/
static void _get_route_latency(const char *src, const char *dst,
- route_extended_t *e_route, double *latency)
+ xbt_dynar_t *route, double *latency)
{
XBT_DEBUG("Solve route/latency \"%s\" to \"%s\"", src, dst);
xbt_assert(src && dst, "bad parameters for \"_get_route_latency\" method");
if (src_father == dst_father) { /* SURF_ROUTING_BASE */
- route_extended_t route = NULL;
- if (e_route) {
- route = common_father->get_route(common_father, src, dst);
- xbt_assert(route, "no route between \"%s\" and \"%s\"", src, dst);
- *e_route = route;
+ route_extended_t e_route = NULL;
+ if (route) {
+ e_route = common_father->get_route(common_father, src, dst);
+ xbt_assert(e_route, "no route between \"%s\" and \"%s\"", src, dst);
+ *route = e_route->generic_route.link_list;
}
if (latency) {
- *latency = common_father->get_latency(common_father, src, dst, route);
+ *latency = common_father->get_latency(common_father, src, dst, e_route);
xbt_assert(*latency >= 0.0,
"latency error on route between \"%s\" and \"%s\"", src, dst);
}
+ if (e_route) {
+ xbt_free(e_route->src_gateway);
+ xbt_free(e_route->dst_gateway);
+ xbt_free(e_route);
+ }
} else { /* SURF_ROUTING_RECURSIVE */
(e_route_cnt->dst_gateway == NULL),
"bad gateway for route between \"%s\" and \"%s\"", src, dst);
- if (e_route) {
- (*e_route) = xbt_new0(s_route_extended_t, 1);
- (*e_route)->src_gateway = NULL;
- (*e_route)->dst_gateway = NULL;
- (*e_route)->generic_route.link_list =
- xbt_dynar_new(global_routing->size_of_link, NULL);
+ if (route) {
+ *route = xbt_dynar_new(global_routing->size_of_link, NULL);
}
-
if (latency) {
*latency = common_father->get_latency(common_father,
src_father->name, dst_father->name,
if (strcmp(src, e_route_cnt->src_gateway)) {
double latency_src;
- route_extended_t e_route_src;
+ xbt_dynar_t route_src;
_get_route_latency(src, e_route_cnt->src_gateway,
- (e_route ? &e_route_src : NULL),
+ (route ? &route_src : NULL),
(latency ? &latency_src : NULL));
- if (e_route) {
- xbt_assert(e_route_src, "no route between \"%s\" and \"%s\"",
+ if (route) {
+ xbt_assert(route_src, "no route between \"%s\" and \"%s\"",
src, e_route_cnt->src_gateway);
- xbt_dynar_foreach(e_route_src->generic_route.link_list, cpt, link) {
- xbt_dynar_push((*e_route)->generic_route.link_list, &link);
+ xbt_dynar_foreach(route_src, cpt, link) {
+ xbt_dynar_push(*route, &link);
}
- generic_free_extended_route(e_route_src);
+ xbt_dynar_free(&route_src);
}
if (latency) {
xbt_assert(latency_src >= 0.0,
}
}
- if (e_route) {
+ if (route) {
xbt_dynar_foreach(e_route_cnt->generic_route.link_list, cpt, link) {
- xbt_dynar_push((*e_route)->generic_route.link_list, &link);
+ xbt_dynar_push(*route, &link);
}
}
if (strcmp(e_route_cnt->dst_gateway, dst)) {
double latency_dst;
- route_extended_t e_route_dst;
+ xbt_dynar_t route_dst;
_get_route_latency(e_route_cnt->dst_gateway, dst,
- (e_route ? &e_route_dst : NULL),
+ (route ? &route_dst : NULL),
(latency ? &latency_dst : NULL));
- if (e_route) {
- xbt_assert(e_route_dst, "no route between \"%s\" and \"%s\"",
+ if (route) {
+ xbt_assert(route_dst, "no route between \"%s\" and \"%s\"",
e_route_cnt->dst_gateway, dst);
- xbt_dynar_foreach(e_route_dst->generic_route.link_list, cpt, link) {
- xbt_dynar_push((*e_route)->generic_route.link_list, &link);
+ xbt_dynar_foreach(route_dst, cpt, link) {
+ xbt_dynar_push(*route, &link);
}
- generic_free_extended_route(e_route_dst);
+ xbt_dynar_free(&route_dst);
}
if (latency) {
xbt_assert(latency_dst >= 0.0,
}
}
- if (e_route) {
- (*e_route)->src_gateway = xbt_strdup(e_route_cnt->src_gateway);
- (*e_route)->dst_gateway = xbt_strdup(e_route_cnt->dst_gateway);
- }
-
generic_free_extended_route(e_route_cnt);
}
}
+/**
+ * \brief Generic function for get_route, get_route_no_cleanup, and get_latency
+ */
+static void get_route_latency(const char *src, const char *dst,
+ xbt_dynar_t *route, double *latency, int cleanup)
+{
+ _get_route_latency(src, dst, route, latency);
+ xbt_assert(!route || *route, "no route between \"%s\" and \"%s\"", src, dst);
+ xbt_assert(!latency || *latency >= 0.0,
+ "latency error on route between \"%s\" and \"%s\"", src, dst);
+ if (route) {
+ xbt_dynar_free(&global_routing->last_route);
+ global_routing->last_route = cleanup ? *route : NULL;
+ }
+}
+
/**
* \brief Generic method: find a route between hosts
*
*/
static xbt_dynar_t get_route(const char *src, const char *dst)
{
+ xbt_dynar_t route = NULL;
+ get_route_latency(src, dst, &route, NULL, 1);
+ return route;
+}
- route_extended_t e_route = NULL;
-
- _get_route_latency(src, dst, &e_route, NULL);
- xbt_assert(e_route, "no route between \"%s\" and \"%s\"", src, dst);
-
- if (global_routing->last_route)
- xbt_dynar_free(&(global_routing->last_route));
- global_routing->last_route = e_route->generic_route.link_list;
-
- if (e_route->src_gateway)
- xbt_free(e_route->src_gateway);
- if (e_route->dst_gateway)
- xbt_free(e_route->dst_gateway);
-
- xbt_free(e_route);
-
- return global_routing->last_route;
+/**
+ * \brief Generic method: find a route between hosts
+ *
+ * \param src the source host name
+ * \param dst the destination host name
+ *
+ * same as get_route, but return NULL if any exception is raised.
+ */
+static xbt_dynar_t get_route_or_null(const char *src, const char *dst)
+{
+ xbt_dynar_t route = NULL;
+ xbt_ex_t exception;
+ TRY {
+ get_route_latency(src, dst, &route, NULL, 1);
+ }CATCH(exception) {
+ xbt_ex_free(exception);
+ return NULL;
+ }
+ return route;
}
/**
*/
static xbt_dynar_t get_route_no_cleanup(const char *src, const char *dst)
{
- xbt_dynar_t d = get_route(src,dst);
- global_routing->last_route = NULL;
- return d;
+ xbt_dynar_t route = NULL;
+ get_route_latency(src, dst, &route, NULL, 0);
+ return route;
}
/*Get Latency*/
static double get_latency(const char *src, const char *dst)
{
-
double latency = -1.0;
- _get_route_latency(src, dst, NULL, &latency);
- xbt_assert(latency>=0.0, "no route between \"%s\" and \"%s\"", src, dst);
+ get_route_latency(src, dst, NULL, &latency, 0);
return latency;
}
+static int surf_parse_models_setup_already_called=0;
+/* Call the last initialization functions, that must be called after the
+ * <config> tag, if any, and before the first of cluster|peer|AS|trace|trace_connect
+ */
+void surf_parse_models_setup()
+{
+ if (surf_parse_models_setup_already_called)
+ return;
+ surf_parse_models_setup_already_called=1;
+ routing_parse_Erandom();
+ surf_config_models_setup();
+}
+
+
/**
* \brief Recursive function for finalize
*
xbt_dynar_free(&(global_routing->last_route));
/* delete global routing structure */
xbt_free(global_routing);
+ /* make sure that we will reinit the models while loading the platf once reinited -- HACK but there is no proper surf_routing_init() */
+ surf_parse_models_setup_already_called = 0;
}
static xbt_dynar_t recursive_get_onelink_routes(routing_component_t rc)
global_routing = xbt_new0(s_routing_global_t, 1);
global_routing->root = NULL;
global_routing->get_route = get_route;
+ global_routing->get_route_or_null = get_route_or_null;
global_routing->get_latency = get_latency;
global_routing->get_route_no_cleanup = get_route_no_cleanup;
global_routing->get_onelink_routes = get_onelink_routes;
+ global_routing->get_route_latency = get_route_latency;
global_routing->get_network_element_type = get_network_element_type;
global_routing->finalize = finalize;
global_routing->loopback = loopback;
current_routing = NULL;
/* parse generic elements */
- surfxml_add_callback(STag_surfxml_host_cb_list, &parse_S_host_XML);
+ sg_platf_host_add_cb(parse_S_host_XML);
surfxml_add_callback(ETag_surfxml_host_cb_list, &parse_E_host_XML);
- surfxml_add_callback(STag_surfxml_router_cb_list, &parse_S_router_XML);
+ sg_platf_router_add_cb(parse_S_router);
surfxml_add_callback(STag_surfxml_route_cb_list,
&parse_S_route_new_and_endpoints_XML);
surfxml_add_callback(ETag_surfxml_bypassRoute_cb_list,
&parse_E_bypassRoute_store_route);
- surfxml_add_callback(STag_surfxml_AS_cb_list, &parse_S_AS_XML);
- surfxml_add_callback(ETag_surfxml_AS_cb_list, &parse_E_AS_XML);
-
surfxml_add_callback(STag_surfxml_cluster_cb_list,
&routing_parse_Scluster);
&routing_parse_Speer);
surfxml_add_callback(ETag_surfxml_platform_cb_list,
- &clean_dict_random);
+ &clean_routing_after_parse);
#ifdef HAVE_TRACING
instr_routing_define_callbacks();
void surf_parse_add_callback_config(void)
{
- surfxml_add_callback(STag_surfxml_config_cb_list, &routing_parse_Sconfig);
- surfxml_add_callback(ETag_surfxml_config_cb_list, &routing_parse_Econfig);
surfxml_add_callback(STag_surfxml_prop_cb_list, &parse_properties_XML);
- surfxml_add_callback(STag_surfxml_AS_cb_list, &surf_parse_models_setup);
surfxml_add_callback(STag_surfxml_random_cb_list, &routing_parse_Srandom);
}
-void surf_parse_models_setup()
-{
- routing_parse_Erandom();
- surfxml_del_callback(STag_surfxml_AS_cb_list, surf_parse_models_setup);
- surf_config_models_setup(platform_filename);
- free(platform_filename);
-}
-
/* ************************************************** */
/* ********** PATERN FOR NEW ROUTING **************** */
current_src = xbt_dynar_get_ptr(path_src, index_src);
current_dst = xbt_dynar_get_ptr(path_dst, index_dst);
while (index_src >= 0 && index_dst >= 0 && *current_src == *current_dst) {
- routing_component_t *tmp_src, *tmp_dst;
- tmp_src = xbt_dynar_pop_ptr(path_src);
- tmp_dst = xbt_dynar_pop_ptr(path_dst);
+ xbt_dynar_pop_ptr(path_src);
+ xbt_dynar_pop_ptr(path_dst);
index_src--;
index_dst--;
current_src = xbt_dynar_get_ptr(path_src, index_src);
src,dst,src_as->name, dst_as->name,rc->name);
}
-static void routing_parse_Sconfig(void)
-{
- XBT_DEBUG("START configuration name = %s",A_surfxml_config_id);
-}
-
-static void routing_parse_Econfig(void)
-{
- xbt_dict_cursor_t cursor = NULL;
- char *key;
- char *elem;
- char *cfg;
- xbt_dict_foreach(current_property_set, cursor, key, elem) {
- cfg = bprintf("%s:%s",key,elem);
- if(xbt_cfg_is_default_value(_surf_cfg_set, key))
- xbt_cfg_set_parse(_surf_cfg_set, cfg);
- else
- XBT_INFO("The custom configuration '%s' is already define by user!",key);
- free(cfg);
- }
- XBT_DEBUG("End configuration name = %s",A_surfxml_config_id);
-}
-
void routing_parse_Scluster(void)
{
- static int AX_ptr = 0;
+ if(!cluster_host_link)
+ cluster_host_link = xbt_dict_new();
- char *cluster_id = A_surfxml_cluster_id;
- char *cluster_prefix = A_surfxml_cluster_prefix;
- char *cluster_suffix = A_surfxml_cluster_suffix;
- char *cluster_radical = A_surfxml_cluster_radical;
- char *cluster_power = A_surfxml_cluster_power;
- char *cluster_core = A_surfxml_cluster_core;
- char *cluster_bw = A_surfxml_cluster_bw;
- char *cluster_lat = A_surfxml_cluster_lat;
- char *temp_cluster_bw = NULL;
- char *temp_cluster_lat = NULL;
- char *temp_cluster_power = NULL;
- char *cluster_bb_bw = A_surfxml_cluster_bb_bw;
- char *cluster_bb_lat = A_surfxml_cluster_bb_lat;
- char *cluster_availability_file = A_surfxml_cluster_availability_file;
- char *cluster_state_file = A_surfxml_cluster_state_file;
+ static int AX_ptr = 0;
char *host_id, *groups, *link_id = NULL;
- char *router_id, *link_backbone;
- char *availability_file = xbt_strdup(cluster_availability_file);
- char *state_file = xbt_strdup(cluster_state_file);
- if(xbt_dict_size(patterns)==0)
- patterns = xbt_dict_new();
+ s_sg_platf_host_cbarg_t host;
- xbt_dict_set(patterns,"id",cluster_id,NULL);
- xbt_dict_set(patterns,"prefix",cluster_prefix,NULL);
- xbt_dict_set(patterns,"suffix",cluster_suffix,NULL);
+ if( strcmp(struct_cluster->V_cluster_availability_file,"")
+ || strcmp(struct_cluster->V_cluster_state_file,"") )
+ {
+ if(xbt_dict_size(patterns)==0)
+ patterns = xbt_dict_new();
+ xbt_dict_set(patterns,"id",struct_cluster->V_cluster_id,NULL);
+ xbt_dict_set(patterns,"prefix",struct_cluster->V_cluster_prefix,NULL);
+ xbt_dict_set(patterns,"suffix",struct_cluster->V_cluster_suffix,NULL);
+ }
-#ifdef HAVE_PCRE_LIB
- char *route_src_dst;
-#endif
unsigned int iter;
int start, end, i;
xbt_dynar_t radical_elements;
xbt_dynar_t radical_ends;
- int cluster_sharing_policy = AX_surfxml_cluster_sharing_policy;
- int cluster_bb_sharing_policy = AX_surfxml_cluster_bb_sharing_policy;
-
-#ifndef HAVE_PCRE_LIB
- xbt_dynar_t tab_elements_num = xbt_dynar_new(sizeof(int), NULL);
- char *route_src, *route_dst;
- int j;
-#endif
static unsigned int surfxml_buffer_stack_stack_ptr = 1;
static unsigned int surfxml_buffer_stack_stack[1024];
surfxml_buffer_stack_stack[0] = 0;
-
surfxml_bufferstack_push(1);
- SURFXML_BUFFER_SET(AS_id, cluster_id);
-#ifdef HAVE_PCRE_LIB
- SURFXML_BUFFER_SET(AS_routing, "RuleBased");
- XBT_DEBUG("<AS id=\"%s\"\trouting=\"RuleBased\">", cluster_id);
-#else
- SURFXML_BUFFER_SET(AS_routing, "Full");
- XBT_DEBUG("<AS id=\"%s\"\trouting=\"Full\">", cluster_id);
-#endif
+ SURFXML_BUFFER_SET(AS_id, struct_cluster->V_cluster_id);
+ SURFXML_BUFFER_SET(AS_routing, "Cluster");
+ XBT_DEBUG("<AS id=\"%s\"\trouting=\"Cluster\">", struct_cluster->V_cluster_id);
SURFXML_START_TAG(AS);
- radical_elements = xbt_str_split(cluster_radical, ",");
+ //Make all hosts
+ radical_elements = xbt_str_split(struct_cluster->V_cluster_radical, ",");
xbt_dynar_foreach(radical_elements, iter, groups) {
+ memset(&host,0,sizeof(host));
+
radical_ends = xbt_str_split(groups, "-");
switch (xbt_dynar_length(radical_ends)) {
case 1:
- surf_parse_get_int(&start,
- xbt_dynar_get_as(radical_ends, 0, char *));
- host_id = bprintf("%s%d%s", cluster_prefix, start, cluster_suffix);
-#ifndef HAVE_PCRE_LIB
- xbt_dynar_push_as(tab_elements_num, int, start);
-#endif
- link_id = bprintf("%s_link_%d", cluster_id, start);
-
- xbt_dict_set(patterns, "radical", bprintf("%d", start), xbt_free);
- temp_cluster_power = xbt_strdup(cluster_power);
- temp_cluster_power = replace_random_parameter(temp_cluster_power);
- XBT_DEBUG("<host\tid=\"%s\"\tpower=\"%s\">", host_id, temp_cluster_power);
- A_surfxml_host_state = A_surfxml_host_state_ON;
- SURFXML_BUFFER_SET(host_id, host_id);
- SURFXML_BUFFER_SET(host_power, temp_cluster_power);
- SURFXML_BUFFER_SET(host_core, cluster_core);
- SURFXML_BUFFER_SET(host_availability, "1.0");
- SURFXML_BUFFER_SET(host_coordinates, "");
- xbt_free(availability_file);
- availability_file = xbt_strdup(cluster_availability_file);
- xbt_free(state_file);
- state_file = xbt_strdup(cluster_state_file);
- XBT_DEBUG("\tavailability_file=\"%s\"",xbt_str_varsubst(availability_file,patterns));
- XBT_DEBUG("\tstate_file=\"%s\"",xbt_str_varsubst(state_file,patterns));
- SURFXML_BUFFER_SET(host_availability_file, xbt_str_varsubst(availability_file,patterns));
- SURFXML_BUFFER_SET(host_state_file, xbt_str_varsubst(state_file,patterns));
- XBT_DEBUG("</host>");
- SURFXML_START_TAG(host);
- SURFXML_END_TAG(host);
-
-
- temp_cluster_bw = xbt_strdup(cluster_bw);
- temp_cluster_bw = replace_random_parameter(temp_cluster_bw);
- temp_cluster_lat = xbt_strdup(cluster_lat);
- temp_cluster_lat = replace_random_parameter(temp_cluster_lat);
- XBT_DEBUG("<link\tid=\"%s\"\tbw=\"%s\"\tlat=\"%s\"/>", link_id,temp_cluster_bw, cluster_lat);
- A_surfxml_link_state = A_surfxml_link_state_ON;
- A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED;
- if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX)
- {A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_FULLDUPLEX;}
- if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FATPIPE)
- {A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_FATPIPE;}
- SURFXML_BUFFER_SET(link_id, link_id);
- SURFXML_BUFFER_SET(link_bandwidth, temp_cluster_bw);
- SURFXML_BUFFER_SET(link_latency, temp_cluster_lat);
- SURFXML_BUFFER_SET(link_bandwidth_file, "");
- SURFXML_BUFFER_SET(link_latency_file, "");
- SURFXML_BUFFER_SET(link_state_file, "");
- SURFXML_START_TAG(link);
- SURFXML_END_TAG(link);
-
- xbt_free(temp_cluster_bw);
- xbt_free(temp_cluster_lat);
- xbt_free(temp_cluster_power);
- free(link_id);
- free(host_id);
- break;
+ start=surf_parse_get_int(xbt_dynar_get_as(radical_ends, 0, char *));
+ host_id = bprintf("%s%d%s", struct_cluster->V_cluster_prefix, start, struct_cluster->V_cluster_suffix);
+ link_id = bprintf("%s_link_%d", struct_cluster->V_cluster_id, start);
+
+ XBT_DEBUG("<host\tid=\"%s\"\tpower=\"%f\">", host_id, struct_cluster->S_cluster_power);
+ host.V_host_id = host_id;
+ if(strcmp(struct_cluster->V_cluster_availability_file,"")){
+ xbt_dict_set(patterns, "radical", bprintf("%d", start), xbt_free);
+ char* tmp_availability_file = xbt_strdup(struct_cluster->V_cluster_availability_file);
+ xbt_str_varsubst(tmp_availability_file,patterns);
+ XBT_DEBUG("\tavailability_file=\"%s\"",tmp_availability_file);
+ host.V_host_power_trace = tmgr_trace_new(tmp_availability_file);
+ xbt_free(tmp_availability_file);
+ }
+ else
+ {
+ XBT_DEBUG("\tavailability_file=\"\"");
+ }
+ if(strcmp(struct_cluster->V_cluster_state_file,"")){
+ char *tmp_state_file = xbt_strdup(struct_cluster->V_cluster_state_file);
+ xbt_str_varsubst(tmp_state_file,patterns);
+ XBT_DEBUG("\tstate_file=\"%s\"",tmp_state_file);
+ host.V_host_state_trace = tmgr_trace_new(tmp_state_file);
+ xbt_free(tmp_state_file);
+ }
+ else
+ {
+ XBT_DEBUG("\tstate_file=\"\"");
+ }
+
+ host.V_host_power_peak = struct_cluster->S_cluster_power;
+ host.V_host_power_scale = 1.0;
+ host.V_host_core = struct_cluster->S_cluster_core;
+ host.V_host_state_initial = SURF_RESOURCE_ON;
+ host.V_host_coord = "";
+ sg_platf_new_host(&host);
+ XBT_DEBUG("</host>");
+
+ A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED;
+ if(struct_cluster->V_cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX)
+ {A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_FULLDUPLEX;}
+ if(struct_cluster->V_cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FATPIPE)
+ {A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_FATPIPE;}
+
+ XBT_DEBUG("<link\tid=\"%s\"\tbw=\"%f\"\tlat=\"%f\"/>", link_id,struct_cluster->S_cluster_bw, struct_cluster->S_cluster_lat);
+
+ struct_lnk = xbt_new0(s_surf_parsing_link_arg_t, 1);
+ struct_lnk->V_link_id = link_id;
+ struct_lnk->V_link_bandwidth = struct_cluster->S_cluster_bw;
+ struct_lnk->V_link_latency = struct_cluster->S_cluster_lat;
+ struct_lnk->V_link_bandwidth_file = NULL;
+ struct_lnk->V_link_latency_file = NULL;
+ struct_lnk->V_link_state_file = NULL;
+ struct_lnk->V_link_state = SURF_RESOURCE_ON;
+ struct_lnk->V_link_sharing_policy = A_surfxml_link_sharing_policy;
+
+ if (A_surfxml_link_sharing_policy == A_surfxml_link_sharing_policy_SHARED)
+ struct_lnk->V_policy_initial_link = SURF_LINK_SHARED;
+ else
+ {
+ if (A_surfxml_link_sharing_policy == A_surfxml_link_sharing_policy_FATPIPE)
+ struct_lnk->V_policy_initial_link = SURF_LINK_FATPIPE;
+ else if (A_surfxml_link_sharing_policy == A_surfxml_link_sharing_policy_FULLDUPLEX)
+ struct_lnk->V_policy_initial_link = SURF_LINK_FULLDUPLEX;
+ }
+ surf_parse_link();
+
+ xbt_dict_set(cluster_host_link,host_id,strdup(link_id),free);
+// XBT_INFO("key '%s' Value '%s'",host_id,link_id);
+ ETag_surfxml_host();
+ ETag_surfxml_link();
+
+ break;
case 2:
- surf_parse_get_int(&start,
- xbt_dynar_get_as(radical_ends, 0, char *));
- surf_parse_get_int(&end, xbt_dynar_get_as(radical_ends, 1, char *));
+ start=surf_parse_get_int(xbt_dynar_get_as(radical_ends, 0, char *));
+ end= surf_parse_get_int(xbt_dynar_get_as(radical_ends, 1, char *));
for (i = start; i <= end; i++) {
- host_id = bprintf("%s%d%s", cluster_prefix, i, cluster_suffix);
-#ifndef HAVE_PCRE_LIB
- xbt_dynar_push_as(tab_elements_num, int, i);
-#endif
- link_id = bprintf("%s_link_%d", cluster_id, i);
-
- xbt_dict_set(patterns, "radical", bprintf("%d", i), xbt_free);
- temp_cluster_power = xbt_strdup(cluster_power);
- temp_cluster_power = replace_random_parameter(temp_cluster_power);
- XBT_DEBUG("<host\tid=\"%s\"\tpower=\"%s\">", host_id, temp_cluster_power);
- A_surfxml_host_state = A_surfxml_host_state_ON;
- SURFXML_BUFFER_SET(host_id, host_id);
- SURFXML_BUFFER_SET(host_power, temp_cluster_power);
- SURFXML_BUFFER_SET(host_core, cluster_core);
- SURFXML_BUFFER_SET(host_availability, "1.0");
- SURFXML_BUFFER_SET(host_coordinates, "");
- xbt_free(availability_file);
- availability_file = xbt_strdup(cluster_availability_file);
- xbt_free(state_file);
- state_file = xbt_strdup(cluster_state_file);
- XBT_DEBUG("\tavailability_file=\"%s\"",xbt_str_varsubst(availability_file,patterns));
- XBT_DEBUG("\tstate_file=\"%s\"",xbt_str_varsubst(state_file,patterns));
- SURFXML_BUFFER_SET(host_availability_file, xbt_str_varsubst(availability_file,patterns));
- SURFXML_BUFFER_SET(host_state_file, xbt_str_varsubst(state_file,patterns));
- XBT_DEBUG("</host>");
- SURFXML_START_TAG(host);
- SURFXML_END_TAG(host);
-
- xbt_free(temp_cluster_power);
-
- temp_cluster_bw = xbt_strdup(cluster_bw);
- temp_cluster_bw = replace_random_parameter(temp_cluster_bw);
- temp_cluster_lat = xbt_strdup(cluster_lat);
- temp_cluster_lat = replace_random_parameter(temp_cluster_lat);
- XBT_DEBUG("<link\tid=\"%s\"\tbw=\"%s\"\tlat=\"%s\"/>", link_id,temp_cluster_bw, cluster_lat);
- A_surfxml_link_state = A_surfxml_link_state_ON;
- A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED;
- if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX)
- {A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_FULLDUPLEX;}
- if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FATPIPE)
- {A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_FATPIPE;}
- SURFXML_BUFFER_SET(link_id, link_id);
- SURFXML_BUFFER_SET(link_bandwidth, temp_cluster_bw);
- SURFXML_BUFFER_SET(link_latency, temp_cluster_lat);
- SURFXML_BUFFER_SET(link_bandwidth_file, "");
- SURFXML_BUFFER_SET(link_latency_file, "");
- SURFXML_BUFFER_SET(link_state_file, "");
- SURFXML_START_TAG(link);
- SURFXML_END_TAG(link);
-
- xbt_free(temp_cluster_bw);
- xbt_free(temp_cluster_lat);
- free(link_id);
- free(host_id);
+ host_id = bprintf("%s%d%s", struct_cluster->V_cluster_prefix, i, struct_cluster->V_cluster_suffix);
+ link_id = bprintf("%s_link_%d", struct_cluster->V_cluster_id, i);
+
+ A_surfxml_host_state = A_surfxml_host_state_ON;
+
+ XBT_DEBUG("<host\tid=\"%s\"\tpower=\"%f\">", host_id, struct_cluster->S_cluster_power);
+ host.V_host_id = host_id;
+ if(strcmp(struct_cluster->V_cluster_availability_file,"")){
+ xbt_dict_set(patterns, "radical", bprintf("%d", i), xbt_free);
+ char* tmp_availability_file = xbt_strdup(struct_cluster->V_cluster_availability_file);
+ xbt_str_varsubst(tmp_availability_file,patterns);
+ XBT_DEBUG("\tavailability_file=\"%s\"",tmp_availability_file);
+ host.V_host_power_trace = tmgr_trace_new(tmp_availability_file);
+ xbt_free(tmp_availability_file);
+ }
+ else
+ {
+ XBT_DEBUG("\tavailability_file=\"\"");
+ }
+ if(strcmp(struct_cluster->V_cluster_state_file,"")){
+ char *tmp_state_file = xbt_strdup(struct_cluster->V_cluster_state_file);
+ xbt_str_varsubst(tmp_state_file,patterns);
+ XBT_DEBUG("\tstate_file=\"%s\"",tmp_state_file);
+ host.V_host_state_trace = tmgr_trace_new(tmp_state_file);
+ xbt_free(tmp_state_file);
+ }
+ else
+ {
+ XBT_DEBUG("\tstate_file=\"\"");
+ }
+
+ host.V_host_power_peak = struct_cluster->S_cluster_power;
+ host.V_host_power_scale = 1.0;
+ host.V_host_core = struct_cluster->S_cluster_core;
+ host.V_host_state_initial = SURF_RESOURCE_ON;
+ host.V_host_coord = "";
+ sg_platf_new_host(&host);
+ XBT_DEBUG("</host>");
+
+ A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED;
+ if(struct_cluster->V_cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX)
+ {A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_FULLDUPLEX;}
+ if(struct_cluster->V_cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FATPIPE)
+ {A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_FATPIPE;}
+
+ XBT_DEBUG("<link\tid=\"%s\"\tbw=\"%f\"\tlat=\"%f\"/>", link_id,struct_cluster->S_cluster_bw, struct_cluster->S_cluster_lat);
+
+ struct_lnk = xbt_new0(s_surf_parsing_link_arg_t, 1);
+ struct_lnk->V_link_id = link_id;
+ struct_lnk->V_link_bandwidth = struct_cluster->S_cluster_bw;
+ struct_lnk->V_link_latency = struct_cluster->S_cluster_lat;
+ struct_lnk->V_link_bandwidth_file = NULL;
+ struct_lnk->V_link_latency_file = NULL;
+ struct_lnk->V_link_state_file = NULL;
+ struct_lnk->V_link_state = SURF_RESOURCE_ON;
+ struct_lnk->V_link_sharing_policy = A_surfxml_link_sharing_policy;
+
+ if (A_surfxml_link_sharing_policy == A_surfxml_link_sharing_policy_SHARED)
+ struct_lnk->V_policy_initial_link = SURF_LINK_SHARED;
+ else
+ {
+ if (A_surfxml_link_sharing_policy == A_surfxml_link_sharing_policy_FATPIPE)
+ struct_lnk->V_policy_initial_link = SURF_LINK_FATPIPE;
+ else if (A_surfxml_link_sharing_policy == A_surfxml_link_sharing_policy_FULLDUPLEX)
+ struct_lnk->V_policy_initial_link = SURF_LINK_FULLDUPLEX;
+ }
+ surf_parse_link();
+
+ xbt_dict_set(cluster_host_link,host_id,strdup(link_id),free);
+// XBT_INFO("key '%s' Value '%s'",host_id,link_id);
+
+ ETag_surfxml_host();
+ ETag_surfxml_link();
+
}
break;
default:
XBT_DEBUG("Malformed radical");
+ break;
}
xbt_dynar_free(&radical_ends);
}
xbt_dynar_free(&radical_elements);
+ //Make the router
XBT_DEBUG(" ");
- router_id =
- bprintf("%s%s_router%s", cluster_prefix, cluster_id,
- cluster_suffix);
- //link_router = bprintf("%s_link_%s_router", cluster_id, cluster_id);
- link_backbone = bprintf("%s_backbone", cluster_id);
-
- XBT_DEBUG("<router id=\"%s\"/>", router_id);
- SURFXML_BUFFER_SET(router_id, router_id);
+ XBT_DEBUG("<router id=\"%s\"/>", struct_cluster->S_cluster_router_id);
+ SURFXML_BUFFER_SET(router_id, struct_cluster->S_cluster_router_id);
SURFXML_BUFFER_SET(router_coordinates, "");
SURFXML_START_TAG(router);
SURFXML_END_TAG(router);
- //TODO
-// xbt_dict_set(patterns, "radical", xbt_strdup("_router"), xbt_free);
-// temp_cluster_bw = xbt_strdup(cluster_bw);
-// temp_cluster_bw = replace_random_parameter(temp_cluster_bw);
-// temp_cluster_lat = xbt_strdup(cluster_lat);
-// temp_cluster_lat = replace_random_parameter(temp_cluster_lat);
-// XBT_DEBUG("<link\tid=\"%s\" bw=\"%s\" lat=\"%s\"/>", link_router,temp_cluster_bw, temp_cluster_lat);
-// A_surfxml_link_state = A_surfxml_link_state_ON;
-// A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED;
-// if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX)
-// {A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_FULLDUPLEX;}
-// if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FATPIPE)
-// {A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_FATPIPE;}
-// SURFXML_BUFFER_SET(link_id, link_router);
-// SURFXML_BUFFER_SET(link_bandwidth, temp_cluster_bw);
-// SURFXML_BUFFER_SET(link_latency, temp_cluster_lat);
-// SURFXML_BUFFER_SET(link_bandwidth_file, "");
-// SURFXML_BUFFER_SET(link_latency_file, "");
-// SURFXML_BUFFER_SET(link_state_file, "");
-// SURFXML_START_TAG(link);
-// SURFXML_END_TAG(link);
-
-// xbt_free(temp_cluster_bw);
-// xbt_free(temp_cluster_lat);
-
- XBT_DEBUG("<link\tid=\"%s\" bw=\"%s\" lat=\"%s\"/>", link_backbone,cluster_bb_bw, cluster_bb_lat);
- A_surfxml_link_state = A_surfxml_link_state_ON;
- A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED;
- if(cluster_bb_sharing_policy == A_surfxml_cluster_bb_sharing_policy_FATPIPE)
- {A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_FATPIPE;}
- SURFXML_BUFFER_SET(link_id, link_backbone);
- SURFXML_BUFFER_SET(link_bandwidth, cluster_bb_bw);
- SURFXML_BUFFER_SET(link_latency, cluster_bb_lat);
- SURFXML_BUFFER_SET(link_bandwidth_file, "");
- SURFXML_BUFFER_SET(link_latency_file, "");
- SURFXML_BUFFER_SET(link_state_file, "");
- SURFXML_START_TAG(link);
- SURFXML_END_TAG(link);
+ //Make the backbone
+ if( (struct_cluster->S_cluster_bb_bw!= 0) && (struct_cluster->S_cluster_bb_lat!=0) ){
+ char *link_backbone = bprintf("%s_backbone", struct_cluster->V_cluster_id);
+ XBT_DEBUG("<link\tid=\"%s\" bw=\"%f\" lat=\"%f\"/>", link_backbone,struct_cluster->S_cluster_bb_bw, struct_cluster->S_cluster_bb_lat);
+
+ A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED;
+ if(AX_surfxml_cluster_bb_sharing_policy == A_surfxml_cluster_bb_sharing_policy_FATPIPE)
+ {A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_FATPIPE;}
+
+ struct_lnk = xbt_new0(s_surf_parsing_link_arg_t, 1);
+ struct_lnk->V_link_id = xbt_strdup(link_backbone);
+ struct_lnk->V_link_bandwidth = struct_cluster->S_cluster_bb_bw;
+ struct_lnk->V_link_latency = struct_cluster->S_cluster_bb_lat;
+ struct_lnk->V_link_bandwidth_file = NULL;
+ struct_lnk->V_link_latency_file = NULL;
+ struct_lnk->V_link_state_file = NULL;
+ struct_lnk->V_link_state = SURF_RESOURCE_ON;
+ struct_lnk->V_link_sharing_policy = A_surfxml_link_sharing_policy;
+
+ if (A_surfxml_link_sharing_policy == A_surfxml_link_sharing_policy_SHARED)
+ struct_lnk->V_policy_initial_link = SURF_LINK_SHARED;
+ else
+ struct_lnk->V_policy_initial_link = SURF_LINK_FATPIPE;
+
+ surf_parse_link();
+ ETag_surfxml_link();
+
+ surf_parsing_link_up_down_t info = xbt_new0(s_surf_parsing_link_up_down_t, 1);
+ info->link_up = xbt_lib_get_or_null(link_lib, link_backbone, SURF_LINK_LEVEL);
+ info->link_down = info->link_up;
+ xbt_dict_set(cluster_host_link,struct_cluster->V_cluster_id,info,xbt_free);
+ free(link_backbone);
+ }
XBT_DEBUG(" ");
-#ifdef HAVE_PCRE_LIB
char *new_suffix = xbt_strdup("");
- radical_elements = xbt_str_split(cluster_suffix, ".");
+ radical_elements = xbt_str_split(struct_cluster->V_cluster_suffix, ".");
xbt_dynar_foreach(radical_elements, iter, groups) {
if (strcmp(groups, "")) {
char *old_suffix = new_suffix;
free(old_suffix);
}
}
- route_src_dst = bprintf("%s(.*)%s", cluster_prefix, new_suffix);
- xbt_dynar_free(&radical_elements);
- free(new_suffix);
-
- char *pcre_link_src = bprintf("%s_link_$1src", cluster_id);
- char *pcre_link_backbone = bprintf("%s_backbone", cluster_id);
- char *pcre_link_dst = bprintf("%s_link_$1dst", cluster_id);
-
- //from router to router
- XBT_DEBUG("<route\tsrc=\"%s\"\tdst=\"%s\"", router_id, router_id);
- XBT_DEBUG("symmetrical=\"NO\">");
- SURFXML_BUFFER_SET(route_src, router_id);
- SURFXML_BUFFER_SET(route_dst, router_id);
- A_surfxml_route_symmetrical = A_surfxml_route_symmetrical_NO;
- SURFXML_START_TAG(route);
-
- XBT_DEBUG("<link_ctn\tid=\"%s\"/>", pcre_link_backbone);
- SURFXML_BUFFER_SET(link_ctn_id, pcre_link_backbone);
- A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE;
- SURFXML_START_TAG(link_ctn);
- SURFXML_END_TAG(link_ctn);
-
- XBT_DEBUG("</route>");
- SURFXML_END_TAG(route);
-
- //from host to router
- XBT_DEBUG("<route\tsrc=\"%s\"\tdst=\"%s\"", route_src_dst, router_id);
- XBT_DEBUG("symmetrical=\"NO\">");
- SURFXML_BUFFER_SET(route_src, route_src_dst);
- SURFXML_BUFFER_SET(route_dst, router_id);
- A_surfxml_route_symmetrical = A_surfxml_route_symmetrical_NO;
- SURFXML_START_TAG(route);
-
- XBT_DEBUG("<link_ctn\tid=\"%s\"/>", pcre_link_src);
- SURFXML_BUFFER_SET(link_ctn_id, pcre_link_src);
- A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE;
- if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX)
- {A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_UP;}
- SURFXML_START_TAG(link_ctn);
- SURFXML_END_TAG(link_ctn);
- XBT_DEBUG("<link_ctn\tid=\"%s\"/>", pcre_link_backbone);
- SURFXML_BUFFER_SET(link_ctn_id, pcre_link_backbone);
- A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE;
- SURFXML_START_TAG(link_ctn);
- SURFXML_END_TAG(link_ctn);
-
- XBT_DEBUG("</route>");
- SURFXML_END_TAG(route);
-
- //from router to host
- XBT_DEBUG("<route\tsrc=\"%s\"\tdst=\"%s\"", router_id, route_src_dst);
- XBT_DEBUG("symmetrical=\"NO\">");
- SURFXML_BUFFER_SET(route_src, router_id);
- SURFXML_BUFFER_SET(route_dst, route_src_dst);
- A_surfxml_route_symmetrical = A_surfxml_route_symmetrical_NO;
- SURFXML_START_TAG(route);
-
- XBT_DEBUG("<link_ctn\tid=\"%s\"/>", pcre_link_backbone);
- SURFXML_BUFFER_SET(link_ctn_id, pcre_link_backbone);
- A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE;
- SURFXML_START_TAG(link_ctn);
- SURFXML_END_TAG(link_ctn);
-
- XBT_DEBUG("<link_ctn\tid=\"%s\"/>", pcre_link_dst);
- SURFXML_BUFFER_SET(link_ctn_id, pcre_link_dst);
- A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE;
- if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX)
- {A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_UP;}
- SURFXML_START_TAG(link_ctn);
- SURFXML_END_TAG(link_ctn);
-
- XBT_DEBUG("</route>");
- SURFXML_END_TAG(route);
-
- //from host to host
- XBT_DEBUG("<route\tsrc=\"%s\"\tdst=\"%s\"", route_src_dst, route_src_dst);
- XBT_DEBUG("symmetrical=\"NO\">");
- SURFXML_BUFFER_SET(route_src, route_src_dst);
- SURFXML_BUFFER_SET(route_dst, route_src_dst);
- A_surfxml_route_symmetrical = A_surfxml_route_symmetrical_NO;
- SURFXML_START_TAG(route);
-
- XBT_DEBUG("<link_ctn\tid=\"%s\"/>", pcre_link_src);
- SURFXML_BUFFER_SET(link_ctn_id, pcre_link_src);
- A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE;
- if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX)
- {A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_UP;}
- SURFXML_START_TAG(link_ctn);
- SURFXML_END_TAG(link_ctn);
-
- XBT_DEBUG("<link_ctn\tid=\"%s\"/>", pcre_link_backbone);
- SURFXML_BUFFER_SET(link_ctn_id, pcre_link_backbone);
- A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE;
- SURFXML_START_TAG(link_ctn);
- SURFXML_END_TAG(link_ctn);
-
- XBT_DEBUG("<link_ctn\tid=\"%s\"/>", pcre_link_dst);
- SURFXML_BUFFER_SET(link_ctn_id, pcre_link_dst);
- A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE;
- if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX)
- {A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_DOWN;}
- SURFXML_START_TAG(link_ctn);
- SURFXML_END_TAG(link_ctn);
-
- XBT_DEBUG("</route>");
- SURFXML_END_TAG(route);
-
- free(pcre_link_dst);
- free(pcre_link_backbone);
- free(pcre_link_src);
- free(route_src_dst);
-#else
- for (i = 0; i <= xbt_dynar_length(tab_elements_num); i++) {
- for (j = 0; j <= xbt_dynar_length(tab_elements_num); j++) {
- if (i == xbt_dynar_length(tab_elements_num)) {
- route_src = router_id;
- } else {
- route_src =
- bprintf("%s%d%s", cluster_prefix,
- xbt_dynar_get_as(tab_elements_num, i, int),
- cluster_suffix);
- }
-
- if (j == xbt_dynar_length(tab_elements_num)) {
- route_dst = router_id;
- } else {
- route_dst =
- bprintf("%s%d%s", cluster_prefix,
- xbt_dynar_get_as(tab_elements_num, j, int),
- cluster_suffix);
- }
-
- XBT_DEBUG("<route\tsrc=\"%s\"\tdst=\"%s\"", route_src, route_dst);
- XBT_DEBUG("symmetrical=\"NO\">");
- SURFXML_BUFFER_SET(route_src, route_src);
- SURFXML_BUFFER_SET(route_dst, route_dst);
- A_surfxml_route_symmetrical = A_surfxml_route_symmetrical_NO;
- SURFXML_START_TAG(route);
-
- if (i != xbt_dynar_length(tab_elements_num)){
- route_src =
- bprintf("%s_link_%d", cluster_id,
- xbt_dynar_get_as(tab_elements_num, i, int));
- XBT_DEBUG("<link_ctn\tid=\"%s\"/>", route_src);
- SURFXML_BUFFER_SET(link_ctn_id, route_src);
- A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE;
- if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX)
- {A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_UP;}
- SURFXML_START_TAG(link_ctn);
- SURFXML_END_TAG(link_ctn);
- free(route_src);
- }
-
- XBT_DEBUG("<link_ctn\tid=\"%s_backbone\"/>", cluster_id);
- SURFXML_BUFFER_SET(link_ctn_id, bprintf("%s_backbone", cluster_id));
- A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE;
- SURFXML_START_TAG(link_ctn);
- SURFXML_END_TAG(link_ctn);
-
- if (j != xbt_dynar_length(tab_elements_num)) {
- route_dst =
- bprintf("%s_link_%d", cluster_id,
- xbt_dynar_get_as(tab_elements_num, j, int));
- XBT_DEBUG("<link_ctn\tid=\"%s\"/>", route_dst);
- SURFXML_BUFFER_SET(link_ctn_id, route_dst);
- A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE;
- if(cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX)
- {A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_DOWN;}
- SURFXML_START_TAG(link_ctn);
- SURFXML_END_TAG(link_ctn);
- free(route_dst);
- }
-
- XBT_DEBUG("</route>");
- SURFXML_END_TAG(route);
- }
- }
- xbt_dynar_free(&tab_elements_num);
-
-#endif
+ xbt_dynar_free(&radical_elements);
+ xbt_free(new_suffix);
- free(router_id);
- free(link_backbone);
- //free(link_router);
- xbt_dict_free(&patterns);
- free(availability_file);
- free(state_file);
+ if( strcmp(struct_cluster->V_cluster_availability_file,"")
+ || strcmp(struct_cluster->V_cluster_state_file,"") )
+ xbt_dict_free(&patterns);
XBT_DEBUG("</AS>");
SURFXML_END_TAG(AS);
return string;
}
-static void clean_dict_random(void)
+static void clean_routing_after_parse(void)
{
xbt_dict_free(&random_value);
xbt_dict_free(&patterns);
static void routing_parse_Speer(void)
{
static int AX_ptr = 0;
-
- char *peer_id = A_surfxml_peer_id;
- char *peer_power = A_surfxml_peer_power;
- char *peer_bw_in = A_surfxml_peer_bw_in;
- char *peer_bw_out = A_surfxml_peer_bw_out;
- char *peer_lat = A_surfxml_peer_lat;
- char *peer_coord = A_surfxml_peer_coordinates;
- char *peer_state_file = A_surfxml_peer_state_file;
- char *peer_availability_file = A_surfxml_peer_availability_file;
-
char *host_id = NULL;
char *router_id, *link_router, *link_backbone, *link_id_up, *link_id_down;
surfxml_bufferstack_push(1);
- SURFXML_BUFFER_SET(AS_id, peer_id);
+ SURFXML_BUFFER_SET(AS_id, struct_peer->V_peer_id);
SURFXML_BUFFER_SET(AS_routing, "Full");
- XBT_DEBUG("<AS id=\"%s\"\trouting=\"Full\">", peer_id);
+ XBT_DEBUG("<AS id=\"%s\"\trouting=\"Full\">", struct_peer->V_peer_id);
SURFXML_START_TAG(AS);
XBT_DEBUG(" ");
- host_id = bprintf("peer_%s", peer_id);
- router_id = bprintf("router_%s", peer_id);
- link_id_up = bprintf("link_%s_up", peer_id);
- link_id_down = bprintf("link_%s_down", peer_id);
+ host_id = bprintf("peer_%s", struct_peer->V_peer_id);
+ router_id = bprintf("router_%s", struct_peer->V_peer_id);
+ link_id_up = bprintf("link_%s_up", struct_peer->V_peer_id);
+ link_id_down = bprintf("link_%s_down", struct_peer->V_peer_id);
- link_router = bprintf("%s_link_router", peer_id);
- link_backbone = bprintf("%s_backbone", peer_id);
+ link_router = bprintf("%s_link_router", struct_peer->V_peer_id);
+ link_backbone = bprintf("%s_backbone", struct_peer->V_peer_id);
- XBT_DEBUG("<host\tid=\"%s\"\tpower=\"%s\"/>", host_id, peer_power);
+ XBT_DEBUG("<host\tid=\"%s\"\tpower=\"%s\"/>", host_id, struct_peer->V_peer_power);
A_surfxml_host_state = A_surfxml_host_state_ON;
SURFXML_BUFFER_SET(host_id, host_id);
- SURFXML_BUFFER_SET(host_power, peer_power);
+ SURFXML_BUFFER_SET(host_power, struct_peer->V_peer_power);
SURFXML_BUFFER_SET(host_availability, "1.0");
- SURFXML_BUFFER_SET(host_availability_file, peer_availability_file);
- SURFXML_BUFFER_SET(host_state_file, peer_state_file);
+ SURFXML_BUFFER_SET(host_availability_file, struct_peer->V_peer_availability_trace);
+ SURFXML_BUFFER_SET(host_state_file, struct_peer->V_peer_state_trace);
SURFXML_BUFFER_SET(host_coordinates, "");
+ SURFXML_BUFFER_SET(host_core, "1.0");
SURFXML_START_TAG(host);
SURFXML_END_TAG(host);
- XBT_DEBUG("<router id=\"%s\"\tcoordinates=\"%s\"/>", router_id, peer_coord);
+ XBT_DEBUG("<router id=\"%s\"\tcoordinates=\"%s\"/>", router_id, struct_peer->V_peer_coord);
SURFXML_BUFFER_SET(router_id, router_id);
- SURFXML_BUFFER_SET(router_coordinates, peer_coord);
+ SURFXML_BUFFER_SET(router_coordinates, struct_peer->V_peer_coord);
SURFXML_START_TAG(router);
SURFXML_END_TAG(router);
- XBT_DEBUG("<link\tid=\"%s\"\tbw=\"%s\"\tlat=\"%s\"/>", link_id_up, peer_bw_in, peer_lat);
+ XBT_DEBUG("<link\tid=\"%s\"\tbw=\"%s\"\tlat=\"%s\"/>", link_id_up, struct_peer->V_peer_bw_in, struct_peer->V_peer_lat);
A_surfxml_link_state = A_surfxml_link_state_ON;
A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED;
SURFXML_BUFFER_SET(link_id, link_id_up);
- SURFXML_BUFFER_SET(link_bandwidth, peer_bw_in);
- SURFXML_BUFFER_SET(link_latency, peer_lat);
+ SURFXML_BUFFER_SET(link_bandwidth, struct_peer->V_peer_bw_in);
+ SURFXML_BUFFER_SET(link_latency, struct_peer->V_peer_lat);
SURFXML_BUFFER_SET(link_bandwidth_file, "");
SURFXML_BUFFER_SET(link_latency_file, "");
SURFXML_BUFFER_SET(link_state_file, "");
SURFXML_START_TAG(link);
SURFXML_END_TAG(link);
- XBT_DEBUG("<link\tid=\"%s\"\tbw=\"%s\"\tlat=\"%s\"/>", link_id_down, peer_bw_out, peer_lat);
+ XBT_DEBUG("<link\tid=\"%s\"\tbw=\"%s\"\tlat=\"%s\"/>", link_id_down, struct_peer->V_peer_bw_out, struct_peer->V_peer_lat);
A_surfxml_link_state = A_surfxml_link_state_ON;
A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED;
SURFXML_BUFFER_SET(link_id, link_id_down);
- SURFXML_BUFFER_SET(link_bandwidth, peer_bw_out);
- SURFXML_BUFFER_SET(link_latency, peer_lat);
+ SURFXML_BUFFER_SET(link_bandwidth, struct_peer->V_peer_bw_out);
+ SURFXML_BUFFER_SET(link_latency, struct_peer->V_peer_lat);
SURFXML_BUFFER_SET(link_bandwidth_file, "");
SURFXML_BUFFER_SET(link_latency_file, "");
SURFXML_BUFFER_SET(link_state_file, "");
char *random_radical = A_surfxml_random_radical;
char *rd_name = NULL;
char *rd_value;
- surf_parse_get_double(&mean,A_surfxml_random_mean);
- surf_parse_get_double(&std,A_surfxml_random_std_deviation);
- surf_parse_get_double(&min,A_surfxml_random_min);
- surf_parse_get_double(&max,A_surfxml_random_max);
- surf_parse_get_double(&seed,A_surfxml_random_seed);
+ mean = surf_parse_get_double(A_surfxml_random_mean);
+ std = surf_parse_get_double(A_surfxml_random_std_deviation);
+ min = surf_parse_get_double(A_surfxml_random_min);
+ max = surf_parse_get_double(A_surfxml_random_max);
+ seed = surf_parse_get_double(A_surfxml_random_seed);
double res = 0;
int i = 0;
xbt_free(tmpbuf);
break;
- case 2: surf_parse_get_int(&start,
- xbt_dynar_get_as(radical_ends, 0, char *));
- surf_parse_get_int(&end, xbt_dynar_get_as(radical_ends, 1, char *));
+ case 2:
+ start = surf_parse_get_int(xbt_dynar_get_as(radical_ends, 0, char *));
+ end = surf_parse_get_int(xbt_dynar_get_as(radical_ends, 1, char *));
for (i = start; i <= end; i++) {
xbt_assert(!xbt_dict_get_or_null(random_value,random_id),"Custom Random '%s' already exists !",bprintf("%s%d",random_id,i));
res = random_generate(random);
break;
default:
XBT_INFO("Malformed radical");
+ break;
}
res = random_generate(random);
rd_name = bprintf("%s_router",random_id);
static void routing_parse_Erandom(void)
{
- xbt_dict_cursor_t cursor = NULL;
+ /*xbt_dict_cursor_t cursor = NULL;
char *key;
char *elem;
xbt_dict_foreach(random_value, cursor, key, elem) {
XBT_DEBUG("%s = %s",key,elem);
}
-
+*/
}
-
/*
* New methods to init the routing model component from the lua script
*/
-/*
- * calling parse_S_AS_lua with lua values
- */
-void routing_AS_init(const char *AS_id, const char *AS_routing)
-{
- parse_S_AS_lua((char *) AS_id, (char *) AS_routing);
-}
-
-/*
- * calling parse_E_AS_lua to fisnish the creation of routing component
- */
-void routing_AS_end(const char *AS_id)
-{
- parse_E_AS_lua((char *) AS_id);
-}
/*
* add a host to the network element list
