const char *direction;
} s_sg_platf_linkctn_cbarg_t;
+typedef struct s_sg_platf_cluster_cbarg *sg_platf_cluster_cbarg_t;
+typedef struct s_sg_platf_cluster_cbarg {
+ const char* id;
+ const char* prefix;
+ const char* suffix;
+ const char* radical;
+ double power;
+ int core_amount;
+ double bw;
+ double lat;
+ double bb_bw;
+ double bb_lat;
+ const char* router_id;
+ e_surf_link_sharing_policy_t sharing_policy;
+ e_surf_link_sharing_policy_t bb_sharing_policy;
+ const char* availability_trace; //don't convert to tmgr_trace_t since there is a trace per host and some rewriting is needed
+ const char* state_trace;
+} s_sg_platf_cluster_cbarg_t;
+
+
XBT_PUBLIC(void) sg_platf_begin(void); // Start a new platform
XBT_PUBLIC(void) sg_platf_end(void); // Finish the creation of the platform
XBT_PUBLIC(void) sg_platf_new_AS_begin(const char *id, const char *mode); // Begin description of new AS
XBT_PUBLIC(void) sg_platf_new_AS_end(void); // That AS is fully described
-XBT_PUBLIC(void) sg_platf_new_host (sg_platf_host_cbarg_t host); // Add an host to the currently described AS
-XBT_PUBLIC(void) sg_platf_new_router(sg_platf_router_cbarg_t router); // Add a router to the currently described AS
-XBT_PUBLIC(void) sg_platf_new_link (sg_platf_link_cbarg_t link); // Add a link to the currently described AS
-XBT_PUBLIC(void) sg_platf_new_peer(sg_platf_peer_cbarg_t peer); // Add a peer to the currently described AS
+XBT_PUBLIC(void) sg_platf_new_host (sg_platf_host_cbarg_t host); // Add an host to the currently described AS
+XBT_PUBLIC(void) sg_platf_new_router (sg_platf_router_cbarg_t router); // Add a router to the currently described AS
+XBT_PUBLIC(void) sg_platf_new_link (sg_platf_link_cbarg_t link); // Add a link to the currently described AS
+XBT_PUBLIC(void) sg_platf_new_peer (sg_platf_peer_cbarg_t peer); // Add a peer to the currently described AS
+XBT_PUBLIC(void) sg_platf_new_cluster(sg_platf_cluster_cbarg_t clust); // Add a cluster to the currently described AS
#endif /* SG_PLATF_H */
XBT_PUBLIC_DATA(xbt_dynar_t) ETag_surfxml_ASroute_cb_list;
XBT_PUBLIC_DATA(xbt_dynar_t) STag_surfxml_bypassRoute_cb_list;
XBT_PUBLIC_DATA(xbt_dynar_t) ETag_surfxml_bypassRoute_cb_list;
-XBT_PUBLIC_DATA(xbt_dynar_t) STag_surfxml_cluster_cb_list;
-XBT_PUBLIC_DATA(xbt_dynar_t) ETag_surfxml_cluster_cb_list;
XBT_PUBLIC_DATA(xbt_dynar_t) STag_surfxml_peer_cb_list;
XBT_PUBLIC_DATA(xbt_dynar_t) ETag_surfxml_peer_cb_list;
XBT_PUBLIC_DATA(xbt_dynar_t) STag_surfxml_include_cb_list;
typedef void (*sg_platf_router_cb_t)(sg_platf_router_cbarg_t);
typedef void (*sg_platf_link_cb_t)(sg_platf_link_cbarg_t);
typedef void (*sg_platf_peer_cb_t)(sg_platf_peer_cbarg_t);
+typedef void (*sg_platf_cluster_cb_t)(sg_platf_cluster_cbarg_t);
typedef void (*sg_platf_AS_begin_cb_t)(const char*id, const char*routing);
void sg_platf_host_add_cb(sg_platf_host_cb_t);
void sg_platf_router_add_cb(sg_platf_router_cb_t);
void sg_platf_link_add_cb(sg_platf_link_cb_t);
void sg_platf_peer_add_cb(sg_platf_peer_cb_t fct);
+void sg_platf_cluster_add_cb(sg_platf_cluster_cb_t fct);
void sg_platf_postparse_add_cb(void_f_void_t fct);
void sg_platf_AS_begin_add_cb(sg_platf_AS_begin_cb_t fct);
void sg_platf_AS_end_add_cb(void_f_void_t fct);
#define SURFXML_PARSE_VALUES_H_
-typedef struct s_surf_parsing_cluster_arg *surf_parsing_cluster_arg_t;
-typedef struct s_surf_parsing_cluster_arg {
- const char* id;
- const char* prefix;
- const char* suffix;
- const char* radical;
- double power;
- int core_amount;
- double bw;
- double lat;
- double bb_bw;
- double bb_lat;
- const char* router_id;
- e_surf_link_sharing_policy_t sharing_policy;
- e_surf_link_sharing_policy_t bb_sharing_policy;
- const char* availability_trace; //don't convert to tmgr_trace_t since there is a trace per host and some rewriting is needed
- const char* state_trace;
-} s_surf_parsing_cluster_arg_t;
-
typedef struct s_surf_parsing_link_up_down *surf_parsing_link_up_down_t;
typedef struct s_surf_parsing_link_up_down {
void* link_up;
void* link_down;
} s_surf_parsing_link_up_down_t;
-
-extern surf_parsing_cluster_arg_t struct_cluster;
-
#endif /* SURFXML_PARSE_VALUES_H_ */
xbt_dynar_t sg_platf_link_cb_list = NULL; // of sg_platf_link_cb_t
xbt_dynar_t sg_platf_router_cb_list = NULL; // of sg_platf_router_cb_t
xbt_dynar_t sg_platf_peer_cb_list = NULL; // of sg_platf_peer_cb_t
+xbt_dynar_t sg_platf_cluster_cb_list = NULL; // of sg_platf_cluster_cb_t
xbt_dynar_t sg_platf_AS_begin_cb_list = NULL; //of sg_platf_AS_begin_cb_t
xbt_dynar_t sg_platf_AS_end_cb_list = NULL; //of void_f_void_t
xbt_dynar_t sg_platf_postparse_cb_list = NULL; // of void_f_void_t
sg_platf_router_cb_list = xbt_dynar_new(sizeof(sg_platf_host_cb_t), NULL);
sg_platf_link_cb_list = xbt_dynar_new(sizeof(sg_platf_host_cb_t), NULL);
sg_platf_peer_cb_list = xbt_dynar_new(sizeof(sg_platf_peer_cb_t), NULL);
+ sg_platf_cluster_cb_list = xbt_dynar_new(sizeof(sg_platf_cluster_cb_t), NULL);
sg_platf_postparse_cb_list = xbt_dynar_new(sizeof(sg_platf_link_cb_t),NULL);
sg_platf_AS_begin_cb_list = xbt_dynar_new(sizeof(sg_platf_AS_begin_cb_t),NULL);
sg_platf_AS_end_cb_list = xbt_dynar_new(sizeof(void_f_void_t),NULL);
xbt_dynar_free(&sg_platf_link_cb_list);
xbt_dynar_free(&sg_platf_postparse_cb_list);
xbt_dynar_free(&sg_platf_peer_cb_list);
+ xbt_dynar_free(&sg_platf_cluster_cb_list);
xbt_dynar_free(&sg_platf_AS_begin_cb_list);
xbt_dynar_free(&sg_platf_AS_end_cb_list);
void sg_platf_new_peer(sg_platf_peer_cbarg_t peer){
unsigned int iterator;
sg_platf_peer_cb_t fun;
- xbt_dynar_foreach(sg_platf_link_cb_list, iterator, fun) {
+ xbt_dynar_foreach(sg_platf_peer_cb_list, iterator, fun) {
fun(peer);
}
}
+void sg_platf_new_cluster(sg_platf_cluster_cbarg_t cluster){
+ unsigned int iterator;
+ sg_platf_cluster_cb_t fun;
+ xbt_dynar_foreach(sg_platf_cluster_cb_list, iterator, fun) {
+ fun(cluster);
+ }
+}
void sg_platf_begin() { /* Do nothing: just for symmetry of user code */ }
void sg_platf_peer_add_cb(sg_platf_peer_cb_t fct) {
xbt_dynar_push(sg_platf_peer_cb_list, &fct);
}
+void sg_platf_cluster_add_cb(sg_platf_cluster_cb_t fct) {
+ xbt_dynar_push(sg_platf_cluster_cb_list, &fct);
+}
void sg_platf_postparse_add_cb(void_f_void_t fct) {
xbt_dynar_push(sg_platf_postparse_cb_list, &fct);
}
/* ************************* 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;
xbt_dynar_t radical_elements;
xbt_dynar_t radical_ends;
- if (strcmp(struct_cluster->availability_trace, "")
- || strcmp(struct_cluster->state_trace, "")) {
+ if (strcmp(cluster->availability_trace, "")
+ || strcmp(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);
+ 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\">", struct_cluster->id);
- sg_platf_new_AS_begin(struct_cluster->id, "Cluster");
+ 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) {
radical_ends = xbt_str_split(groups, "-");
}
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 *avail_file = xbt_str_varsubst(struct_cluster->availability_trace, patterns);
+ 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);
XBT_DEBUG("\tavailability_file=\"\"");
}
- if (strcmp(struct_cluster->state_trace, "")) {
- char *avail_file = xbt_str_varsubst(struct_cluster->state_trace, patterns);
+ 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);
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;
- link.policy = struct_cluster->sharing_policy;
+ link.policy = cluster->sharing_policy;
sg_platf_new_link(&link);
surf_parsing_link_up_down_t info =
// 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);
+ 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;
- link.policy = struct_cluster->bb_sharing_policy;
+ link.policy = cluster->bb_sharing_policy;
sg_platf_new_link(&link);
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);
xbt_dynar_t ETag_surfxml_argument_cb_list = NULL;
xbt_dynar_t STag_surfxml_prop_cb_list = NULL;
xbt_dynar_t ETag_surfxml_prop_cb_list = NULL;
-xbt_dynar_t STag_surfxml_cluster_cb_list = NULL;
-xbt_dynar_t ETag_surfxml_cluster_cb_list = NULL;
xbt_dynar_t STag_surfxml_peer_cb_list = NULL;
xbt_dynar_t ETag_surfxml_peer_cb_list = NULL;
xbt_dynar_t STag_surfxml_trace_cb_list = NULL;
xbt_dynar_new(sizeof(void_f_void_t), NULL);
ETag_surfxml_bypassRoute_cb_list =
xbt_dynar_new(sizeof(void_f_void_t), NULL);
- STag_surfxml_cluster_cb_list =
- xbt_dynar_new(sizeof(void_f_void_t), NULL);
- ETag_surfxml_cluster_cb_list =
- xbt_dynar_new(sizeof(void_f_void_t), NULL);
STag_surfxml_peer_cb_list =
xbt_dynar_new(sizeof(void_f_void_t), NULL);
ETag_surfxml_peer_cb_list =
xbt_dynar_free(&ETag_surfxml_ASroute_cb_list);
xbt_dynar_free(&STag_surfxml_bypassRoute_cb_list);
xbt_dynar_free(&ETag_surfxml_bypassRoute_cb_list);
- xbt_dynar_free(&STag_surfxml_cluster_cb_list);
- xbt_dynar_free(&ETag_surfxml_cluster_cb_list);
xbt_dynar_free(&STag_surfxml_peer_cb_list);
xbt_dynar_free(&ETag_surfxml_peer_cb_list);
xbt_dynar_free(&STag_surfxml_include_cb_list);
}
void STag_surfxml_cluster(void){
- struct_cluster = xbt_new0(s_surf_parsing_cluster_arg_t, 1);
- struct_cluster->id = A_surfxml_cluster_id;
- struct_cluster->prefix = A_surfxml_cluster_prefix;
- struct_cluster->suffix = A_surfxml_cluster_suffix;
- struct_cluster->radical = A_surfxml_cluster_radical;
- struct_cluster->power= surf_parse_get_double(A_surfxml_cluster_power);
- struct_cluster->core_amount = surf_parse_get_int(A_surfxml_cluster_core);
- struct_cluster->bw = surf_parse_get_double(A_surfxml_cluster_bw);
- struct_cluster->lat = surf_parse_get_double(A_surfxml_cluster_lat);
+ s_sg_platf_cluster_cbarg_t cluster;
+ memset(&cluster,0,sizeof(cluster));
+ cluster.id = A_surfxml_cluster_id;
+ cluster.prefix = A_surfxml_cluster_prefix;
+ cluster.suffix = A_surfxml_cluster_suffix;
+ cluster.radical = A_surfxml_cluster_radical;
+ cluster.power= surf_parse_get_double(A_surfxml_cluster_power);
+ cluster.core_amount = surf_parse_get_int(A_surfxml_cluster_core);
+ cluster.bw = surf_parse_get_double(A_surfxml_cluster_bw);
+ cluster.lat = surf_parse_get_double(A_surfxml_cluster_lat);
if(strcmp(A_surfxml_cluster_bb_bw,""))
- struct_cluster->bb_bw = surf_parse_get_double(A_surfxml_cluster_bb_bw);
+ cluster.bb_bw = surf_parse_get_double(A_surfxml_cluster_bb_bw);
if(strcmp(A_surfxml_cluster_bb_lat,""))
- struct_cluster->bb_lat = surf_parse_get_double(A_surfxml_cluster_bb_lat);
- struct_cluster->router_id = A_surfxml_cluster_router_id;
+ cluster.bb_lat = surf_parse_get_double(A_surfxml_cluster_bb_lat);
+ cluster.router_id = A_surfxml_cluster_router_id;
switch (AX_surfxml_cluster_sharing_policy) {
case A_surfxml_cluster_sharing_policy_SHARED:
- struct_cluster->sharing_policy = SURF_LINK_SHARED;
+ cluster.sharing_policy = SURF_LINK_SHARED;
break;
case A_surfxml_cluster_sharing_policy_FULLDUPLEX:
- struct_cluster->sharing_policy = SURF_LINK_FULLDUPLEX;
+ cluster.sharing_policy = SURF_LINK_FULLDUPLEX;
break;
case A_surfxml_cluster_sharing_policy_FATPIPE:
- struct_cluster->sharing_policy = SURF_LINK_FATPIPE;
+ cluster.sharing_policy = SURF_LINK_FATPIPE;
break;
default:
surf_parse_error(bprintf
("Invalid cluster sharing policy for cluster %s",
- struct_cluster->id));
+ cluster.id));
break;
}
switch (AX_surfxml_cluster_bb_sharing_policy) {
case A_surfxml_cluster_bb_sharing_policy_FATPIPE:
- struct_cluster->bb_sharing_policy = SURF_LINK_FATPIPE;
+ cluster.bb_sharing_policy = SURF_LINK_FATPIPE;
break;
case A_surfxml_cluster_bb_sharing_policy_SHARED:
- struct_cluster->bb_sharing_policy = SURF_LINK_SHARED;
+ cluster.bb_sharing_policy = SURF_LINK_SHARED;
break;
default:
surf_parse_error(bprintf
("Invalid bb sharing policy in cluster %s",
- struct_cluster->id));
+ cluster.id));
break;
}
- struct_cluster->availability_trace = A_surfxml_cluster_availability_file;
- struct_cluster->state_trace = A_surfxml_cluster_state_file;
-
- surfxml_call_cb_functions(STag_surfxml_cluster_cb_list);
+ cluster.availability_trace = A_surfxml_cluster_availability_file;
+ cluster.state_trace = A_surfxml_cluster_state_file;
+ sg_platf_new_cluster(&cluster);
}
void ETag_surfxml_cluster(void){
- surfxml_call_cb_functions(ETag_surfxml_cluster_cb_list);
- xbt_free(struct_cluster);
+ /* nothing I can think of */
}
void STag_surfxml_peer(void){
}
}
-/*
- * Pass arguments to parsing callback as structures to save some time (and allow callbacks to ignore some)
- */
-
-surf_parsing_cluster_arg_t struct_cluster = NULL;
-
/*
* Trace related stuff
*/
