#include "xbt/config.h"
#include "xbt/graph.h"
#include "xbt/set.h"
+#include "surf/surfxml_parse.h"
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_route, surf, "Routing part of surf");
}
-static double vivaldi_get_link_latency (routing_component_t rc,
- const char *src, const char *dst)
+static double vivaldi_get_link_latency (routing_component_t rc,const char *src, const char *dst)
{
double euclidean_dist;
xbt_dynar_t src_ctn, dst_ctn;
info->rc_type = SURF_NETWORK_ELEMENT_ROUTER;
xbt_dict_set(global_routing->where_network_elements, A_surfxml_router_id,
(void *) info, xbt_free);
-#ifdef HAVE_TRACING
- TRACE_surf_host_declaration(A_surfxml_router_id, 0);
-#endif
if (strcmp(A_surfxml_router_coordinates,"")) {
xbt_dynar_t ctn = xbt_str_split_str(A_surfxml_router_coordinates, " ");
xbt_dynar_shrink(ctn,0);
static void parse_S_AS_XML(void)
{
parse_S_AS(A_surfxml_AS_id, A_surfxml_AS_routing);
+
+ if (strcmp(A_surfxml_AS_coordinates,"")) {
+ DEBUG2("%s coordinates : %s",A_surfxml_AS_id,A_surfxml_AS_coordinates);
+ xbt_dynar_t ctn = xbt_str_split_str(A_surfxml_AS_coordinates, " ");
+ xbt_dynar_shrink(ctn,0);
+ xbt_dict_set (coordinates,A_surfxml_AS_id,ctn,NULL);
+ }
}
/*
/* Aux Business methods */
+/**
+ * \brief Get the AS name of the element
+ *
+ * \param name the host name
+ *
+ */
+static char* elements_As_name(const char *name)
+{
+ routing_component_t as_comp;
+
+ /* (1) find the as where the host is located */
+ as_comp = ((network_element_info_t)
+ xbt_dict_get_or_null(global_routing->where_network_elements,
+ name))->rc_component;
+ return as_comp->name;
+}
+
+
/**
* \brief Get the AS father and the first elements of the chain
*
double latency, latency_src, latency_dst = 0.0;
DEBUG2("Solve route \"%s\" to \"%s\"", src, dst);
-
xbt_assert0(src && dst, "bad parameters for \"_get_route\" method");
route_extended_t e_route_cnt;
} else latency = 0;
} else { /* SURF_ROUTING_RECURSIVE */
route_extended_t e_route_bypass = NULL;
-
if (common_father->get_bypass_route)
e_route_bypass =
(*(common_father->get_bypass_route)) (common_father, src, dst);
"bad gateway for route between \"%s\" and \"%s\"", src,
dst);
latency =
- (*(common_father->get_latency)) (common_father, e_route_cnt->src_gateway,
- e_route_cnt->src_gateway);
+ (*(common_father->get_latency)) (common_father, elements_As_name(src),
+ elements_As_name(dst));
+
xbt_assert2(latency>=0, "no route between \"%s\" and \"%s\"",
src_father->name, dst_father->name);
*/
void routing_model_create(size_t size_of_links, void *loopback, double_f_cpvoid_t get_link_latency_fun)
{
-
/* config the uniq global routing */
global_routing = xbt_new0(s_routing_global_t, 1);
global_routing->where_network_elements = xbt_dict_new();
surfxml_add_callback(STag_surfxml_peer_cb_list,
&routing_parse_Speer);
- surfxml_add_callback(STag_surfxml_config_cb_list,
- &routing_parse_Sconfig);
- surfxml_add_callback(ETag_surfxml_config_cb_list,
- &routing_parse_Econfig);
+#ifdef HAVE_TRACING
+ instr_routing_define_callbacks();
+#endif
+}
+
+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);
+ surfxml_add_callback(STag_surfxml_AS_cb_list, &surf_parse_models_setup);
+}
+
+void surf_parse_models_setup()
+{
+ surfxml_del_callback(STag_surfxml_AS_cb_list, surf_parse_models_setup);
+ surf_config_models_setup(platform_filename);
+ free(platform_filename);
}
/* ************************************************************************** */
new_component->generic_routing.finalize = full_finalize;
new_component->generic_routing.to_index = xbt_dict_new();
new_component->generic_routing.bypassRoutes = xbt_dict_new();
+ new_component->generic_routing.get_network_element_type = get_network_element_type;
return new_component;
}
(void*)TO_ROUTE_FULL(*src_id, *dst_id)->generic_route.link_list,
(void*)link_route_to_test,
(int_f_cpvoid_cpvoid_t) surf_pointer_resource_cmp),
- "The route between \"%s\" and \"%s\" already exists", src,dst);
+ "The route between \"%s\" and \"%s\" already exists. If you are trying to define a reverse route, you must set the symmetrical=no attribute to your routes tags.", src,dst);
xbt_dynar_free(&link_route_to_test);
}
else
new_component->generic_routing.finalize = floyd_finalize;
new_component->generic_routing.to_index = xbt_dict_new();
new_component->generic_routing.bypassRoutes = xbt_dict_new();
+ new_component->generic_routing.get_network_element_type = get_network_element_type;
return new_component;
}
int dst_id, route_extended_t e_route)
{
routing_component_dijkstra_t routing = (routing_component_dijkstra_t) rc;
-
+ DEBUG2("Load Route from \"%d\" to \"%d\"", src_id, dst_id);
xbt_node_t src = NULL;
xbt_node_t dst = NULL;
+
graph_node_map_element_t src_elm = (graph_node_map_element_t)
xbt_dict_get_or_null_ext(routing->graph_node_map,
(char *) (&src_id),
(char *) (&dst_id),
sizeof(int));
+
if (src_elm)
src = src_elm->node;
new_component->cached = cached;
new_component->generic_routing.to_index = xbt_dict_new();
new_component->generic_routing.bypassRoutes = xbt_dict_new();
+ new_component->generic_routing.get_network_element_type = get_network_element_type;
return new_component;
}
xbt_dynar_t nodes = NULL;
/* Create the topology graph */
+ if(!routing->route_graph)
routing->route_graph = xbt_graph_new_graph(1, NULL);
+ if(!routing->graph_node_map)
routing->graph_node_map = xbt_dict_new();
if (routing->cached && !routing->route_cache)
- routing->route_cache = xbt_dict_new();
+ routing->route_cache = xbt_dict_new();
/* Add the loopback if needed */
if (current_routing->hierarchy == SURF_ROUTING_BASE)
src_id = xbt_dict_get_or_null(rc->to_index, src);
dst_id = xbt_dict_get_or_null(rc->to_index, dst);
+ /* Create the topology graph */
+ if(!routing->route_graph)
+ routing->route_graph = xbt_graph_new_graph(1, NULL);
+ if(!routing->graph_node_map)
+ routing->graph_node_map = xbt_dict_new();
+
if (routing->cached && !routing->route_cache)
routing->route_cache = xbt_dict_new();
new_component->generic_routing.get_latency = generic_get_link_latency;
new_component->generic_routing.get_bypass_route = rulebased_get_bypass_route;
new_component->generic_routing.finalize = rulebased_finalize;
+ new_component->generic_routing.get_network_element_type = get_network_element_type;
/* initialization of internal structures */
new_component->dict_processing_units = xbt_dict_new();
new_component->dict_autonomous_systems = xbt_dict_new();
static void routing_parse_Sconfig(void)
{
- //TODO
- DEBUG0("WARNING tag config not yet implemented.");
- DEBUG1("Configuration name = %s",A_surfxml_config_id);
+ DEBUG1("START configuration name = %s",A_surfxml_config_id);
}
static void routing_parse_Econfig(void)
{
- //TODO
xbt_dict_cursor_t cursor = NULL;
char *key;
char *elem;
+ char *cfg;
xbt_dict_foreach(current_property_set, cursor, key, elem) {
- DEBUG2("property : %s = %s",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
+ INFO1("The custom configuration '%s' is already define by user!",key);
}
+ DEBUG1("End configuration name = %s",A_surfxml_config_id);
}
static void routing_parse_Scluster(void)
char *cluster_state_file = A_surfxml_cluster_state_file;
char *host_id, *groups, *link_id = NULL;
char *router_id, *link_router, *link_backbone;
- char *host_availability_file = NULL;
- char *host_state_file = NULL;
char *availability_file = bprintf("%s",cluster_availability_file);
char *state_file = bprintf("%s",cluster_state_file);
SURFXML_START_TAG(link);
SURFXML_END_TAG(link);
- DEBUG3("<link\tid=\"%s\" bw=\"%s\" lat=\"%s\"/>", link_backbone,cluster_bw, cluster_lat);
+ DEBUG3("<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)
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_coordinates, peer_coord);
#ifdef HAVE_PCRE_LIB
SURFXML_BUFFER_SET(AS_routing, "RuleBased");
DEBUG1("<AS id=\"%s\"\trouting=\"RuleBased\">", peer_id);
SURFXML_BUFFER_SET(host_id, host_id);
SURFXML_BUFFER_SET(host_power, peer_power);
SURFXML_BUFFER_SET(host_availability, "1.0");
- SURFXML_BUFFER_SET(host_availability_file, "");
- SURFXML_BUFFER_SET(host_state_file, "");
+ SURFXML_BUFFER_SET(host_availability_file, peer_availability_file);
+ SURFXML_BUFFER_SET(host_state_file, peer_state_file);
SURFXML_START_TAG(host);
SURFXML_END_TAG(host);