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;
}
/* make a new routing component */
- new_as = (AS_t) (*(model->create)) ();
+ new_as = (AS_t) model->create();
new_as->model_desc = model;
new_as->hierarchy = SURF_ROUTING_NULL;
new_as->name = xbt_strdup(AS_id);
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);
+ current_routing->parse_AS(current_routing, AS_id);
} else {
THROWF(arg_error, 0, "All defined components must be belong to a AS");
}
(void *) info);
if (current_routing->model_desc->end)
- (*(current_routing->model_desc->end)) (current_routing);
+ current_routing->model_desc->end(current_routing);
current_routing = current_routing->routing_father;
}
}
/* ************************* 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(" ");
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);