Properly integrate the link creation into sg_platf

diff --git a/include/simgrid/platf.h b/include/simgrid/platf.h
index 5ad299f..69f1f66 100644 (file)
--- a/include/simgrid/platf.h
+++ b/include/simgrid/platf.h
@@ -47,6 +47,20 @@ typedef struct {
   const char* V_router_coord;
 } s_sg_platf_router_cbarg_t, *sg_platf_router_cbarg_t;
 
+typedef struct {
+  char* V_link_id;
+  double V_link_bandwidth;
+  tmgr_trace_t V_link_bandwidth_file;
+  double V_link_latency;
+  tmgr_trace_t V_link_latency_file;
+  e_surf_resource_state_t V_link_state;
+  tmgr_trace_t V_link_state_file;
+  int V_link_sharing_policy;
+  int V_policy_initial_link;
+  xbt_dict_t properties;
+} s_sg_platf_link_cbarg_t, *sg_platf_link_cbarg_t;
+
+
 XBT_PUBLIC(void) sg_platf_open(void);  // Start a new platform
 XBT_PUBLIC(void) sg_platf_close(void); // Finish the creation of the platform
 
@@ -55,6 +69,7 @@ XBT_PUBLIC(void) sg_platf_new_AS_close(void);                            // That
 
 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
 
 
 #endif                          /* SG_PLATF_H */

diff --git a/include/surf/surfxml_parse.h b/include/surf/surfxml_parse.h
index eaf8897..cf9c13e 100644 (file)
--- a/include/surf/surfxml_parse.h
+++ b/include/surf/surfxml_parse.h
@@ -15,8 +15,6 @@
 SG_BEGIN_DECL()
 
 /* Hook for the different tags. All the functions which pointer to are push into here are run when the tag is encountered */
-XBT_PUBLIC_DATA(xbt_dynar_t) STag_surfxml_link_cb_list;
-XBT_PUBLIC_DATA(xbt_dynar_t) ETag_surfxml_link_cb_list;
 XBT_PUBLIC_DATA(xbt_dynar_t) STag_surfxml_route_cb_list;
 XBT_PUBLIC_DATA(xbt_dynar_t) ETag_surfxml_route_cb_list;
 XBT_PUBLIC_DATA(xbt_dynar_t) STag_surfxml_link_ctn_cb_list;
@@ -51,6 +49,7 @@ XBT_PUBLIC(void) surf_parse_close(void);
 XBT_PUBLIC(void) surf_parse_init_callbacks(void);
 XBT_PUBLIC(void) surf_parse_reset_callbacks(void);
 XBT_PUBLIC(void) surf_parse_free_callbacks(void);
+XBT_PUBLIC(void) surf_parse_error(char *msg);
 XBT_PUBLIC(double) surf_parse_get_double(const char *string);
 XBT_PUBLIC(int) surf_parse_get_int(const char *string);
 XBT_PUBLIC(void) surf_parse_add_callback_config(void);

diff --git a/src/include/simgrid/platf_interface.h b/src/include/simgrid/platf_interface.h
index c17c0bc..69f3286 100644 (file)
--- a/src/include/simgrid/platf_interface.h
+++ b/src/include/simgrid/platf_interface.h
@@ -19,8 +19,11 @@ void sg_platf_exit(void);
 
 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);
+
 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_postparse_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 01e259a..ae8eeb1 100644 (file)
--- a/src/include/surf/surfxml_parse_values.h
+++ b/src/include/surf/surfxml_parse_values.h
@@ -19,19 +19,6 @@ typedef struct s_surf_parsing_peer_arg {
        char* V_peer_state_trace;
 } s_surf_parsing_peer_arg_t;
 
-typedef struct s_surf_parsing_link_arg *surf_parsing_link_arg_t;
-typedef struct s_surf_parsing_link_arg {
-       char* V_link_id;
-       double V_link_bandwidth;
-       tmgr_trace_t V_link_bandwidth_file;
-       double V_link_latency;
-       tmgr_trace_t V_link_latency_file;
-       e_surf_resource_state_t V_link_state;
-       tmgr_trace_t V_link_state_file;
-       int V_link_sharing_policy;
-       int V_policy_initial_link;
-} s_surf_parsing_link_arg_t;
-
 typedef struct s_surf_parsing_cluster_arg *surf_parsing_cluster_arg_t;
 typedef struct s_surf_parsing_cluster_arg {
        char* V_cluster_id;
@@ -60,8 +47,5 @@ typedef struct s_surf_parsing_link_up_down {
 
 extern surf_parsing_cluster_arg_t struct_cluster;
 extern surf_parsing_peer_arg_t struct_peer;
-extern surf_parsing_link_arg_t struct_lnk;
-
-void surf_parse_link(void);
 
 #endif /* SURFXML_PARSE_VALUES_H_ */

diff --git a/src/instr/instr_routing.c b/src/instr/instr_routing.c
index 1388256..ae62d45 100644 (file)
--- a/src/instr/instr_routing.c
+++ b/src/instr/instr_routing.c
@@ -186,23 +186,23 @@ static void instr_routing_parse_end_AS ()
   }
 }
 
