static void routing_parse_peer(sg_platf_peer_cbarg_t peer); /* peer bypass */
static void routing_parse_Srandom(void); /* random bypass */
-static char *replace_random_parameter(char *chaine);
static void routing_parse_postparse(void);
/* this lines are only for replace use like index in the model table */
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);
+ current_routing->parse_PU(current_routing, host->id);
info = xbt_new0(s_network_element_info_t, 1);
info->rc_component = current_routing;
info->rc_type = SURF_NETWORK_ELEMENT_HOST;
"Reading a router, processing unit \"%s\" already exists",
router->id);
- (*(current_routing->parse_PU)) (current_routing, router->id);
+ current_routing->parse_PU(current_routing, router->id);
info = xbt_new0(s_network_element_info_t, 1);
info->rc_component = current_routing;
info->rc_type = SURF_NETWORK_ELEMENT_ROUTER;
xbt_assert(current_routing->parse_route,
"no defined method \"set_route\" in \"%s\"",
current_routing->name);
- (*(current_routing->parse_route)) (current_routing, src, dst, route);
+ current_routing->parse_route(current_routing, src, dst, route);
link_list = NULL;
src = NULL;
dst = NULL;
xbt_assert(current_routing->parse_ASroute,
"no defined method \"set_ASroute\" in \"%s\"",
current_routing->name);
- (*(current_routing->parse_ASroute)) (current_routing, src, dst, e_route);
+ current_routing->parse_ASroute(current_routing, src, dst, e_route);
link_list = NULL;
src = NULL;
dst = NULL;
xbt_assert(current_routing->parse_bypassroute,
"Bypassing mechanism not implemented by routing '%s'",
current_routing->name);
- (*(current_routing->parse_bypassroute)) (current_routing, src, dst, e_route);
+ current_routing->parse_bypassroute(current_routing, src, dst, e_route);
link_list = NULL;
src = NULL;
dst = NULL;
*/
void routing_AS_begin(const char *AS_id, const char *wanted_routing_type)
{
- AS_t new_routing;
+ AS_t new_as;
routing_model_description_t model = NULL;
int cpt;
}
/* make a new routing component */
- new_routing = (AS_t) (*(model->create)) ();
- new_routing->routing = model;
- new_routing->hierarchy = SURF_ROUTING_NULL;
- new_routing->name = xbt_strdup(AS_id);
- new_routing->routing_sons = xbt_dict_new();
+ new_as = (AS_t) model->create();
+ new_as->model_desc = model;
+ new_as->hierarchy = SURF_ROUTING_NULL;
+ new_as->name = xbt_strdup(AS_id);
if (current_routing == NULL && global_routing->root == NULL) {
/* it is the first one */
- new_routing->routing_father = NULL;
- global_routing->root = new_routing;
+ new_as->routing_father = NULL;
+ global_routing->root = new_as;
} else if (current_routing != NULL && global_routing->root != NULL) {
(current_routing->routing_sons, AS_id),
"The AS \"%s\" already exists", AS_id);
/* it is a part of the tree */
- new_routing->routing_father = current_routing;
+ new_as->routing_father = current_routing;
/* set the father behavior */
if (current_routing->hierarchy == SURF_ROUTING_NULL)
current_routing->hierarchy = SURF_ROUTING_RECURSIVE;
/* add to the sons dictionary */
xbt_dict_set(current_routing->routing_sons, AS_id,
- (void *) new_routing, NULL);
+ (void *) new_as, NULL);
/* add to the father element list */
- (*(current_routing->parse_AS)) (current_routing, AS_id);
+ current_routing->parse_AS(current_routing, AS_id);
} else {
THROWF(arg_error, 0, "All defined components must be belong to a AS");
}
/* set the new current component of the tree */
- current_routing = new_routing;
+ current_routing = new_as;
}
/**
xbt_lib_set(as_router_lib, current_routing->name, ROUTING_ASR_LEVEL,
(void *) info);
- if (current_routing->routing->end)
- (*(current_routing->routing->end)) (current_routing);
+ if (current_routing->model_desc->end)
+ current_routing->model_desc->end(current_routing);
current_routing = current_routing->routing_father;
}
}
* This function is called by "get_route" and "get_latency". It allows to walk
* recursively through the routing components tree.
*/
-static void _get_route_latency(const char *src, const char *dst,
- xbt_dynar_t * route, double *latency)
+static void _get_route_and_latency(const char *src, const char *dst,
+ 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");
double latency_src;
xbt_dynar_t route_src;
- _get_route_latency(src, e_route_cnt->src_gateway,
+ _get_route_and_latency(src, e_route_cnt->src_gateway,
(route ? &route_src : NULL),
(latency ? &latency_src : NULL));
if (route) {
double latency_dst;
xbt_dynar_t route_dst;
- _get_route_latency(e_route_cnt->dst_gateway, dst,
+ _get_route_and_latency(e_route_cnt->dst_gateway, dst,
(route ? &route_dst : NULL),
(latency ? &latency_dst : NULL));
if (route) {
/**
* \brief Generic function for get_route, get_route_no_cleanup, and get_latency
*/
-static void get_route_latency(const char *src, const char *dst,
+void routing_get_route_and_latency(const char *src, const char *dst,
xbt_dynar_t * route, double *latency, int cleanup)
{
static xbt_dynar_t last_route = NULL;
- _get_route_latency(src, dst, route, latency);
+ _get_route_and_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);
*/
xbt_dynar_t routing_get_route(const char *src, const char *dst) {
xbt_dynar_t route = NULL;
- get_route_latency(src, dst, &route, NULL, 1);
+ routing_get_route_and_latency(src, dst, &route, NULL, 1);
return route;
}
static xbt_dynar_t get_route_no_cleanup(const char *src, const char *dst)
{
xbt_dynar_t route = NULL;
- get_route_latency(src, dst, &route, NULL, 0);
+ routing_get_route_and_latency(src, dst, &route, NULL, 0);
return route;
}
global_routing->root = NULL;
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->loopback = loopback;
global_routing->size_of_link = size_of_links;
/* no current routing at moment */
/* ************************* GENERIC PARSE FUNCTIONS ************************ */
-static void routing_parse_cluster(void)
+static void routing_parse_cluster(sg_platf_cluster_cbarg_t cluster)
{
char *host_id, *groups, *link_id = NULL;
xbt_dict_t patterns = NULL;
s_sg_platf_host_cbarg_t host;
s_sg_platf_link_cbarg_t link;
- if (strcmp(struct_cluster->availability_trace, "")
- || strcmp(struct_cluster->state_trace, "")) {
- patterns = xbt_dict_new();
- xbt_dict_set(patterns, "id", xbt_strdup(struct_cluster->id), free);
- xbt_dict_set(patterns, "prefix", xbt_strdup(struct_cluster->prefix), free);
- xbt_dict_set(patterns, "suffix", xbt_strdup(struct_cluster->suffix), free);
- }
-
unsigned int iter;
int start, end, i;
xbt_dynar_t radical_elements;
xbt_dynar_t radical_ends;
- XBT_DEBUG("<AS id=\"%s\"\trouting=\"Cluster\">", struct_cluster->id);
- sg_platf_new_AS_begin(struct_cluster->id, "Cluster");
+ if (strcmp(cluster->availability_trace, "")
+ || strcmp(cluster->state_trace, "")) {
+ patterns = xbt_dict_new();
+ xbt_dict_set(patterns, "id", xbt_strdup(cluster->id), free);
+ xbt_dict_set(patterns, "prefix", xbt_strdup(cluster->prefix), free);
+ xbt_dict_set(patterns, "suffix", xbt_strdup(cluster->suffix), free);
+ }
+
+
+ XBT_DEBUG("<AS id=\"%s\"\trouting=\"Cluster\">", cluster->id);
+ sg_platf_new_AS_begin(cluster->id, "Cluster");
//Make all hosts
- radical_elements = xbt_str_split(struct_cluster->radical, ",");
+ radical_elements = xbt_str_split(cluster->radical, ",");
xbt_dynar_foreach(radical_elements, iter, groups) {
- memset(&host, 0, sizeof(host));
radical_ends = xbt_str_split(groups, "-");
start = surf_parse_get_int(xbt_dynar_get_as(radical_ends, 0, char *));
}
for (i = start; i <= end; i++) {
host_id =
- bprintf("%s%d%s", struct_cluster->prefix, i, struct_cluster->suffix);
- link_id = bprintf("%s_link_%d", struct_cluster->id, i);
+ bprintf("%s%d%s", cluster->prefix, i, cluster->suffix);
+ link_id = bprintf("%s_link_%d", cluster->id, i);
- XBT_DEBUG("<host\tid=\"%s\"\tpower=\"%f\">", host_id,
- struct_cluster->power);
+ XBT_DEBUG("<host\tid=\"%s\"\tpower=\"%f\">", host_id, cluster->power);
+
+ memset(&host, 0, sizeof(host));
host.id = host_id;
- if (strcmp(struct_cluster->availability_trace, "")) {
+ if (strcmp(cluster->availability_trace, "")) {
xbt_dict_set(patterns, "radical", bprintf("%d", i), xbt_free);
- char *tmp_availability_file =
- xbt_str_varsubst(struct_cluster->availability_trace, patterns);
- XBT_DEBUG("\tavailability_file=\"%s\"", tmp_availability_file);
- host.power_trace = tmgr_trace_new(tmp_availability_file);
- xbt_free(tmp_availability_file);
+ char *avail_file = xbt_str_varsubst(cluster->availability_trace, patterns);
+ XBT_DEBUG("\tavailability_file=\"%s\"", avail_file);
+ host.power_trace = tmgr_trace_new(avail_file);
+ xbt_free(avail_file);
} else {
XBT_DEBUG("\tavailability_file=\"\"");
}
- if (strcmp(struct_cluster->state_trace, "")) {
- char *tmp_state_file =
- xbt_str_varsubst(struct_cluster->state_trace, patterns);
- XBT_DEBUG("\tstate_file=\"%s\"", tmp_state_file);
- host.state_trace = tmgr_trace_new(tmp_state_file);
- xbt_free(tmp_state_file);
+
+ if (strcmp(cluster->state_trace, "")) {
+ char *avail_file = xbt_str_varsubst(cluster->state_trace, patterns);
+ XBT_DEBUG("\tstate_file=\"%s\"", avail_file);
+ host.state_trace = tmgr_trace_new(avail_file);
+ xbt_free(avail_file);
} else {
XBT_DEBUG("\tstate_file=\"\"");
}
- host.power_peak = struct_cluster->power;
+ host.power_peak = cluster->power;
host.power_scale = 1.0;
- host.core_amount = struct_cluster->core_amount;
+ host.core_amount = cluster->core_amount;
host.initial_state = SURF_RESOURCE_ON;
host.coord = "";
sg_platf_new_host(&host);
XBT_DEBUG("</host>");
XBT_DEBUG("<link\tid=\"%s\"\tbw=\"%f\"\tlat=\"%f\"/>", link_id,
- struct_cluster->bw, struct_cluster->lat);
+ cluster->bw, cluster->lat);
memset(&link, 0, sizeof(link));
link.id = link_id;
- link.bandwidth = struct_cluster->bw;
- link.latency = struct_cluster->lat;
+ link.bandwidth = cluster->bw;
+ link.latency = cluster->lat;
link.state = SURF_RESOURCE_ON;
-
- switch (struct_cluster->sharing_policy) {
- case A_surfxml_cluster_sharing_policy_SHARED:
- link.policy = SURF_LINK_SHARED;
- break;
- case A_surfxml_cluster_sharing_policy_FULLDUPLEX:
- link.policy = SURF_LINK_FULLDUPLEX;
- break;
- case A_surfxml_cluster_sharing_policy_FATPIPE:
- link.policy = SURF_LINK_FATPIPE;
- break;
- default:
- surf_parse_error(bprintf
- ("Invalid cluster sharing policy for cluster %s",
- struct_cluster->id));
- break;
- }
+ link.policy = cluster->sharing_policy;
sg_platf_new_link(&link);
surf_parsing_link_up_down_t info =
}
xbt_dynar_free(&radical_elements);
- // Add a router. It is magically used thanks to the way in which surf_routing_cluster is written, and it's very useful to connect clusters together
+ // Add a router. It is magically used thanks to the way in which surf_routing_cluster is written,
+ // and it's very useful to connect clusters together
XBT_DEBUG(" ");
- XBT_DEBUG("<router id=\"%s\"/>", struct_cluster->router_id);
- s_sg_platf_router_cbarg_t router;
+ XBT_DEBUG("<router id=\"%s\"/>", cluster->router_id);
char *newid = NULL;
+ s_sg_platf_router_cbarg_t router;
memset(&router, 0, sizeof(router));
- router.id = struct_cluster->router_id;
+ router.id = cluster->router_id;
router.coord = "";
if (!router.id || !strcmp(router.id, ""))
router.id = newid =
- bprintf("%s%s_router%s", struct_cluster->prefix, struct_cluster->id,
- struct_cluster->suffix);
+ bprintf("%s%s_router%s", cluster->prefix, cluster->id,
+ cluster->suffix);
sg_platf_new_router(&router);
free(newid);
//Make the backbone
- if ((struct_cluster->bb_bw != 0) && (struct_cluster->bb_lat != 0)) {
- char *link_backbone = bprintf("%s_backbone", struct_cluster->id);
+ if ((cluster->bb_bw != 0) && (cluster->bb_lat != 0)) {
+ char *link_backbone = bprintf("%s_backbone", cluster->id);
XBT_DEBUG("<link\tid=\"%s\" bw=\"%f\" lat=\"%f\"/>", link_backbone,
- struct_cluster->bb_bw, struct_cluster->bb_lat);
+ cluster->bb_bw, cluster->bb_lat);
memset(&link, 0, sizeof(link));
link.id = link_backbone;
- link.bandwidth = struct_cluster->bb_bw;
- link.latency = struct_cluster->bb_lat;
+ link.bandwidth = cluster->bb_bw;
+ link.latency = cluster->bb_lat;
link.state = SURF_RESOURCE_ON;
-
- switch (struct_cluster->bb_sharing_policy) {
- case A_surfxml_cluster_bb_sharing_policy_FATPIPE:
- link.policy = SURF_LINK_FATPIPE;
- break;
- case A_surfxml_cluster_bb_sharing_policy_SHARED:
- link.policy = SURF_LINK_SHARED;
- break;
- default:
- surf_parse_error(bprintf
- ("Invalid bb sharing policy in cluster %s",
- struct_cluster->id));
- break;
- }
+ link.policy = cluster->bb_sharing_policy;
sg_platf_new_link(&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;
- surf_routing_cluster_add_link(struct_cluster->id, info);
+ surf_routing_cluster_add_backbone(current_routing, xbt_lib_get_or_null(link_lib, link_backbone, SURF_LINK_LEVEL));
free(link_backbone);
}
- XBT_DEBUG(" ");
-
- char *new_suffix = xbt_strdup("");
-
- radical_elements = xbt_str_split(struct_cluster->suffix, ".");
- xbt_dynar_foreach(radical_elements, iter, groups) {
- if (strcmp(groups, "")) {
- char *old_suffix = new_suffix;
- new_suffix = bprintf("%s\\.%s", old_suffix, groups);
- free(old_suffix);
- }
- }
-
- xbt_dynar_free(&radical_elements);
- xbt_free(new_suffix);
-
XBT_DEBUG("</AS>");
sg_platf_new_AS_end();
XBT_DEBUG(" ");
random_id, random->min, random->max, random->mean, random->std,
random->generator, random->seed, random_radical);
- if (xbt_dict_size(random_value) == 0)
+ if (!random_value)
random_value = xbt_dict_new();
if (!strcmp(random_radical, "")) {
surfxml_add_callback(ETag_surfxml_bypassRoute_cb_list,
&routing_parse_E_bypassRoute);
- surfxml_add_callback(STag_surfxml_cluster_cb_list, &routing_parse_cluster);
+ sg_platf_cluster_add_cb(routing_parse_cluster);
sg_platf_peer_add_cb(routing_parse_peer);
sg_platf_postparse_add_cb(routing_parse_postparse);
char *key;
AS_t elem;
- xbt_dict_foreach(as->routing_sons, cursor, key, elem)
- finalize_rec(elem);
+ xbt_dict_foreach(as->routing_sons, cursor, key, elem) {
+ finalize_rec(elem);
+ }
- xbt_dict_free(&as->routing_sons);
- xbt_free(as->name);
as->finalize(as);
}