From: Martin Quinson Date: Fri, 11 Nov 2011 02:17:41 +0000 (+0100) Subject: move the callbacks to the cluster creation from surfxml_parse to sg_platf X-Git-Tag: exp_20120216~316 X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/commitdiff_plain/d435bdefd34324ed0b0c25d1b6eb6dd3b7344524?ds=sidebyside move the callbacks to the cluster creation from surfxml_parse to sg_platf --- diff --git a/include/simgrid/platf.h b/include/simgrid/platf.h index c449f3f1d0..68c26f3d63 100644 --- a/include/simgrid/platf.h +++ b/include/simgrid/platf.h @@ -86,6 +86,26 @@ typedef struct s_sg_platf_linkctn_cbarg { 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 @@ -93,10 +113,11 @@ 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 */ diff --git a/include/surf/surfxml_parse.h b/include/surf/surfxml_parse.h index 10a0e46ac8..721db6e027 100644 --- a/include/surf/surfxml_parse.h +++ b/include/surf/surfxml_parse.h @@ -35,8 +35,6 @@ XBT_PUBLIC_DATA(xbt_dynar_t) STag_surfxml_ASroute_cb_list; 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; diff --git a/src/include/simgrid/platf_interface.h b/src/include/simgrid/platf_interface.h index b0510a3e03..a2ae6f2747 100644 --- a/src/include/simgrid/platf_interface.h +++ b/src/include/simgrid/platf_interface.h @@ -21,12 +21,14 @@ typedef void (*sg_platf_host_cb_t)(sg_platf_host_cbarg_t); 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); diff --git a/src/include/surf/surfxml_parse_values.h b/src/include/surf/surfxml_parse_values.h index c35c33d5a3..d030d07a19 100644 --- a/src/include/surf/surfxml_parse_values.h +++ b/src/include/surf/surfxml_parse_values.h @@ -8,32 +8,10 @@ #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_ */ diff --git a/src/surf/sg_platf.c b/src/surf/sg_platf.c index 06e0c77007..5276efc1dc 100644 --- a/src/surf/sg_platf.c +++ b/src/surf/sg_platf.c @@ -15,6 +15,7 @@ xbt_dynar_t sg_platf_host_cb_list = NULL; // of sg_platf_host_cb_t 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 @@ -28,6 +29,7 @@ void sg_platf_init(void) { 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); @@ -39,6 +41,7 @@ void sg_platf_exit(void) { 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); @@ -70,10 +73,17 @@ void sg_platf_new_link(sg_platf_link_cbarg_t link){ 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 */ } @@ -134,6 +144,9 @@ void sg_platf_router_add_cb(sg_platf_router_cb_t fct) { 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); } diff --git a/src/surf/surf_routing.c b/src/surf/surf_routing.c index 0c310ba9d1..55d6ab262f 100644 --- a/src/surf/surf_routing.c +++ b/src/surf/surf_routing.c @@ -752,7 +752,7 @@ void routing_model_create(size_t size_of_links, void *loopback) /* ************************* 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; @@ -765,20 +765,20 @@ static void routing_parse_cluster(void) 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("", struct_cluster->id); - sg_platf_new_AS_begin(struct_cluster->id, "Cluster"); + XBT_DEBUG("", 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, "-"); @@ -797,16 +797,16 @@ static void routing_parse_cluster(void) } 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_id, struct_cluster->power); + XBT_DEBUG("", 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); @@ -814,8 +814,8 @@ static void routing_parse_cluster(void) 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); @@ -823,23 +823,23 @@ static void routing_parse_cluster(void) 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(""); XBT_DEBUG("", 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 = @@ -870,31 +870,31 @@ static void routing_parse_cluster(void) // 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("", struct_cluster->router_id); + XBT_DEBUG("", 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_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); @@ -1148,7 +1148,7 @@ void routing_register_callbacks() 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); diff --git a/src/surf/surfxml_parse.c b/src/surf/surfxml_parse.c index ec8eac660b..30b70dfcc5 100644 --- a/src/surf/surfxml_parse.c +++ b/src/surf/surfxml_parse.c @@ -58,8 +58,6 @@ xbt_dynar_t STag_surfxml_argument_cb_list = NULL; 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; @@ -176,10 +174,6 @@ void surf_parse_init_callbacks(void) 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 = @@ -220,8 +214,6 @@ void surf_parse_free_callbacks(void) 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); @@ -298,59 +290,58 @@ void STag_surfxml_router(void){ } 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){ diff --git a/src/surf/surfxml_parseplatf.c b/src/surf/surfxml_parseplatf.c index 1a5965d43c..33498c33c7 100644 --- a/src/surf/surfxml_parseplatf.c +++ b/src/surf/surfxml_parseplatf.c @@ -49,12 +49,6 @@ void surfxml_bufferstack_pop(int new) } } -/* - * 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 */