-static void instr_routing_parse_start_link ()
+static void instr_routing_parse_start_link (sg_platf_link_cbarg_t link)
 {
   container_t father = *(container_t*)xbt_dynar_get_ptr(currentContainer, xbt_dynar_length(currentContainer)-1);
 
-  double bandwidth_value = struct_lnk->V_link_bandwidth;
-  double latency_value = struct_lnk->V_link_latency;
+  double bandwidth_value = link->V_link_bandwidth;
+  double latency_value = link->V_link_latency;
   xbt_dynar_t links_to_create = xbt_dynar_new (sizeof(char*), &xbt_free_ref);
 
-  if (struct_lnk->V_link_sharing_policy == A_surfxml_link_sharing_policy_FULLDUPLEX){
-    char *up = bprintf("%s_UP", struct_lnk->V_link_id);
-    char *down = bprintf("%s_DOWN", struct_lnk->V_link_id);
+  if (link->V_link_sharing_policy == A_surfxml_link_sharing_policy_FULLDUPLEX){
+    char *up = bprintf("%s_UP", link->V_link_id);
+    char *down = bprintf("%s_DOWN", link->V_link_id);
     xbt_dynar_push_as (links_to_create, char*, xbt_strdup(up));
     xbt_dynar_push_as (links_to_create, char*, xbt_strdup(down));
     free (up);
     free (down);
   }else{
-    xbt_dynar_push_as (links_to_create, char*, strdup(struct_lnk->V_link_id));
+    xbt_dynar_push_as (links_to_create, char*, strdup(link->V_link_id));
   }
 
   char *link_name = NULL;
@@ -291,7 +291,7 @@ void instr_routing_define_callbacks ()
   surfxml_add_callback(STag_surfxml_AS_cb_list, &instr_routing_parse_start_AS);
   surfxml_add_callback(ETag_surfxml_AS_cb_list, &instr_routing_parse_end_AS);
   if (!TRACE_needs_platform()) return;
-  surfxml_add_callback(STag_surfxml_link_cb_list, &instr_routing_parse_start_link);
+  sg_platf_link_add_cb(instr_routing_parse_start_link);
   sg_platf_host_add_cb(instr_routing_parse_start_host);
   sg_platf_router_add_cb(instr_routing_parse_start_router);
 

diff --git a/src/surf/network.c b/src/surf/network.c
index 166e928..e42e22a 100644 (file)
--- a/src/surf/network.c
+++ b/src/surf/network.c
@@ -192,24 +192,24 @@ static void* net_create_resource(const char *name,
   return nw_link;
 }
 
-static void net_parse_link_init(void)
+static void net_parse_link_init(sg_platf_link_cbarg_t link)
 {
   XBT_DEBUG("link_CM02");
 
-  if(struct_lnk->V_policy_initial_link == SURF_LINK_FULLDUPLEX)
+  if(link->V_policy_initial_link == SURF_LINK_FULLDUPLEX)
   {
-    net_create_resource(bprintf("%s_UP",struct_lnk->V_link_id), struct_lnk->V_link_bandwidth, struct_lnk->V_link_bandwidth_file,
-                      struct_lnk->V_link_latency, struct_lnk->V_link_latency_file, struct_lnk->V_link_state, struct_lnk->V_link_state_file,
-                      struct_lnk->V_policy_initial_link, xbt_dict_new());
-    net_create_resource(bprintf("%s_DOWN",struct_lnk->V_link_id), struct_lnk->V_link_bandwidth, struct_lnk->V_link_bandwidth_file,
-            struct_lnk->V_link_latency, struct_lnk->V_link_latency_file, struct_lnk->V_link_state, struct_lnk->V_link_state_file,
-                      struct_lnk->V_policy_initial_link, xbt_dict_new());
+    net_create_resource(bprintf("%s_UP",link->V_link_id), link->V_link_bandwidth, link->V_link_bandwidth_file,
+                      link->V_link_latency, link->V_link_latency_file, link->V_link_state, link->V_link_state_file,
+                      link->V_policy_initial_link, link->properties);
+    net_create_resource(bprintf("%s_DOWN",link->V_link_id), link->V_link_bandwidth, link->V_link_bandwidth_file,
+            link->V_link_latency, link->V_link_latency_file, link->V_link_state, link->V_link_state_file,
+            link->V_policy_initial_link, NULL); // FIXME: We need to deep copy the properties or we won't be able to free it
   }
   else
   {
-    net_create_resource(xbt_strdup(struct_lnk->V_link_id), struct_lnk->V_link_bandwidth, struct_lnk->V_link_bandwidth_file,
-               struct_lnk->V_link_latency, struct_lnk->V_link_latency_file, struct_lnk->V_link_state, struct_lnk->V_link_state_file,
-                      struct_lnk->V_policy_initial_link, xbt_dict_new());
+    net_create_resource(xbt_strdup(link->V_link_id), link->V_link_bandwidth, link->V_link_bandwidth_file,
+               link->V_link_latency, link->V_link_latency_file, link->V_link_state, link->V_link_state_file,
+                      link->V_policy_initial_link, link->properties);
   }
 
 }
@@ -273,7 +273,7 @@ static void net_add_traces(void)
 static void net_define_callbacks(void)
 {
   /* Figuring out the network links */
-  surfxml_add_callback(STag_surfxml_link_cb_list, &net_parse_link_init);
+  sg_platf_link_add_cb(net_parse_link_init);
   sg_platf_postparse_add_cb(net_add_traces);
 }
 

diff --git a/src/surf/network_im.c b/src/surf/network_im.c
index a31e8c2..f53574a 100644 (file)
--- a/src/surf/network_im.c
+++ b/src/surf/network_im.c
@@ -188,22 +188,22 @@ static void* im_net_create_resource(const char *name,
   return nw_link;
 }
 
-static void im_net_parse_link_init(void)
+static void im_net_parse_link_init(sg_platf_link_cbarg_t link)
 {
-  if(struct_lnk->V_policy_initial_link == SURF_LINK_FULLDUPLEX)
+  if(link->V_policy_initial_link == SURF_LINK_FULLDUPLEX)
   {
-         im_net_create_resource(bprintf("%s_UP",struct_lnk->V_link_id), struct_lnk->V_link_bandwidth, struct_lnk->V_link_bandwidth_file,
-                      struct_lnk->V_link_latency, struct_lnk->V_link_latency_file, struct_lnk->V_link_state, struct_lnk->V_link_state_file,
-                      struct_lnk->V_policy_initial_link, xbt_dict_new());
-         im_net_create_resource(bprintf("%s_DOWN",struct_lnk->V_link_id), struct_lnk->V_link_bandwidth, struct_lnk->V_link_bandwidth_file,
-            struct_lnk->V_link_latency, struct_lnk->V_link_latency_file, struct_lnk->V_link_state, struct_lnk->V_link_state_file,
-                      struct_lnk->V_policy_initial_link, xbt_dict_new());
+         im_net_create_resource(bprintf("%s_UP",link->V_link_id), link->V_link_bandwidth, link->V_link_bandwidth_file,
+                      link->V_link_latency, link->V_link_latency_file, link->V_link_state, link->V_link_state_file,
+                      link->V_policy_initial_link, link->properties);
+         im_net_create_resource(bprintf("%s_DOWN",link->V_link_id), link->V_link_bandwidth, link->V_link_bandwidth_file,
+            link->V_link_latency, link->V_link_latency_file, link->V_link_state, link->V_link_state_file,
+            link->V_policy_initial_link, NULL); // FIXME: We need to deep copy the properties or we won't be able to free it
   }
   else
   {
-         im_net_create_resource(xbt_strdup(struct_lnk->V_link_id), struct_lnk->V_link_bandwidth, struct_lnk->V_link_bandwidth_file,
-               struct_lnk->V_link_latency, struct_lnk->V_link_latency_file, struct_lnk->V_link_state, struct_lnk->V_link_state_file,
-                      struct_lnk->V_policy_initial_link, xbt_dict_new());
+         im_net_create_resource(xbt_strdup(link->V_link_id), link->V_link_bandwidth, link->V_link_bandwidth_file,
+               link->V_link_latency, link->V_link_latency_file, link->V_link_state, link->V_link_state_file,
+                      link->V_policy_initial_link, link->properties);
   }
 }
 
@@ -266,7 +266,7 @@ static void im_net_add_traces(void)
 static void im_net_define_callbacks(void)
 {
   /* Figuring out the network links */
-  surfxml_add_callback(STag_surfxml_link_cb_list, &im_net_parse_link_init);
+  sg_platf_link_add_cb(im_net_parse_link_init);
   sg_platf_postparse_add_cb(im_net_add_traces);
 }
 

diff --git a/src/surf/sg_platf.c b/src/surf/sg_platf.c
index 773cc49..c111a40 100644 (file)
--- a/src/surf/sg_platf.c
+++ b/src/surf/sg_platf.c
@@ -9,10 +9,10 @@
 #include "xbt/str.h"
 #include "xbt/dict.h"
 #include "simgrid/platf_interface.h"
-#include "surf/surf_private.h"
 
 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(surf_parse);
 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_postparse_cb_list = NULL; // of void_f_void_t
 
@@ -20,7 +20,8 @@ xbt_dynar_t sg_platf_postparse_cb_list = NULL; // of void_f_void_t
 void sg_platf_init(void) {
   sg_platf_host_cb_list = xbt_dynar_new(sizeof(sg_platf_host_cb_t), NULL);
   sg_platf_router_cb_list = xbt_dynar_new(sizeof(sg_platf_host_cb_t), NULL);
-  sg_platf_postparse_cb_list = xbt_dynar_new(sizeof(void_f_void_t),NULL);
+  sg_platf_link_cb_list = xbt_dynar_new(sizeof(sg_platf_host_cb_t), NULL);
+  sg_platf_postparse_cb_list = xbt_dynar_new(sizeof(sg_platf_link_cb_t),NULL);
 }
 /** Module management function: frees all internal data structures */
 void sg_platf_exit(void) {
@@ -43,6 +44,14 @@ void sg_platf_new_router(sg_platf_router_cbarg_t router) {
     (*fun) (router);
   }
 }
+void sg_platf_new_link(sg_platf_link_cbarg_t link){
+  unsigned int iterator;
+  sg_platf_link_cb_t fun;
+  xbt_dynar_foreach(sg_platf_link_cb_list, iterator, fun) {
+    (*fun) (link);
+  }
+}
+
 void sg_platf_open() { /* Do nothing: just for symmetry of user code */ }
 
 void sg_platf_close() {
@@ -57,6 +66,9 @@ void sg_platf_close() {
 void sg_platf_host_add_cb(sg_platf_host_cb_t fct) {
   xbt_dynar_push(sg_platf_host_cb_list, &fct);
 }
+void sg_platf_link_add_cb(sg_platf_link_cb_t fct) {
+  xbt_dynar_push(sg_platf_link_cb_list, &fct);
+}
 void sg_platf_router_add_cb(sg_platf_router_cb_t fct) {
   xbt_dynar_push(sg_platf_router_cb_list, &fct);
 }

diff --git a/src/surf/surf_routing.c b/src/surf/surf_routing.c
index 25ffc1b..f354e05 100644 (file)
--- a/src/surf/surf_routing.c
+++ b/src/surf/surf_routing.c
@@ -1393,6 +1393,7 @@ void routing_parse_Scluster(void)
   char *host_id, *groups, *link_id = NULL;
 
   s_sg_platf_host_cbarg_t host;
+  s_sg_platf_link_cbarg_t link;
 
   if( strcmp(struct_cluster->V_cluster_availability_file,"")
          || strcmp(struct_cluster->V_cluster_state_file,"") )
@@ -1466,6 +1467,7 @@ void routing_parse_Scluster(void)
                sg_platf_new_host(&host);
                XBT_DEBUG("</host>");
 
+
                A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED;
                if(struct_cluster->V_cluster_sharing_policy == A_surfxml_cluster_sharing_policy_FULLDUPLEX)
                {A_surfxml_link_sharing_policy =  A_surfxml_link_sharing_policy_FULLDUPLEX;}
@@ -1474,28 +1476,31 @@ void routing_parse_Scluster(void)
 
                XBT_DEBUG("<link\tid=\"%s\"\tbw=\"%f\"\tlat=\"%f\"/>", link_id,struct_cluster->S_cluster_bw, struct_cluster->S_cluster_lat);
 
-               struct_lnk = xbt_new0(s_surf_parsing_link_arg_t, 1);
-               struct_lnk->V_link_id = link_id;
-               struct_lnk->V_link_bandwidth = struct_cluster->S_cluster_bw;
-               struct_lnk->V_link_latency = struct_cluster->S_cluster_lat;
-               struct_lnk->V_link_bandwidth_file = NULL;
-               struct_lnk->V_link_latency_file = NULL;
-               struct_lnk->V_link_state_file = NULL;
-               struct_lnk->V_link_state = SURF_RESOURCE_ON;
-               struct_lnk->V_link_sharing_policy = A_surfxml_link_sharing_policy;
-
-               if (A_surfxml_link_sharing_policy == A_surfxml_link_sharing_policy_SHARED)
-                       struct_lnk->V_policy_initial_link = SURF_LINK_SHARED;
-               else
-               {
-                if (A_surfxml_link_sharing_policy == A_surfxml_link_sharing_policy_FATPIPE)
-                        struct_lnk->V_policy_initial_link = SURF_LINK_FATPIPE;
-                else if (A_surfxml_link_sharing_policy == A_surfxml_link_sharing_policy_FULLDUPLEX)
-                        struct_lnk->V_policy_initial_link = SURF_LINK_FULLDUPLEX;
+               memset(&link,0,sizeof(link));
+               link.V_link_id = link_id;
+               link.V_link_bandwidth = struct_cluster->S_cluster_bw;
+               link.V_link_latency = struct_cluster->S_cluster_lat;
+               link.V_link_bandwidth_file = NULL;
+               link.V_link_latency_file = NULL;
+               link.V_link_state_file = NULL;
+               link.V_link_state = SURF_RESOURCE_ON;
+               link.V_link_sharing_policy = A_surfxml_link_sharing_policy;
+
+               switch (A_surfxml_link_sharing_policy) {
+               case A_surfxml_link_sharing_policy_SHARED:
+                       link.V_policy_initial_link = SURF_LINK_SHARED;
+                       break;
+               case A_surfxml_link_sharing_policy_FATPIPE:
+                 link.V_policy_initial_link = SURF_LINK_FATPIPE;
+                 break;
+               case A_surfxml_link_sharing_policy_FULLDUPLEX:
+                 link.V_policy_initial_link = SURF_LINK_FULLDUPLEX;
+                 break;
+               case AU_surfxml_link_sharing_policy:
+                 surf_parse_error(bprintf("Invalid sharing policy in cluster %s (please report this bug, this shouldn't happen)",struct_cluster->V_cluster_id));
                }
-               surf_parse_link();
 
-               ETag_surfxml_link();
+               sg_platf_new_link(&link);
 
                surf_parsing_link_up_down_t info = xbt_new0(s_surf_parsing_link_up_down_t, 1);
                if (A_surfxml_link_sharing_policy == A_surfxml_link_sharing_policy_FULLDUPLEX){
@@ -1568,26 +1573,26 @@ void routing_parse_Scluster(void)
 
                XBT_DEBUG("<link\tid=\"%s\"\tbw=\"%f\"\tlat=\"%f\"/>", link_id,struct_cluster->S_cluster_bw, struct_cluster->S_cluster_lat);
 
-               struct_lnk = xbt_new0(s_surf_parsing_link_arg_t, 1);
-               struct_lnk->V_link_id = link_id;
-               struct_lnk->V_link_bandwidth = struct_cluster->S_cluster_bw;
-               struct_lnk->V_link_latency = struct_cluster->S_cluster_lat;
-               struct_lnk->V_link_bandwidth_file = NULL;
-               struct_lnk->V_link_latency_file = NULL;
-               struct_lnk->V_link_state_file = NULL;
-               struct_lnk->V_link_state = SURF_RESOURCE_ON;
-               struct_lnk->V_link_sharing_policy = A_surfxml_link_sharing_policy;
+               memset(&link,0,sizeof(link));
+               link.V_link_id = link_id;
+               link.V_link_bandwidth = struct_cluster->S_cluster_bw;
+               link.V_link_latency = struct_cluster->S_cluster_lat;
+               link.V_link_bandwidth_file = NULL;
+               link.V_link_latency_file = NULL;
+               link.V_link_state_file = NULL;
+               link.V_link_state = SURF_RESOURCE_ON;
+               link.V_link_sharing_policy = A_surfxml_link_sharing_policy;
 
                if (A_surfxml_link_sharing_policy == A_surfxml_link_sharing_policy_SHARED)
-                       struct_lnk->V_policy_initial_link = SURF_LINK_SHARED;
+                       link.V_policy_initial_link = SURF_LINK_SHARED;
                else
                {
                 if (A_surfxml_link_sharing_policy == A_surfxml_link_sharing_policy_FATPIPE)
-                        struct_lnk->V_policy_initial_link = SURF_LINK_FATPIPE;
+                        link.V_policy_initial_link = SURF_LINK_FATPIPE;
                 else if (A_surfxml_link_sharing_policy == A_surfxml_link_sharing_policy_FULLDUPLEX)
-                        struct_lnk->V_policy_initial_link = SURF_LINK_FULLDUPLEX;
+                        link.V_policy_initial_link = SURF_LINK_FULLDUPLEX;
                }
-               surf_parse_link();
+               sg_platf_new_link(&link);
 
                ETag_surfxml_link();
 
@@ -1637,22 +1642,22 @@ void routing_parse_Scluster(void)
          if(AX_surfxml_cluster_bb_sharing_policy == A_surfxml_cluster_bb_sharing_policy_FATPIPE)
          {A_surfxml_link_sharing_policy =  A_surfxml_link_sharing_policy_FATPIPE;}
 
-         struct_lnk = xbt_new0(s_surf_parsing_link_arg_t, 1);
-         struct_lnk->V_link_id = link_backbone;
-         struct_lnk->V_link_bandwidth = struct_cluster->S_cluster_bb_bw;
-         struct_lnk->V_link_latency = struct_cluster->S_cluster_bb_lat;
-         struct_lnk->V_link_bandwidth_file = NULL;
-         struct_lnk->V_link_latency_file = NULL;
-         struct_lnk->V_link_state_file = NULL;
-         struct_lnk->V_link_state = SURF_RESOURCE_ON;
-         struct_lnk->V_link_sharing_policy = A_surfxml_link_sharing_policy;
+         memset(&link,0,sizeof(link));
+         link.V_link_id = link_backbone;
+         link.V_link_bandwidth = struct_cluster->S_cluster_bb_bw;
+         link.V_link_latency = struct_cluster->S_cluster_bb_lat;
+         link.V_link_bandwidth_file = NULL;
+         link.V_link_latency_file = NULL;
+         link.V_link_state_file = NULL;
+         link.V_link_state = SURF_RESOURCE_ON;
+         link.V_link_sharing_policy = A_surfxml_link_sharing_policy;
 
          if (A_surfxml_link_sharing_policy == A_surfxml_link_sharing_policy_SHARED)
-                 struct_lnk->V_policy_initial_link = SURF_LINK_SHARED;
+                 link.V_policy_initial_link = SURF_LINK_SHARED;
          else
-                 struct_lnk->V_policy_initial_link = SURF_LINK_FATPIPE;
+                 link.V_policy_initial_link = SURF_LINK_FATPIPE;
 
-         surf_parse_link();
+         sg_platf_new_link(&link);
          ETag_surfxml_link();
 
          surf_parsing_link_up_down_t info = xbt_new0(s_surf_parsing_link_up_down_t, 1);

diff --git a/src/surf/surfxml_parse.c b/src/surf/surfxml_parse.c
index 9760b4e..92a759d 100644 (file)
--- a/src/surf/surfxml_parse.c
+++ b/src/surf/surfxml_parse.c
@@ -21,7 +21,7 @@ int ETag_surfxml_include_state(void);
 /*
  * Helping functions
  */
-static void surf_parse_error(char *msg) {
+void surf_parse_error(char *msg) {
   xbt_die("Parse error on line %d: %s\n", surf_parse_lineno, msg);
 }
 
@@ -48,9 +48,6 @@ int surf_parse_get_int(const char *string) {
  */
 
 /* make sure these symbols are defined as strong ones in this file so that the linker can resolve them */
-//xbt_dynar_t STag_surfxml_host_cb_list = NULL;
-xbt_dynar_t STag_surfxml_link_cb_list = NULL;
-xbt_dynar_t ETag_surfxml_link_cb_list = NULL;
 xbt_dynar_t STag_surfxml_route_cb_list = NULL;
 xbt_dynar_t ETag_surfxml_route_cb_list = NULL;
 xbt_dynar_t STag_surfxml_link_ctn_cb_list = NULL;
@@ -153,8 +150,6 @@ void surf_parse_init_callbacks(void)
 {
          sg_platf_init(); // FIXME: move to a proper place?
 
-         STag_surfxml_link_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
-         ETag_surfxml_link_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
          STag_surfxml_route_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
          ETag_surfxml_route_cb_list = xbt_dynar_new(sizeof(void_f_void_t), NULL);
          STag_surfxml_link_ctn_cb_list =
@@ -213,8 +208,6 @@ void surf_parse_free_callbacks(void)
 {
   sg_platf_exit(); // FIXME: better place?
 
-  xbt_dynar_free(&STag_surfxml_link_cb_list);
-  xbt_dynar_free(&ETag_surfxml_link_cb_list);
   xbt_dynar_free(&STag_surfxml_route_cb_list);
   xbt_dynar_free(&ETag_surfxml_route_cb_list);
   xbt_dynar_free(&STag_surfxml_link_ctn_cb_list);
@@ -378,39 +371,40 @@ void ETag_surfxml_peer(void){
        xbt_free(struct_peer);
 }
 void STag_surfxml_link(void){
-       struct_lnk = xbt_new0(s_surf_parsing_link_arg_t, 1);
-       struct_lnk->V_link_id = A_surfxml_link_id;
-       struct_lnk->V_link_bandwidth = surf_parse_get_double(A_surfxml_link_bandwidth);
-       struct_lnk->V_link_bandwidth_file = tmgr_trace_new(A_surfxml_link_bandwidth_file);
-       struct_lnk->V_link_latency = surf_parse_get_double(A_surfxml_link_latency);
-       struct_lnk->V_link_latency_file = tmgr_trace_new(A_surfxml_link_latency_file);
+  s_sg_platf_link_cbarg_t link;
+  memset(&link,0,sizeof(link));
+
+  xbt_assert(current_property_set == NULL, "Someone forgot to reset the property set to NULL in its closing tag (or XML malformed)");
+  link.properties = current_property_set = xbt_dict_new();
+
+       link.V_link_id = A_surfxml_link_id;
+       link.V_link_bandwidth = surf_parse_get_double(A_surfxml_link_bandwidth);
+       link.V_link_bandwidth_file = tmgr_trace_new(A_surfxml_link_bandwidth_file);
+       link.V_link_latency = surf_parse_get_double(A_surfxml_link_latency);
+       link.V_link_latency_file = tmgr_trace_new(A_surfxml_link_latency_file);
        xbt_assert((A_surfxml_link_state == A_surfxml_link_state_ON) ||
                          (A_surfxml_link_state == A_surfxml_link_state_OFF), "Invalid state");
        if (A_surfxml_link_state == A_surfxml_link_state_ON)
-               struct_lnk->V_link_state = SURF_RESOURCE_ON;
+               link.V_link_state = SURF_RESOURCE_ON;
        if (A_surfxml_link_state == A_surfxml_link_state_OFF)
-               struct_lnk->V_link_state = SURF_RESOURCE_OFF;
-       struct_lnk->V_link_state_file = tmgr_trace_new(A_surfxml_link_state_file);
-       struct_lnk->V_link_sharing_policy = A_surfxml_link_sharing_policy;
+               link.V_link_state = SURF_RESOURCE_OFF;
+       link.V_link_state_file = tmgr_trace_new(A_surfxml_link_state_file);
+       link.V_link_sharing_policy = A_surfxml_link_sharing_policy;
 
        if (A_surfxml_link_sharing_policy == A_surfxml_link_sharing_policy_SHARED)
-               struct_lnk->V_policy_initial_link = SURF_LINK_SHARED;
+               link.V_policy_initial_link = SURF_LINK_SHARED;
        else
        {
         if (A_surfxml_link_sharing_policy == A_surfxml_link_sharing_policy_FATPIPE)
-                struct_lnk->V_policy_initial_link = SURF_LINK_FATPIPE;
+                link.V_policy_initial_link = SURF_LINK_FATPIPE;
         else if (A_surfxml_link_sharing_policy == A_surfxml_link_sharing_policy_FULLDUPLEX)
-                struct_lnk->V_policy_initial_link = SURF_LINK_FULLDUPLEX;
+                link.V_policy_initial_link = SURF_LINK_FULLDUPLEX;
        }
 
-       surf_parse_link();
-}
-void surf_parse_link(void){
-       surfxml_call_cb_functions(STag_surfxml_link_cb_list);
+       sg_platf_new_link(&link);
 }
 void ETag_surfxml_link(void){
-       surfxml_call_cb_functions(ETag_surfxml_link_cb_list);
-       xbt_free(struct_lnk);
+  current_property_set = NULL;
 }
 
 void STag_surfxml_route(void){

diff --git a/src/surf/surfxml_parseplatf.c b/src/surf/surfxml_parseplatf.c
index 894dc9e..4445475 100644 (file)
--- a/src/surf/surfxml_parseplatf.c
+++ b/src/surf/surfxml_parseplatf.c
@@ -53,11 +53,8 @@ void surfxml_bufferstack_pop(int new)
  * Pass arguments to parsing callback as structures to save some time (and allow callbacks to ignore some)
  */
 
-sg_platf_router_cbarg_t struct_router = NULL;
 surf_parsing_cluster_arg_t struct_cluster = NULL;
 surf_parsing_peer_arg_t struct_peer = NULL;
-surf_parsing_link_arg_t struct_lnk = NULL;
-
 
 /*
  * Trace related stuff

diff --git a/src/surf/workstation_ptask_L07.c b/src/surf/workstation_ptask_L07.c
index 4ed016c..86f3e7a 100644 (file)
--- a/src/surf/workstation_ptask_L07.c
+++ b/src/surf/workstation_ptask_L07.c
@@ -710,22 +710,22 @@ static void* ptask_link_create_resource(const char *name,
   return nw_link;
 }
 
-static void ptask_parse_link_init(void)
+static void ptask_parse_link_init(sg_platf_link_cbarg_t link)
 {
-  if(struct_lnk->V_policy_initial_link == SURF_LINK_FULLDUPLEX)
+  if(link->V_policy_initial_link == SURF_LINK_FULLDUPLEX)
   {
-         ptask_link_create_resource(bprintf("%s_UP",struct_lnk->V_link_id), struct_lnk->V_link_bandwidth, struct_lnk->V_link_bandwidth_file,
-                      struct_lnk->V_link_latency, struct_lnk->V_link_latency_file, struct_lnk->V_link_state, struct_lnk->V_link_state_file,
-                      struct_lnk->V_policy_initial_link, current_property_set);
-    ptask_link_create_resource(bprintf("%s_DOWN",struct_lnk->V_link_id), struct_lnk->V_link_bandwidth, struct_lnk->V_link_bandwidth_file,
-            struct_lnk->V_link_latency, struct_lnk->V_link_latency_file, struct_lnk->V_link_state, struct_lnk->V_link_state_file,
-                      struct_lnk->V_policy_initial_link, current_property_set);
+         ptask_link_create_resource(bprintf("%s_UP",link->V_link_id), link->V_link_bandwidth, link->V_link_bandwidth_file,
+                      link->V_link_latency, link->V_link_latency_file, link->V_link_state, link->V_link_state_file,
+                      link->V_policy_initial_link, link->properties);
+    ptask_link_create_resource(bprintf("%s_DOWN",link->V_link_id), link->V_link_bandwidth, link->V_link_bandwidth_file,
+            link->V_link_latency, link->V_link_latency_file, link->V_link_state, link->V_link_state_file,
+            link->V_policy_initial_link, NULL); // FIXME: We need to deep copy the properties or we won't be able to free it
   }
   else
   {
-         ptask_link_create_resource(xbt_strdup(struct_lnk->V_link_id), struct_lnk->V_link_bandwidth, struct_lnk->V_link_bandwidth_file,
-               struct_lnk->V_link_latency, struct_lnk->V_link_latency_file, struct_lnk->V_link_state, struct_lnk->V_link_state_file,
-                      struct_lnk->V_policy_initial_link, current_property_set);
+         ptask_link_create_resource(xbt_strdup(link->V_link_id), link->V_link_bandwidth, link->V_link_bandwidth_file,
+               link->V_link_latency, link->V_link_latency_file, link->V_link_state, link->V_link_state_file,
+                      link->V_policy_initial_link, link->properties);
   }
 
   current_property_set = NULL;
@@ -800,9 +800,8 @@ static void ptask_add_traces(void)
 
 static void ptask_define_callbacks()
 {
-  /* Adding callback functions */
   sg_platf_host_add_cb(ptask_parse_cpu_init);
-  surfxml_add_callback(ETag_surfxml_link_cb_list, &ptask_parse_link_init);
+  sg_platf_link_add_cb(ptask_parse_link_init);
   sg_platf_postparse_add_cb(ptask_add_traces);
 }