Now call communicate and get_route with void* and not char*.

This optim remove call to xbt_lib_get_or_null from
simulation and do the job into the parse time.

diff --git a/src/include/surf/surf.h b/src/include/surf/surf.h
index 4a9e9bc..cdae739 100644 (file)
--- a/src/include/surf/surf.h
+++ b/src/include/surf/surf.h
@@ -29,7 +29,7 @@ typedef enum {
 } e_surf_network_element_type_t;
 
 XBT_PUBLIC(e_surf_network_element_type_t)
 } e_surf_network_element_type_t;
 
 XBT_PUBLIC(e_surf_network_element_type_t)

-  routing_get_network_element_type(const char *name);
+  routing_get_network_element_type(const char* name);

 
 /** @Brief Specify that we use that action */
 XBT_PUBLIC(void) surf_action_ref(surf_action_t action);
 
 /** @Brief Specify that we use that action */
 XBT_PUBLIC(void) surf_action_ref(surf_action_t action);


@@ -184,10 +184,10 @@ typedef struct surf_cpu_model_extension_public {
       *  Public functions specific to the network model
       */
 typedef struct surf_network_model_extension_public {
       *  Public functions specific to the network model
       */
 typedef struct surf_network_model_extension_public {

-  surf_action_t(*communicate) (const char *src_name,
-                               const char *dst_name,
+  surf_action_t(*communicate) (void* src,
+                               void* dst,

                                double size, double rate);
                                double size, double rate);

-  xbt_dynar_t(*get_route) (const char *src_name, const char *dst_name); //FIXME: kill field? That is done by the routing nowadays
+  xbt_dynar_t(*get_route) (void *src, void *dst); //FIXME: kill field? That is done by the routing nowadays

   double (*get_link_bandwidth) (const void *link);
   double (*get_link_latency) (const void *link);
   int (*link_shared) (const void *link);
   double (*get_link_bandwidth) (const void *link);
   double (*get_link_latency) (const void *link);
   int (*link_shared) (const void *link);

diff --git a/src/surf/network.c b/src/surf/network.c
index 2bb1ce5..a6c1583 100644 (file)
--- a/src/surf/network.c
+++ b/src/surf/network.c
@@ -45,11 +45,6 @@ typedef struct s_smpi_factor {
   double value;
 } s_smpi_factor_t;
 
   double value;
 } s_smpi_factor_t;
 

-typedef struct s_net_card *net_card_t;
-typedef struct s_net_card {
-  char* name;
-  void* routing_obj;
-} s_net_card_t;

 
 double sg_sender_gap = 0.0;
 double sg_latency_factor = 1.0; /* default value; can be set by model or from command line */
 
 double sg_sender_gap = 0.0;
 double sg_latency_factor = 1.0; /* default value; can be set by model or from command line */


@@ -747,8 +742,8 @@ static void net_update_resource_state(void *id,
 }
 
 
 }
 
 

-static surf_action_t net_communicate(const char *src_name,
-                                     const char *dst_name, double size,
+static surf_action_t net_communicate(void *src,
+                                     void *dst, double size,

                                      double rate)
 {
   unsigned int i;
                                      double rate)
 {
   unsigned int i;


@@ -762,12 +757,12 @@ static surf_action_t net_communicate(const char *src_name,
 
   xbt_dynar_t route = xbt_dynar_new(global_routing->size_of_link, NULL);
 
 
   xbt_dynar_t route = xbt_dynar_new(global_routing->size_of_link, NULL);
 

-  XBT_IN("(%s,%s,%g,%g)", src_name, dst_name, size, rate);
+  XBT_IN("(%s,%s,%g,%g)", ((network_element_t)src)->name, ((network_element_t)dst)->name, size, rate);

 
 

-  routing_get_route_and_latency(src_name, dst_name, &route, &latency);
+  routing_get_route_and_latency(src, dst, &route, &latency);

   xbt_assert(!xbt_dynar_is_empty(route) || latency,
              "You're trying to send data from %s to %s but there is no connection at all between these two hosts.",
   xbt_assert(!xbt_dynar_is_empty(route) || latency,
              "You're trying to send data from %s to %s but there is no connection at all between these two hosts.",

-             src_name, dst_name);
+             ((network_element_t)src)->name, ((network_element_t)dst)->name);

 
   xbt_dynar_foreach(route, i, link) {
     if (link->lmm_resource.state_current == SURF_RESOURCE_OFF) {
 
   xbt_dynar_foreach(route, i, link) {
     if (link->lmm_resource.state_current == SURF_RESOURCE_OFF) {


@@ -776,7 +771,7 @@ static surf_action_t net_communicate(const char *src_name,
     }
   }
   if (sg_network_crosstraffic == 1) {
     }
   }
   if (sg_network_crosstraffic == 1) {

-    routing_get_route_and_latency(dst_name, src_name, &back_route, NULL);
+    routing_get_route_and_latency(src, dst, &back_route, NULL);

     xbt_dynar_foreach(back_route, i, link) {
       if (link->lmm_resource.state_current == SURF_RESOURCE_OFF) {
         failed = 1;
     xbt_dynar_foreach(back_route, i, link) {
       if (link->lmm_resource.state_current == SURF_RESOURCE_OFF) {
         failed = 1;


@@ -826,7 +821,7 @@ static surf_action_t net_communicate(const char *src_name,
     link = *(link_CM02_t *) xbt_dynar_get_ptr(route, 0);
     gap_append(size, link, action);
     XBT_DEBUG("Comm %p: %s -> %s gap=%f (lat=%f)",
     link = *(link_CM02_t *) xbt_dynar_get_ptr(route, 0);
     gap_append(size, link, action);
     XBT_DEBUG("Comm %p: %s -> %s gap=%f (lat=%f)",

-              action, src_name, dst_name, action->sender.gap,
+              action, ((network_element_t)src)->name, ((network_element_t)dst)->name, action->sender.gap,

               action->latency);
   }
 
               action->latency);
   }
 


@@ -883,7 +878,7 @@ static surf_action_t net_communicate(const char *src_name,
   return (surf_action_t) action;
 }
 
   return (surf_action_t) action;
 }
 

-static xbt_dynar_t net_get_route(const char *src, const char *dst)
+static xbt_dynar_t net_get_route(void *src, void *dst)

 {
   xbt_dynar_t route = NULL;
   routing_get_route_and_latency(src, dst, &route, NULL);
 {
   xbt_dynar_t route = NULL;
   routing_get_route_and_latency(src, dst, &route, NULL);

diff --git a/src/surf/network_constant.c b/src/surf/network_constant.c
index d0f25db..fc5580d 100644 (file)
--- a/src/surf/network_constant.c
+++ b/src/surf/network_constant.c
@@ -109,12 +109,15 @@ static void netcste_update_resource_state(void *id,
   DIE_IMPOSSIBLE;
 }
 
   DIE_IMPOSSIBLE;
 }
 

-static surf_action_t netcste_communicate(const char *src_name,
-                                         const char *dst_name, double size,
+static surf_action_t netcste_communicate(void *src,
+                                         void *dst, double size,

                                          double rate)
 {
   surf_action_network_Constant_t action = NULL;
 
                                          double rate)
 {
   surf_action_network_Constant_t action = NULL;
 

+  char *src_name = ((network_element_t)src)->name;
+  char *dst_name = ((network_element_t)dst)->name;
+

   XBT_IN("(%s,%s,%g,%g)", src_name, dst_name, size, rate);
 
   action =
   XBT_IN("(%s,%s,%g,%g)", src_name, dst_name, size, rate);
 
   action =

diff --git a/src/surf/network_gtnets.c b/src/surf/network_gtnets.c
index 7e5dcd1..48849da 100644 (file)
--- a/src/surf/network_gtnets.c
+++ b/src/surf/network_gtnets.c
@@ -339,8 +339,8 @@ static void update_resource_state(void *id,
 }
 
 /* Max durations are not supported */
 }
 
 /* Max durations are not supported */

-static surf_action_t communicate(const char *src_name,
-                                 const char *dst_name, double size,
+static surf_action_t communicate(void *src_card,
+                                 void *dst_card, double size,

                                  double rate)
 {
   int src, dst;
                                  double rate)
 {
   int src, dst;

diff --git a/src/surf/network_ns3.c b/src/surf/network_ns3.c
index 6e047c7..648b321 100644 (file)
--- a/src/surf/network_ns3.c
+++ b/src/surf/network_ns3.c
@@ -232,10 +232,10 @@ static double ns3_get_link_bandwidth (const void *link)
   return bdw;
 }
 
   return bdw;
 }
 

-static xbt_dynar_t ns3_get_route(const char *src, const char *dst)
+static xbt_dynar_t ns3_get_route(void *src_card, void *dst_card)

 {
   xbt_dynar_t route = NULL;
 {
   xbt_dynar_t route = NULL;

-  routing_get_route_and_latency(src, dst, &route, NULL);
+  routing_get_route_and_latency(src_card, dst_card, &route, NULL);

   return route;
 }
 
   return route;
 }
 


@@ -478,8 +478,8 @@ static void ns3_update_actions_state(double now, double delta)
 }
 
 /* Max durations are not supported */
 }
 
 /* Max durations are not supported */

-static surf_action_t ns3_communicate(const char *src_name,
-                                 const char *dst_name, double size, double rate)
+static surf_action_t ns3_communicate(void *src_card,
+                                 void *dst_card, double size, double rate)

 {
   surf_action_network_ns3_t action = NULL;
 
 {
   surf_action_network_ns3_t action = NULL;
 

diff --git a/src/surf/surf_private.h b/src/surf/surf_private.h
index 296fef3..bfd298c 100644 (file)
--- a/src/surf/surf_private.h
+++ b/src/surf/surf_private.h
@@ -102,19 +102,26 @@ const char *__surf_get_initial_path(void);
  */
 int __surf_is_absolute_file_path(const char *file_path);
 
  */
 int __surf_is_absolute_file_path(const char *file_path);
 

+typedef struct s_as *AS_t;
+typedef struct s_network_element_info {
+  AS_t rc_component;
+  e_surf_network_element_type_t rc_type;
+  int id;
+  char *name;
+} s_network_element_t, *network_element_t;
+

 /*
  * Link of lenght 1, alongside with its source and destination. This is mainly usefull in the bindings to gtnets and ns3
  */
 typedef struct s_onelink {
 /*
  * Link of lenght 1, alongside with its source and destination. This is mainly usefull in the bindings to gtnets and ns3
  */
 typedef struct s_onelink {

-  char *src;
-  char *dst;
+  network_element_t src;
+  network_element_t dst;

   void *link_ptr;
 } s_onelink_t, *onelink_t;
 
 /**
  * Routing logic
  */
   void *link_ptr;
 } s_onelink_t, *onelink_t;
 
 /**
  * Routing logic
  */

-typedef struct s_as *AS_t;

 
 typedef struct s_model_type {
   const char *name;
 
 typedef struct s_model_type {
   const char *name;


@@ -125,8 +132,8 @@ typedef struct s_model_type {
 
 typedef struct s_route {
   xbt_dynar_t link_list;
 
 typedef struct s_route {
   xbt_dynar_t link_list;

-  char *src_gateway;
-  char *dst_gateway;
+  network_element_t src_gateway;
+  network_element_t dst_gateway;

 } s_route_t, *route_t;
 
 /* This enum used in the routing structure helps knowing in which situation we are. */
 } s_route_t, *route_t;
 
 /* This enum used in the routing structure helps knowing in which situation we are. */


@@ -137,18 +144,19 @@ typedef enum {
 } e_surf_routing_hierarchy_t;
 
 typedef struct s_as {
 } e_surf_routing_hierarchy_t;
 
 typedef struct s_as {

-  xbt_dict_t to_index;                 /* char* -> network_element_t */
+  int nb_index;

   xbt_dict_t bypassRoutes;             /* store bypass routes */
   routing_model_description_t model_desc;
   e_surf_routing_hierarchy_t hierarchy;
   char *name;
   struct s_as *routing_father;
   xbt_dict_t routing_sons;
   xbt_dict_t bypassRoutes;             /* store bypass routes */
   routing_model_description_t model_desc;
   e_surf_routing_hierarchy_t hierarchy;
   char *name;
   struct s_as *routing_father;
   xbt_dict_t routing_sons;

+  network_element_t net_elem;

 
 

-  void (*get_route_and_latency) (AS_t as, const char *src, const char *dst, route_t into, double *latency);
+  void (*get_route_and_latency) (AS_t as, network_element_t src, network_element_t dst, route_t into, double *latency);

 
   xbt_dynar_t(*get_onelink_routes) (AS_t as);
 
   xbt_dynar_t(*get_onelink_routes) (AS_t as);

-  route_t(*get_bypass_route) (AS_t as, const char *src, const char *dst);
+  route_t(*get_bypass_route) (AS_t as, network_element_t src, network_element_t dst);

   void (*finalize) (AS_t as);
 
 
   void (*finalize) (AS_t as);
 
 


@@ -156,8 +164,8 @@ typedef struct s_as {
    * that a new element is added to the AS currently built.
    *
    * Of course, only the routing model of this AS is informed, not every ones */
    * that a new element is added to the AS currently built.
    *
    * Of course, only the routing model of this AS is informed, not every ones */

-  void (*parse_PU) (AS_t as, const char *name); /* A host or a router, whatever */
-  void (*parse_AS) (AS_t as, const char *name);
+  int (*parse_PU) (AS_t as, const char *name); /* A host or a router, whatever */
+  int (*parse_AS) (AS_t as, const char *name);

   void (*parse_route) (AS_t as, const char *src,
                      const char *dst, route_t route);
   void (*parse_ASroute) (AS_t as, const char *src,
   void (*parse_route) (AS_t as, const char *src,
                      const char *dst, route_t route);
   void (*parse_ASroute) (AS_t as, const char *src,


@@ -166,15 +174,6 @@ typedef struct s_as {
                            const char *dst, route_t e_route);
 } s_as_t;
 
                            const char *dst, route_t e_route);
 } s_as_t;
 

-typedef struct s_network_element_info {
-  AS_t rc_component;
-  e_surf_network_element_type_t rc_type;
-  int id;
-  char *name;
-} s_network_element_info_t, *network_element_info_t;
-
-typedef int *network_element_t;
-

 struct s_routing_global {
   AS_t root;
   void *loopback;
 struct s_routing_global {
   AS_t root;
   void *loopback;


@@ -190,7 +189,7 @@ XBT_PUBLIC(void) generic_free_route(route_t route); // FIXME rename to routing_r
  // FIXME: make previous function private to routing again?
 
 
  // FIXME: make previous function private to routing again?
 
 

-XBT_PUBLIC(void) routing_get_route_and_latency(const char *src, const char *dst,
+XBT_PUBLIC(void) routing_get_route_and_latency(network_element_t src, network_element_t dst,

                               xbt_dynar_t * route, double *latency);
 
 /**
                               xbt_dynar_t * route, double *latency);
 
 /**

diff --git a/src/surf/surf_routing.c b/src/surf/surf_routing.c
index 96d3634..b2e27e8 100644 (file)
--- a/src/surf/surf_routing.c
+++ b/src/surf/surf_routing.c
@@ -102,17 +102,19 @@ struct s_model_type routing_models[] = {
  */
 static void parse_S_host(sg_platf_host_cbarg_t host)
 {
  */
 static void parse_S_host(sg_platf_host_cbarg_t host)
 {

-  network_element_info_t info = NULL;
+  network_element_t info = NULL;

   if (current_routing->hierarchy == SURF_ROUTING_NULL)
     current_routing->hierarchy = SURF_ROUTING_BASE;
   xbt_assert(!xbt_lib_get_or_null(host_lib, host->id, ROUTING_HOST_LEVEL),
              "Reading a host, processing unit \"%s\" already exists", host->id);
 
   if (current_routing->hierarchy == SURF_ROUTING_NULL)
     current_routing->hierarchy = SURF_ROUTING_BASE;
   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);
-  info = xbt_new0(s_network_element_info_t, 1);
+  info = xbt_new0(s_network_element_t, 1);

   info->rc_component = current_routing;
   info->rc_type = SURF_NETWORK_ELEMENT_HOST;
   info->rc_component = current_routing;
   info->rc_type = SURF_NETWORK_ELEMENT_HOST;

+  info->name = xbt_strdup(host->id);
+  info->id = current_routing->parse_PU(current_routing, host->id);

   xbt_lib_set(host_lib, host->id, ROUTING_HOST_LEVEL, (void *) info);
   xbt_lib_set(host_lib, host->id, ROUTING_HOST_LEVEL, (void *) info);

+  XBT_DEBUG("Having set name '%s' id '%d'",host->id,info->id);

 
   if(mount_list){
     xbt_lib_set(storage_lib, host->id, ROUTING_STORAGE_HOST_LEVEL, (void *) mount_list);
 
   if(mount_list){
     xbt_lib_set(storage_lib, host->id, ROUTING_STORAGE_HOST_LEVEL, (void *) mount_list);


@@ -124,8 +126,7 @@ static void parse_S_host(sg_platf_host_cbarg_t host)
     char*str;
 
     if (!COORD_HOST_LEVEL)
     char*str;
 
     if (!COORD_HOST_LEVEL)

-      xbt_die ("To use host coordinates, please add --cfg=coordinates:yes to your command line");
-
+      xbt_die ("To use host coordinates, please add --cfg=network/coordinates:yes to your command line");

     /* Pre-parse the host coordinates -- FIXME factorize with routers by overloading the routing->parse_PU function*/
     xbt_dynar_t ctn_str = xbt_str_split_str(host->coord, " ");
     xbt_dynar_t ctn = xbt_dynar_new(sizeof(double),NULL);
     /* Pre-parse the host coordinates -- FIXME factorize with routers by overloading the routing->parse_PU function*/
     xbt_dynar_t ctn_str = xbt_str_split_str(host->coord, " ");
     xbt_dynar_t ctn = xbt_dynar_new(sizeof(double),NULL);


@@ -136,6 +137,7 @@ static void parse_S_host(sg_platf_host_cbarg_t host)
     xbt_dynar_shrink(ctn, 0);
     xbt_dynar_free(&ctn_str);
     xbt_lib_set(host_lib, host->id, COORD_HOST_LEVEL, (void *) ctn);
     xbt_dynar_shrink(ctn, 0);
     xbt_dynar_free(&ctn_str);
     xbt_lib_set(host_lib, host->id, COORD_HOST_LEVEL, (void *) ctn);

+    XBT_DEBUG("Having set host coordinates for '%s'",host->id);

   }
 }
 
   }
 }
 


@@ -144,26 +146,27 @@ static void parse_S_host(sg_platf_host_cbarg_t host)
  */
 static void parse_S_router(sg_platf_router_cbarg_t router)
 {
  */
 static void parse_S_router(sg_platf_router_cbarg_t router)
 {

-  network_element_info_t info = NULL;
+  network_element_t info = NULL;

   if (current_routing->hierarchy == SURF_ROUTING_NULL)
     current_routing->hierarchy = SURF_ROUTING_BASE;
   xbt_assert(!xbt_lib_get_or_null(as_router_lib, router->id, ROUTING_ASR_LEVEL),
              "Reading a router, processing unit \"%s\" already exists",
              router->id);
 
   if (current_routing->hierarchy == SURF_ROUTING_NULL)
     current_routing->hierarchy = SURF_ROUTING_BASE;
   xbt_assert(!xbt_lib_get_or_null(as_router_lib, router->id, ROUTING_ASR_LEVEL),
              "Reading a router, processing unit \"%s\" already exists",
              router->id);
 

-  current_routing->parse_PU(current_routing, router->id);
-  info = xbt_new0(s_network_element_info_t, 1);
+  info = xbt_new0(s_network_element_t, 1);

   info->rc_component = current_routing;
   info->rc_type = SURF_NETWORK_ELEMENT_ROUTER;
   info->rc_component = current_routing;
   info->rc_type = SURF_NETWORK_ELEMENT_ROUTER;

-
+  info->name = xbt_strdup(router->id);
+  info->id = current_routing->parse_PU(current_routing, router->id);

   xbt_lib_set(as_router_lib, router->id, ROUTING_ASR_LEVEL, (void *) info);
   xbt_lib_set(as_router_lib, router->id, ROUTING_ASR_LEVEL, (void *) info);

+  XBT_DEBUG("Having set name '%s' id '%d'",router->id,info->id);
+

   if (strcmp(router->coord, "")) {
     unsigned int cursor;
     char*str;
 
     if (!COORD_ASR_LEVEL)
   if (strcmp(router->coord, "")) {
     unsigned int cursor;
     char*str;
 
     if (!COORD_ASR_LEVEL)

-      xbt_die ("To use host coordinates, please add --cfg=coordinates:yes to your command line");
-
+      xbt_die ("To use host coordinates, please add --cfg=network/coordinates:yes to your command line");

     /* Pre-parse the host coordinates */
     xbt_dynar_t ctn_str = xbt_str_split_str(router->coord, " ");
     xbt_dynar_t ctn = xbt_dynar_new(sizeof(double),NULL);
     /* Pre-parse the host coordinates */
     xbt_dynar_t ctn_str = xbt_str_split_str(router->coord, " ");
     xbt_dynar_t ctn = xbt_dynar_new(sizeof(double),NULL);


@@ -174,6 +177,7 @@ static void parse_S_router(sg_platf_router_cbarg_t router)
     xbt_dynar_shrink(ctn, 0);
     xbt_dynar_free(&ctn_str);
     xbt_lib_set(as_router_lib, router->id, COORD_ASR_LEVEL, (void *) ctn);
     xbt_dynar_shrink(ctn, 0);
     xbt_dynar_free(&ctn_str);
     xbt_lib_set(as_router_lib, router->id, COORD_ASR_LEVEL, (void *) ctn);

+    XBT_DEBUG("Having set router coordinates for '%s'",router->id);

   }
 }
 
   }
 }
 


@@ -279,8 +283,19 @@ static void routing_parse_E_ASroute(void)
 {
   route_t e_route = xbt_new0(s_route_t, 1);
   e_route->link_list = parsed_link_list;
 {
   route_t e_route = xbt_new0(s_route_t, 1);
   e_route->link_list = parsed_link_list;

-  e_route->src_gateway = xbt_strdup(gw_src);
-  e_route->dst_gateway = xbt_strdup(gw_dst);
+
+  if(!strcmp(current_routing->model_desc->name,"RuleBased")) {
+    e_route->src_gateway = (network_element_t) gw_src; // DIRTY HACK possible only
+    e_route->dst_gateway = (network_element_t) gw_dst; // because of what is in routing_parse_E_ASroute
+  }
+  else{
+  e_route->src_gateway =  ((network_element_t)xbt_lib_get_or_null(as_router_lib,gw_src,ROUTING_ASR_LEVEL));
+  if(!e_route->src_gateway)
+    e_route->src_gateway = ((network_element_t)xbt_lib_get_or_null(host_lib,gw_src,ROUTING_HOST_LEVEL));
+  e_route->dst_gateway =  ((network_element_t)xbt_lib_get_or_null(as_router_lib,gw_dst,ROUTING_ASR_LEVEL));
+  if(!e_route->dst_gateway)
+    e_route->dst_gateway = ((network_element_t)xbt_lib_get_or_null(host_lib,gw_dst,ROUTING_HOST_LEVEL));
+  }

   xbt_assert(current_routing->parse_ASroute,
              "no defined method \"set_ASroute\" in \"%s\"",
              current_routing->name);
   xbt_assert(current_routing->parse_ASroute,
              "no defined method \"set_ASroute\" in \"%s\"",
              current_routing->name);


@@ -300,8 +315,12 @@ static void routing_parse_E_bypassRoute(void)
 {
   route_t e_route = xbt_new0(s_route_t, 1);
   e_route->link_list = parsed_link_list;
 {
   route_t e_route = xbt_new0(s_route_t, 1);
   e_route->link_list = parsed_link_list;

-  e_route->src_gateway = xbt_strdup(gw_src);
-  e_route->dst_gateway = xbt_strdup(gw_dst);
+  e_route->src_gateway =  ((network_element_t)xbt_lib_get_or_null(as_router_lib,gw_src,ROUTING_ASR_LEVEL));
+  if(!e_route->src_gateway)
+    e_route->src_gateway = ((network_element_t)xbt_lib_get_or_null(host_lib,gw_src,ROUTING_HOST_LEVEL));
+  e_route->dst_gateway =  ((network_element_t)xbt_lib_get_or_null(as_router_lib,gw_dst,ROUTING_ASR_LEVEL));
+  if(!e_route->dst_gateway)
+    e_route->dst_gateway = ((network_element_t)xbt_lib_get_or_null(host_lib,gw_dst,ROUTING_HOST_LEVEL));

   xbt_assert(current_routing->parse_bypassroute,
              "Bypassing mechanism not implemented by routing '%s'",
              current_routing->name);
   xbt_assert(current_routing->parse_bypassroute,
              "Bypassing mechanism not implemented by routing '%s'",
              current_routing->name);


@@ -332,6 +351,10 @@ void routing_AS_begin(const char *AS_id, const char *wanted_routing_type)
   routing_model_description_t model = NULL;
   int cpt;
 
   routing_model_description_t model = NULL;
   int cpt;
 

+  xbt_assert(!xbt_lib_get_or_null
+             (as_router_lib, AS_id, ROUTING_ASR_LEVEL),
+             "The AS \"%s\" already exists", AS_id);
+

   /* search the routing model */
   for (cpt = 0; routing_models[cpt].name; cpt++)
     if (!strcmp(wanted_routing_type, routing_models[cpt].name))
   /* search the routing model */
   for (cpt = 0; routing_models[cpt].name; cpt++)
     if (!strcmp(wanted_routing_type, routing_models[cpt].name))


@@ -352,12 +375,15 @@ void routing_AS_begin(const char *AS_id, const char *wanted_routing_type)
   new_as->hierarchy = SURF_ROUTING_NULL;
   new_as->name = xbt_strdup(AS_id);
 
   new_as->hierarchy = SURF_ROUTING_NULL;
   new_as->name = xbt_strdup(AS_id);
 

+  network_element_t info = NULL;
+  info = xbt_new0(s_network_element_t, 1);
+

   if (current_routing == NULL && global_routing->root == NULL) {
 
     /* it is the first one */
     new_as->routing_father = NULL;
     global_routing->root = new_as;
   if (current_routing == NULL && global_routing->root == NULL) {
 
     /* it is the first one */
     new_as->routing_father = NULL;
     global_routing->root = new_as;

-
+    info->id = -1;

   } else if (current_routing != NULL && global_routing->root != NULL) {
 
     xbt_assert(!xbt_dict_get_or_null
   } else if (current_routing != NULL && global_routing->root != NULL) {
 
     xbt_assert(!xbt_dict_get_or_null


@@ -372,12 +398,23 @@ void routing_AS_begin(const char *AS_id, const char *wanted_routing_type)
     xbt_dict_set(current_routing->routing_sons, AS_id,
                  (void *) new_as, NULL);
     /* add to the father element list */
     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);
+    info->id = current_routing->parse_AS(current_routing, AS_id);

   } else {
     THROWF(arg_error, 0, "All defined components must be belong to a AS");
   }
   } else {
     THROWF(arg_error, 0, "All defined components must be belong to a AS");
   }

+
+  info->rc_component = new_as->routing_father;
+  info->rc_type = SURF_NETWORK_ELEMENT_AS;
+  info->name = new_as->name;
+
+  xbt_lib_set(as_router_lib, new_as->name, ROUTING_ASR_LEVEL,
+              (void *) info);
+  XBT_DEBUG("Having set name '%s' id '%d'",new_as->name,info->id);
+

   /* set the new current component of the tree */
   current_routing = new_as;
   /* set the new current component of the tree */
   current_routing = new_as;

+  current_routing->net_elem = info;
+

 }
 
 /**
 }
 
 /**


@@ -397,16 +434,6 @@ void routing_AS_end()
   if (current_routing == NULL) {
     THROWF(arg_error, 0, "Close an AS, but none was under construction");
   } else {
   if (current_routing == NULL) {
     THROWF(arg_error, 0, "Close an AS, but none was under construction");
   } else {

-    network_element_info_t info = NULL;
-    xbt_assert(!xbt_lib_get_or_null
-               (as_router_lib, current_routing->name, ROUTING_ASR_LEVEL),
-               "The AS \"%s\" already exists", current_routing->name);
-    info = xbt_new0(s_network_element_info_t, 1);
-    info->rc_component = current_routing->routing_father;
-    info->rc_type = SURF_NETWORK_ELEMENT_AS;
-    xbt_lib_set(as_router_lib, current_routing->name, ROUTING_ASR_LEVEL,
-                (void *) info);
-

     if (current_routing->model_desc->end)
       current_routing->model_desc->end(current_routing);
     current_routing = current_routing->routing_father;
     if (current_routing->model_desc->end)
       current_routing->model_desc->end(current_routing);
     current_routing = current_routing->routing_father;


@@ -424,7 +451,7 @@ void routing_AS_end()
  * Get the common father of the to processing units, and the first different 
  * father in the chain
  */
  * Get the common father of the to processing units, and the first different 
  * father in the chain
  */

-static void elements_father(const char *src, const char *dst,
+static void elements_father(network_element_t src, network_element_t dst,

                             AS_t * res_father,
                             AS_t * res_src,
                             AS_t * res_dst)
                             AS_t * res_father,
                             AS_t * res_src,
                             AS_t * res_dst)


@@ -442,19 +469,15 @@ static void elements_father(const char *src, const char *dst,
   AS_t father;
 
   /* (1) find the as where the src and dst are located */
   AS_t father;
 
   /* (1) find the as where the src and dst are located */

-  network_element_info_t src_data = xbt_lib_get_or_null(host_lib, src,
-                                                        ROUTING_HOST_LEVEL);
-  network_element_info_t dst_data = xbt_lib_get_or_null(host_lib, dst,
-                                                        ROUTING_HOST_LEVEL);
-  if (!src_data)
-    src_data = xbt_lib_get_or_null(as_router_lib, src, ROUTING_ASR_LEVEL);
-  if (!dst_data)
-    dst_data = xbt_lib_get_or_null(as_router_lib, dst, ROUTING_ASR_LEVEL);
+  network_element_t src_data = src;
+  network_element_t dst_data = dst;

   src_as = src_data->rc_component;
   dst_as = dst_data->rc_component;
   src_as = src_data->rc_component;
   dst_as = dst_data->rc_component;

+  char* src_name = src_data->name;
+  char* dst_name = dst_data->name;

 
   xbt_assert(src_as && dst_as,
 
   xbt_assert(src_as && dst_as,

-             "Ask for route \"from\"(%s) or \"to\"(%s) no found", src, dst);
+             "Ask for route \"from\"(%s) or \"to\"(%s) no found", src_name, dst_name);

 
   /* (2) find the path to the root routing component */
   for (current = src_as; current != NULL; current = current->routing_father) {
 
   /* (2) find the path to the root routing component */
   for (current = src_as; current != NULL; current = current->routing_father) {


@@ -501,18 +524,20 @@ static void elements_father(const char *src, const char *dst,
  * This function is called by "get_route" and "get_latency". It allows to walk
  * recursively through the ASes tree.
  */
  * This function is called by "get_route" and "get_latency". It allows to walk
  * recursively through the ASes tree.
  */

-static void _get_route_and_latency(const char *src, const char *dst,
+static void _get_route_and_latency(network_element_t src, network_element_t dst,

                                    xbt_dynar_t * links, double *latency)
 {
   s_route_t route;
   memset(&route,0,sizeof(route));
 
                                    xbt_dynar_t * links, double *latency)
 {
   s_route_t route;
   memset(&route,0,sizeof(route));
 

-  XBT_DEBUG("Solve route/latency  \"%s\" to \"%s\"", src, dst);
+  XBT_DEBUG("Solve route/latency  \"%s\" to \"%s\"", src->name, dst->name);

   xbt_assert(src && dst, "bad parameters for \"_get_route_latency\" method");
 
   /* Find how src and dst are interconnected */
   AS_t common_father, src_father, dst_father;
   elements_father(src, dst, &common_father, &src_father, &dst_father);
   xbt_assert(src && dst, "bad parameters for \"_get_route_latency\" method");
 
   /* Find how src and dst are interconnected */
   AS_t common_father, src_father, dst_father;
   elements_father(src, dst, &common_father, &src_father, &dst_father);

+  XBT_DEBUG("elements_father: common father '%s' src_father '%s' dst_father '%s'",
+      common_father->name,src_father->name,dst_father->name);

 
   /* If src and dst are in the same AS, life is good */
   if (src_father == dst_father) {       /* SURF_ROUTING_BASE */
 
   /* If src and dst are in the same AS, life is good */
   if (src_father == dst_father) {       /* SURF_ROUTING_BASE */


@@ -520,9 +545,6 @@ static void _get_route_and_latency(const char *src, const char *dst,
     route.link_list = *links;
 
     common_father->get_route_and_latency(common_father, src, dst, &route,latency);
     route.link_list = *links;
 
     common_father->get_route_and_latency(common_father, src, dst, &route,latency);

-
-    xbt_free(route.src_gateway);
-    xbt_free(route.dst_gateway);

     return;
   }
 
     return;
   }
 


@@ -543,32 +565,32 @@ static void _get_route_and_latency(const char *src, const char *dst,
     return;
   }
 
     return;
   }
 

-

   /* Not in the same AS, no bypass. We'll have to find our path between the ASes recursively*/
 
   route.link_list = xbt_dynar_new(global_routing->size_of_link, NULL);
   /* Not in the same AS, no bypass. We'll have to find our path between the ASes recursively*/
 
   route.link_list = xbt_dynar_new(global_routing->size_of_link, NULL);

-  common_father->get_route_and_latency(common_father, src_father->name, dst_father->name, &route,latency);
+  // Find the net_card corresponding to father
+  network_element_t src_father_net_elm = src_father->net_elem;
+  network_element_t dst_father_net_elm = dst_father->net_elem;
+
+  common_father->get_route_and_latency(common_father, src_father_net_elm, dst_father_net_elm, &route,latency);

 
   xbt_assert((route.src_gateway != NULL) && (route.dst_gateway != NULL),
 
   xbt_assert((route.src_gateway != NULL) && (route.dst_gateway != NULL),

-      "bad gateways for route from \"%s\" to \"%s\"", src, dst);
+      "bad gateways for route from \"%s\" to \"%s\"", src->name, dst->name);

 
 

-  char*src_gateway = route.src_gateway;
-  char*dst_gateway = route.dst_gateway;
+  network_element_t src_gateway_net_elm = route.src_gateway;
+  network_element_t dst_gateway_net_elm = route.dst_gateway;

 
   /* If source gateway is not our source, we have to recursively find our way up to this point */
 
   /* If source gateway is not our source, we have to recursively find our way up to this point */

-  if (strcmp(src, src_gateway))
-    _get_route_and_latency(src, src_gateway, links, latency);
+  if (strcmp(src->name, src_gateway_net_elm->name))
+    _get_route_and_latency(src, src_gateway_net_elm, links, latency);

 
   xbt_dynar_merge(links,&(route.link_list));
 
   /* If dest gateway is not our destination, we have to recursively find our way from this point */
   // FIXME why can't I factorize it the same way than [src;src_gw] without breaking the examples??
 
   xbt_dynar_merge(links,&(route.link_list));
 
   /* If dest gateway is not our destination, we have to recursively find our way from this point */
   // FIXME why can't I factorize it the same way than [src;src_gw] without breaking the examples??

-  if (strcmp(dst_gateway, dst)) {
-    _get_route_and_latency(dst_gateway, dst, links, latency);
+  if (strcmp(dst_gateway_net_elm->name, dst->name)) {
+    _get_route_and_latency(dst_gateway_net_elm, dst, links, latency);

   }
   }

-
-  xbt_free(src_gateway);
-  xbt_free_f(dst_gateway);

   xbt_dynar_free(&route.link_list);
 }
 
   xbt_dynar_free(&route.link_list);
 }
 


@@ -586,7 +608,7 @@ static void _get_route_and_latency(const char *src, const char *dst,
  * walk through the routing components tree and find a route between hosts
  * by calling the differents "get_route" functions in each routing component.
  */
  * walk through the routing components tree and find a route between hosts
  * by calling the differents "get_route" functions in each routing component.
  */

-void routing_get_route_and_latency(const char *src, const char *dst,
+void routing_get_route_and_latency(network_element_t src, network_element_t dst,

                                    xbt_dynar_t * route, double *latency)
 {
   if (!*route) {
                                    xbt_dynar_t * route, double *latency)
 {
   if (!*route) {


@@ -597,7 +619,7 @@ void routing_get_route_and_latency(const char *src, const char *dst,
   _get_route_and_latency(src, dst, route, latency);
 
   xbt_assert(!latency || *latency >= 0.0,
   _get_route_and_latency(src, dst, route, latency);
 
   xbt_assert(!latency || *latency >= 0.0,

-             "negative latency on route between \"%s\" and \"%s\"", src, dst);
+             "negative latency on route between \"%s\" and \"%s\"", src->name, dst->name);

 }
 
 static xbt_dynar_t recursive_get_onelink_routes(AS_t rc)
 }
 
 static xbt_dynar_t recursive_get_onelink_routes(AS_t rc)


@@ -628,7 +650,7 @@ static xbt_dynar_t get_onelink_routes(void)
 
 e_surf_network_element_type_t routing_get_network_element_type(const char *name)
 {
 
 e_surf_network_element_type_t routing_get_network_element_type(const char *name)
 {

-  network_element_info_t rc = NULL;
+  network_element_t rc = NULL;

 
   rc = xbt_lib_get_or_null(host_lib, name, ROUTING_HOST_LEVEL);
   if (rc)
 
   rc = xbt_lib_get_or_null(host_lib, name, ROUTING_HOST_LEVEL);
   if (rc)

diff --git a/src/surf/surf_routing_cluster.c b/src/surf/surf_routing_cluster.c
index 8400159..9031e51 100644 (file)
--- a/src/surf/surf_routing_cluster.c
+++ b/src/surf/surf_routing_cluster.c
@@ -23,12 +23,12 @@ static xbt_dict_t cluster_host_link = NULL;
 
 /* Business methods */
 static void cluster_get_route_and_latency(AS_t as,
 
 /* Business methods */
 static void cluster_get_route_and_latency(AS_t as,

-                                          const char *src, const char *dst,
+    network_element_t src, network_element_t dst,

                                           route_t route, double *lat) {
 
          surf_parsing_link_up_down_t info;
 
                                           route_t route, double *lat) {
 
          surf_parsing_link_up_down_t info;
 

-         info = xbt_dict_get_or_null(cluster_host_link,src);
+         info = xbt_dict_get_or_null(cluster_host_link,src->name);

          if(info) { // link up
            xbt_dynar_push_as(route->link_list,void*,info->link_up);
       if (lat)
          if(info) { // link up
            xbt_dynar_push_as(route->link_list,void*,info->link_up);
       if (lat)


@@ -41,7 +41,7 @@ static void cluster_get_route_and_latency(AS_t as,
         *lat += surf_network_model->extension.network.get_link_latency(((as_cluster_t)as)->backbone);
          }
 
         *lat += surf_network_model->extension.network.get_link_latency(((as_cluster_t)as)->backbone);
          }
 

-         info = xbt_dict_get_or_null(cluster_host_link,dst);
+         info = xbt_dict_get_or_null(cluster_host_link,dst->name);

          if(info) { // link down
            xbt_dynar_push_as(route->link_list,void*,info->link_down);
       if (lat)
          if(info) { // link down
            xbt_dynar_push_as(route->link_list,void*,info->link_down);
       if (lat)

diff --git a/src/surf/surf_routing_dijkstra.c b/src/surf/surf_routing_dijkstra.c
index 48a321a..e6a11c3 100644 (file)
--- a/src/surf/surf_routing_dijkstra.c
+++ b/src/surf/surf_routing_dijkstra.c
@@ -166,43 +166,43 @@ static void add_loopback_dijkstra(as_dijkstra_t as) {
 }
 
 static void dijkstra_get_route_and_latency(AS_t as_generic,
 }
 
 static void dijkstra_get_route_and_latency(AS_t as_generic,

-        const char *src, const char *dst, route_t route, double *lat);
+    network_element_t src, network_element_t dst, route_t route, double *lat);

 
 static xbt_dynar_t dijkstra_get_onelink_routes(AS_t as)
 {
          xbt_dynar_t ret = xbt_dynar_new(sizeof(onelink_t), xbt_free);
 
 static xbt_dynar_t dijkstra_get_onelink_routes(AS_t as)
 {
          xbt_dynar_t ret = xbt_dynar_new(sizeof(onelink_t), xbt_free);

-
-         //size_t table_size = xbt_dict_length(routing->generic_routing.to_index);
-         xbt_dict_cursor_t c1 = NULL, c2 = NULL;
-         char *k1, *d1, *k2, *d2;
-         xbt_dict_foreach(as->to_index, c1, k1, d1) {
-           xbt_dict_foreach(as->to_index, c2, k2, d2) {
-             route_t route = xbt_new0(s_route_t,1);
-             route->link_list = xbt_dynar_new(global_routing->size_of_link,NULL);
-             dijkstra_get_route_and_latency(as, k1, k2,route, NULL);
-
-             if (xbt_dynar_length(route->link_list) == 1) {
-               void *link =
-                   *(void **) xbt_dynar_get_ptr(route->link_list, 0);
-               onelink_t onelink = xbt_new0(s_onelink_t, 1);
-               onelink->link_ptr = link;
-               if (as->hierarchy == SURF_ROUTING_BASE) {
-                 onelink->src = xbt_strdup(k1);
-                 onelink->dst = xbt_strdup(k2);
-               } else if (as->hierarchy ==
-                   SURF_ROUTING_RECURSIVE) {
-                 onelink->src = xbt_strdup(route->src_gateway);
-                 onelink->dst = xbt_strdup(route->dst_gateway);
-               }
-               xbt_dynar_push(ret, &onelink);
-             }
-           }
-         }
+         THROW_UNIMPLEMENTED;
+//       //size_t table_size = xbt_dict_length(routing->generic_routing.to_index);
+//       xbt_dict_cursor_t c1 = NULL, c2 = NULL;
+//       char *k1, *d1, *k2, *d2;
+//       xbt_dict_foreach(as->to_index, c1, k1, d1) {
+//         xbt_dict_foreach(as->to_index, c2, k2, d2) {
+//           route_t route = xbt_new0(s_route_t,1);
+//           route->link_list = xbt_dynar_new(global_routing->size_of_link,NULL);
+//           dijkstra_get_route_and_latency(as, k1, k2,route, NULL);
+//
+//           if (xbt_dynar_length(route->link_list) == 1) {
+//             void *link =
+//                 *(void **) xbt_dynar_get_ptr(route->link_list, 0);
+//             onelink_t onelink = xbt_new0(s_onelink_t, 1);
+//             onelink->link_ptr = link;
+//             if (as->hierarchy == SURF_ROUTING_BASE) {
+//               onelink->src = xbt_strdup(k1);
+//               onelink->dst = xbt_strdup(k2);
+//             } else if (as->hierarchy ==
+//                 SURF_ROUTING_RECURSIVE) {
+//               onelink->src = route->src_gateway;
+//               onelink->dst = route->dst_gateway;
+//             }
+//             xbt_dynar_push(ret, &onelink);
+//           }
+//         }
+//       }

          return ret;
 }
 
 static void dijkstra_get_route_and_latency(AS_t asg,
          return ret;
 }
 
 static void dijkstra_get_route_and_latency(AS_t asg,

-                               const char *src, const char *dst,
+    network_element_t src, network_element_t dst,

                                route_t route, double *lat)
 {
 
                                route_t route, double *lat)
 {
 


@@ -210,10 +210,11 @@ static void dijkstra_get_route_and_latency(AS_t asg,
   as_dijkstra_t as = (as_dijkstra_t) asg;
 
   generic_src_dst_check(asg, src, dst);
   as_dijkstra_t as = (as_dijkstra_t) asg;
 
   generic_src_dst_check(asg, src, dst);

-  int *src_id = xbt_dict_get_or_null(asg->to_index, src);
-  int *dst_id = xbt_dict_get_or_null(asg->to_index, dst);
+  int *src_id = &(src->id);
+  int *dst_id = &(dst->id);
+

   if (!src_id || !dst_id)
   if (!src_id || !dst_id)

-    THROWF(arg_error,0,"No route from '%s' to '%s'",src,dst);
+    THROWF(arg_error,0,"No route from '%s' to '%s'",src->name,dst->name);

 
   int *pred_arr = NULL;
   int src_node_id = 0;
 
   int *pred_arr = NULL;
   int src_node_id = 0;


@@ -248,7 +249,7 @@ static void dijkstra_get_route_and_latency(AS_t asg,
         xbt_graph_get_edge(as->route_graph, node_s_v, node_e_v);
 
     if (edge == NULL)
         xbt_graph_get_edge(as->route_graph, node_s_v, node_e_v);
 
     if (edge == NULL)

-      THROWF(arg_error,0,"No route from '%s' to '%s'",src,dst);
+      THROWF(arg_error,0,"No route from '%s' to '%s'",src->name,dst->name);

 
     e_route = (route_t) xbt_graph_edge_get_data(edge);
 
 
     e_route = (route_t) xbt_graph_edge_get_data(edge);
 


@@ -330,7 +331,8 @@ static void dijkstra_get_route_and_latency(AS_t asg,
   }
 
   /* compose route path with links */
   }
 
   /* compose route path with links */

-  char *gw_src = NULL, *gw_dst = NULL, *prev_gw_src, *first_gw = NULL;
+  network_element_t gw_src, gw_dst, prev_gw_src, first_gw;
+  network_element_t gw_dst_net_elm = NULL, prev_gw_src_net_elm = NULL;

 
   for (v = dst_node_id; v != src_node_id; v = pred_arr[v]) {
     xbt_node_t node_pred_v =
 
   for (v = dst_node_id; v != src_node_id; v = pred_arr[v]) {
     xbt_node_t node_pred_v =


@@ -340,7 +342,7 @@ static void dijkstra_get_route_and_latency(AS_t asg,
         xbt_graph_get_edge(as->route_graph, node_pred_v, node_v);
 
     if (edge == NULL)
         xbt_graph_get_edge(as->route_graph, node_pred_v, node_v);
 
     if (edge == NULL)

-      THROWF(arg_error,0,"No route from '%s' to '%s'",src,dst);
+      THROWF(arg_error,0,"No route from '%s' to '%s'",src->name,dst->name);

 
     prev_gw_src = gw_src;
 
 
     prev_gw_src = gw_src;
 


@@ -352,11 +354,11 @@ static void dijkstra_get_route_and_latency(AS_t asg,
       first_gw = gw_dst;
 
     if (asg->hierarchy == SURF_ROUTING_RECURSIVE && v != dst_node_id
       first_gw = gw_dst;
 
     if (asg->hierarchy == SURF_ROUTING_RECURSIVE && v != dst_node_id

-        && strcmp(gw_dst, prev_gw_src)) {
+        && strcmp(gw_dst->name, prev_gw_src->name)) {

       xbt_dynar_t e_route_as_to_as=NULL;
       xbt_dynar_t e_route_as_to_as=NULL;

-      routing_get_route_and_latency(gw_dst, prev_gw_src,&e_route_as_to_as,NULL);
+      routing_get_route_and_latency(gw_dst_net_elm, prev_gw_src_net_elm, &e_route_as_to_as, NULL);

       if (edge == NULL)
       if (edge == NULL)

-        THROWF(arg_error,0,"No route from '%s' to '%s'",src,dst);
+        THROWF(arg_error,0,"No route from '%s' to '%s'",src->name,dst->name);

       links = e_route_as_to_as;
       int pos = 0;
       xbt_dynar_foreach(links, cpt, link) {
       links = e_route_as_to_as;
       int pos = 0;
       xbt_dynar_foreach(links, cpt, link) {


@@ -377,8 +379,8 @@ static void dijkstra_get_route_and_latency(AS_t asg,
   }
 
   if (asg->hierarchy == SURF_ROUTING_RECURSIVE) {
   }
 
   if (asg->hierarchy == SURF_ROUTING_RECURSIVE) {

-    route->src_gateway = xbt_strdup(gw_src);
-    route->dst_gateway = xbt_strdup(first_gw);
+    route->src_gateway = gw_src;
+    route->dst_gateway = first_gw;

   }
 
   if (as->cached && elm == NULL) {
   }
 
   if (as->cached && elm == NULL) {


@@ -469,12 +471,15 @@ void model_dijkstra_both_parse_route (AS_t asg, const char *src,
                      const char *dst, route_t route)
 {
        as_dijkstra_t as = (as_dijkstra_t) asg;
                      const char *dst, route_t route)
 {
        as_dijkstra_t as = (as_dijkstra_t) asg;

-       int *src_id, *dst_id;
-       src_id = xbt_dict_get_or_null(asg->to_index, src);
-       dst_id = xbt_dict_get_or_null(asg->to_index, dst);
+    network_element_t src_net_elm, dst_net_elm;
+
+    src_net_elm = (network_element_t)xbt_lib_get_or_null(host_lib, src, ROUTING_HOST_LEVEL);
+    dst_net_elm = (network_element_t)xbt_lib_get_or_null(host_lib, dst, ROUTING_HOST_LEVEL);
+    if(!src_net_elm) src_net_elm = (network_element_t)xbt_lib_get_or_null(as_router_lib, src, ROUTING_ASR_LEVEL);
+    if(!dst_net_elm) dst_net_elm = (network_element_t)xbt_lib_get_or_null(as_router_lib, dst, ROUTING_ASR_LEVEL);

 
 

-       xbt_assert(src_id, "Network elements %s not found", src);
-       xbt_assert(dst_id, "Network elements %s not found", dst);
+    xbt_assert(src_net_elm, "Network elements %s not found", src);
+    xbt_assert(dst_net_elm, "Network elements %s not found", dst);

 
     /* Create the topology graph */
        if(!as->route_graph)
 
     /* Create the topology graph */
        if(!as->route_graph)


@@ -493,13 +498,13 @@ void model_dijkstra_both_parse_route (AS_t asg, const char *src,
          XBT_DEBUG("Load Route from \"%s\" to \"%s\"", src, dst);
        else{
          XBT_DEBUG("Load ASroute from \"%s(%s)\" to \"%s(%s)\"", src,
          XBT_DEBUG("Load Route from \"%s\" to \"%s\"", src, dst);
        else{
          XBT_DEBUG("Load ASroute from \"%s(%s)\" to \"%s(%s)\"", src,

-                        route->src_gateway, dst, route->dst_gateway);
-         if(routing_get_network_element_type((const char*)route->dst_gateway) == SURF_NETWORK_ELEMENT_NULL)
-                 xbt_die("The dst_gateway '%s' does not exist!",route->dst_gateway);
-         if(routing_get_network_element_type((const char*)route->src_gateway) == SURF_NETWORK_ELEMENT_NULL)
-                 xbt_die("The src_gateway '%s' does not exist!",route->src_gateway);
+                        route->src_gateway->name, dst, route->dst_gateway->name);
+         if(route->dst_gateway->rc_type == SURF_NETWORK_ELEMENT_NULL)
+                 xbt_die("The dst_gateway '%s' does not exist!",route->dst_gateway->name);
+         if(route->src_gateway->rc_type == SURF_NETWORK_ELEMENT_NULL)
+                 xbt_die("The src_gateway '%s' does not exist!",route->src_gateway->name);

        }
 
        route_t e_route = generic_new_extended_route(asg->hierarchy, route, 1);
        }
 
        route_t e_route = generic_new_extended_route(asg->hierarchy, route, 1);

-       route_new_dijkstra(as, *src_id, *dst_id, e_route);
+       route_new_dijkstra(as, src_net_elm->id, dst_net_elm->id, e_route);

 }
 }

diff --git a/src/surf/surf_routing_floyd.c b/src/surf/surf_routing_floyd.c
index b7a60a5..28f4f6c 100644 (file)
--- a/src/surf/surf_routing_floyd.c
+++ b/src/surf/surf_routing_floyd.c
@@ -25,61 +25,63 @@ typedef struct {
   route_t *link_table;
 } s_as_floyd_t, *as_floyd_t;
 
   route_t *link_table;
 } s_as_floyd_t, *as_floyd_t;
 

-static void floyd_get_route_and_latency(AS_t asg, const char *src, const char *dst,
+static void floyd_get_route_and_latency(AS_t asg, network_element_t src, network_element_t dst,

     route_t res, double *lat);
 
 /* Business methods */
 static xbt_dynar_t floyd_get_onelink_routes(AS_t asg)
 {
   xbt_dynar_t ret = xbt_dynar_new(sizeof(onelink_t), xbt_free);
     route_t res, double *lat);
 
 /* Business methods */
 static xbt_dynar_t floyd_get_onelink_routes(AS_t asg)
 {
   xbt_dynar_t ret = xbt_dynar_new(sizeof(onelink_t), xbt_free);

-
-  route_t route =   xbt_new0(s_route_t, 1);
-  route->link_list = xbt_dynar_new(global_routing->size_of_link, NULL);
-
-  xbt_dict_cursor_t c1 = NULL, c2 = NULL;
-  char *k1, *d1, *k2, *d2;
-  xbt_dict_foreach(asg->to_index, c1, k1, d1) {
-    xbt_dict_foreach(asg->to_index, c2, k2, d2) {
-      xbt_dynar_reset(route->link_list);
-      floyd_get_route_and_latency(asg, k1, k2, route, NULL);
-      if (xbt_dynar_length(route->link_list) == 1) {
-        void *link = *(void **) xbt_dynar_get_ptr(route->link_list, 0);
-        onelink_t onelink = xbt_new0(s_onelink_t, 1);
-        onelink->link_ptr = link;
-        if (asg->hierarchy == SURF_ROUTING_BASE) {
-          onelink->src = xbt_strdup(k1);
-          onelink->dst = xbt_strdup(k2);
-        } else if (asg->hierarchy == SURF_ROUTING_RECURSIVE) {
-          onelink->src = xbt_strdup(route->src_gateway);
-          onelink->dst = xbt_strdup(route->dst_gateway);
-        }
-        xbt_dynar_push(ret, &onelink);
-      }
-    }
-  }
+  THROW_UNIMPLEMENTED;
+//  route_t route =   xbt_new0(s_route_t, 1);
+//  route->link_list = xbt_dynar_new(global_routing->size_of_link, NULL);
+//
+//  xbt_dict_cursor_t c1 = NULL, c2 = NULL;
+//  char *k1, *d1, *k2, *d2;
+//  xbt_dict_foreach(asg->to_index, c1, k1, d1) {
+//    xbt_dict_foreach(asg->to_index, c2, k2, d2) {
+//      xbt_dynar_reset(route->link_list);
+//      floyd_get_route_and_latency(asg, k1, k2, route, NULL);
+//      if (xbt_dynar_length(route->link_list) == 1) {
+//        void *link = *(void **) xbt_dynar_get_ptr(route->link_list, 0);
+//        onelink_t onelink = xbt_new0(s_onelink_t, 1);
+//        onelink->link_ptr = link;
+//        if (asg->hierarchy == SURF_ROUTING_BASE) {
+//          onelink->src = xbt_strdup(k1);
+//          onelink->dst = xbt_strdup(k2);
+//        } else if (asg->hierarchy == SURF_ROUTING_RECURSIVE) {
+//          onelink->src = route->src_gateway;
+//          onelink->dst = route->dst_gateway;
+//        }
+//        xbt_dynar_push(ret, &onelink);
+//      }
+//    }
+//  }

   return ret;
 }
 
   return ret;
 }
 

-static void floyd_get_route_and_latency(AS_t asg, const char *src, const char *dst,
+static void floyd_get_route_and_latency(AS_t asg, network_element_t src, network_element_t dst,

     route_t res, double *lat)
 {
 
   /* set utils vars */
   as_floyd_t as = (as_floyd_t)asg;
     route_t res, double *lat)
 {
 
   /* set utils vars */
   as_floyd_t as = (as_floyd_t)asg;

-  size_t table_size = xbt_dict_length(asg->to_index);
+  size_t table_size = asg->nb_index;

 
   generic_src_dst_check(asg, src, dst);
 
   generic_src_dst_check(asg, src, dst);

-  int *src_id = xbt_dict_get_or_null(asg->to_index, src);
-  int *dst_id = xbt_dict_get_or_null(asg->to_index, dst);
+  int *src_id = &(src->id);
+  int *dst_id = &(dst->id);

   if (src_id == NULL || dst_id == NULL)
   if (src_id == NULL || dst_id == NULL)

-    THROWF(arg_error,0,"No route from '%s' to '%s'",src,dst);
+    THROWF(arg_error,0,"No route from '%s' to '%s'",
+        src->name,
+        dst->name);

 
   /* create a result route */
 
   int first = 1;
   int pred = *dst_id;
   int prev_pred = 0;
 
   /* create a result route */
 
   int first = 1;
   int pred = *dst_id;
   int prev_pred = 0;

-  char *gw_src = NULL, *gw_dst = NULL, *prev_gw_src, *first_gw = NULL;
+  network_element_t gw_src, gw_dst, prev_gw_src, first_gw;

   unsigned int cpt;
   void *link;
   xbt_dynar_t links;
   unsigned int cpt;
   void *link;
   xbt_dynar_t links;


@@ -90,8 +92,9 @@ static void floyd_get_route_and_latency(AS_t asg, const char *src, const char *d
     if (pred == -1)             /* if no pred in route -> no route to host */
       break;
     xbt_assert(TO_FLOYD_LINK(pred, prev_pred),
     if (pred == -1)             /* if no pred in route -> no route to host */
       break;
     xbt_assert(TO_FLOYD_LINK(pred, prev_pred),

-                "Invalid link for the route between \"%s\" or \"%s\"", src,
-                dst);
+                "Invalid link for the route between \"%s\" or \"%s\"",
+                src->name,
+                dst->name);

 
     prev_gw_src = gw_src;
 
 
     prev_gw_src = gw_src;
 


@@ -103,7 +106,7 @@ static void floyd_get_route_and_latency(AS_t asg, const char *src, const char *d
       first_gw = gw_dst;
 
     if (asg->hierarchy == SURF_ROUTING_RECURSIVE && !first
       first_gw = gw_dst;
 
     if (asg->hierarchy == SURF_ROUTING_RECURSIVE && !first

-        && strcmp(gw_dst, prev_gw_src)) {
+        && strcmp(gw_dst->name, prev_gw_src->name)) {

       xbt_dynar_t e_route_as_to_as;
       e_route_as_to_as = xbt_dynar_new(global_routing->size_of_link, NULL);
       routing_get_route_and_latency(gw_dst, prev_gw_src,&e_route_as_to_as,NULL);
       xbt_dynar_t e_route_as_to_as;
       e_route_as_to_as = xbt_dynar_new(global_routing->size_of_link, NULL);
       routing_get_route_and_latency(gw_dst, prev_gw_src,&e_route_as_to_as,NULL);


@@ -128,11 +131,13 @@ static void floyd_get_route_and_latency(AS_t asg, const char *src, const char *d
 
   } while (pred != *src_id);
   if (pred == -1)
 
   } while (pred != *src_id);
   if (pred == -1)

-    THROWF(arg_error,0,"No route from '%s' to '%s'",src,dst);
+    THROWF(arg_error,0,"No route from '%s' to '%s'",
+        src->name,
+        dst->name);

 
   if (asg->hierarchy == SURF_ROUTING_RECURSIVE) {
 
   if (asg->hierarchy == SURF_ROUTING_RECURSIVE) {

-    res->src_gateway = xbt_strdup(gw_src);
-    res->dst_gateway = xbt_strdup(first_gw);
+    res->src_gateway = gw_src;
+    res->dst_gateway = first_gw;

   }
 }
 
   }
 }
 


@@ -142,7 +147,7 @@ static void floyd_finalize(AS_t rc)
   int i, j;
   size_t table_size;
   if (as) {
   int i, j;
   size_t table_size;
   if (as) {

-    table_size = xbt_dict_length(as->generic_routing.to_index);
+    table_size = as->generic_routing.nb_index;

     /* Delete link_table */
     for (i = 0; i < table_size; i++)
       for (j = 0; j < table_size; j++)
     /* Delete link_table */
     for (i = 0; i < table_size; i++)
       for (j = 0; j < table_size; j++)


@@ -150,8 +155,6 @@ static void floyd_finalize(AS_t rc)
     xbt_free(as->link_table);
     /* Delete bypass dict */
     xbt_dict_free(&as->generic_routing.bypassRoutes);
     xbt_free(as->link_table);
     /* Delete bypass dict */
     xbt_dict_free(&as->generic_routing.bypassRoutes);

-    /* Delete index dict */
-    xbt_dict_free(&(as->generic_routing.to_index));

     /* Delete predecessor and cost table */
     xbt_free(as->predecessor_table);
     xbt_free(as->cost_table);
     /* Delete predecessor and cost table */
     xbt_free(as->predecessor_table);
     xbt_free(as->cost_table);


@@ -181,7 +184,7 @@ void model_floyd_end(AS_t current_routing)
        unsigned int i, j, a, b, c;
 
        /* set the size of table routing */
        unsigned int i, j, a, b, c;
 
        /* set the size of table routing */

-       size_t table_size = xbt_dict_length(as->generic_routing.to_index);
+       size_t table_size = as->generic_routing.nb_index;

 
        if(!as->link_table)
        {
 
        if(!as->link_table)
        {


@@ -246,14 +249,16 @@ void model_floyd_parse_route(AS_t rc, const char *src,
        as_floyd_t as = (as_floyd_t) rc;
 
        /* set the size of table routing */
        as_floyd_t as = (as_floyd_t) rc;
 
        /* set the size of table routing */

-       size_t table_size = xbt_dict_length(rc->to_index);
-       int *src_id, *dst_id;
+       size_t table_size = rc->nb_index;
+    network_element_t src_net_elm, dst_net_elm;

 
 

-       src_id = xbt_dict_get_or_null(rc->to_index, src);
-       dst_id = xbt_dict_get_or_null(rc->to_index, dst);
+    src_net_elm = (network_element_t)xbt_lib_get_or_null(host_lib, src, ROUTING_HOST_LEVEL);
+    dst_net_elm = (network_element_t)xbt_lib_get_or_null(host_lib, dst, ROUTING_HOST_LEVEL);
+    if(!src_net_elm) src_net_elm = (network_element_t)xbt_lib_get_or_null(as_router_lib, src, ROUTING_ASR_LEVEL);
+    if(!dst_net_elm) dst_net_elm = (network_element_t)xbt_lib_get_or_null(as_router_lib, dst, ROUTING_ASR_LEVEL);

 
 

-       xbt_assert(src_id, "Network elements %s not found", src);
-       xbt_assert(dst_id, "Network elements %s not found", dst);
+       xbt_assert(src_net_elm, "Network elements %s not found", src);
+       xbt_assert(dst_net_elm, "Network elements %s not found", dst);

 
        if(!as->link_table)
        {
 
        if(!as->link_table)
        {


@@ -272,13 +277,13 @@ void model_floyd_parse_route(AS_t rc, const char *src,
                }
        }
 
                }
        }
 

-       if(TO_FLOYD_LINK(*src_id, *dst_id))
+       if(TO_FLOYD_LINK(src_net_elm->id, dst_net_elm->id))

        {
                if(!route->dst_gateway && !route->src_gateway)
                        XBT_DEBUG("See Route from \"%s\" to \"%s\"", src, dst);
                else
                        XBT_DEBUG("See ASroute from \"%s(%s)\" to \"%s(%s)\"", src,
        {
                if(!route->dst_gateway && !route->src_gateway)
                        XBT_DEBUG("See Route from \"%s\" to \"%s\"", src, dst);
                else
                        XBT_DEBUG("See ASroute from \"%s(%s)\" to \"%s(%s)\"", src,

-                                route->src_gateway, dst, route->dst_gateway);
+                                route->src_gateway->name, dst, route->dst_gateway->name);

                char * link_name;
                unsigned int cpt;
                xbt_dynar_t link_route_to_test = xbt_dynar_new(global_routing->size_of_link, NULL);
                char * link_name;
                unsigned int cpt;
                xbt_dynar_t link_route_to_test = xbt_dynar_new(global_routing->size_of_link, NULL);


@@ -289,7 +294,7 @@ void model_floyd_parse_route(AS_t rc, const char *src,
                        xbt_dynar_push(link_route_to_test,&link);
                }
                xbt_assert(!xbt_dynar_compare(
                        xbt_dynar_push(link_route_to_test,&link);
                }
                xbt_assert(!xbt_dynar_compare(

-                         (void*)TO_FLOYD_LINK(*src_id, *dst_id)->link_list,
+                         (void*)TO_FLOYD_LINK(src_net_elm->id, dst_net_elm->id)->link_list,

                          (void*)link_route_to_test,
                          (int_f_cpvoid_cpvoid_t) floyd_pointer_resource_cmp),
                          "The route between \"%s\" and \"%s\" already exists", src,dst);
                          (void*)link_route_to_test,
                          (int_f_cpvoid_cpvoid_t) floyd_pointer_resource_cmp),
                          "The route between \"%s\" and \"%s\" already exists", src,dst);


@@ -300,29 +305,29 @@ void model_floyd_parse_route(AS_t rc, const char *src,
                  XBT_DEBUG("Load Route from \"%s\" to \"%s\"", src, dst);
                else{
                        XBT_DEBUG("Load ASroute from \"%s(%s)\" to \"%s(%s)\"", src,
                  XBT_DEBUG("Load Route from \"%s\" to \"%s\"", src, dst);
                else{
                        XBT_DEBUG("Load ASroute from \"%s(%s)\" to \"%s(%s)\"", src,

-                                route->src_gateway, dst, route->dst_gateway);
-                       if(routing_get_network_element_type((const char*)route->dst_gateway) == SURF_NETWORK_ELEMENT_NULL)
-                               xbt_die("The dst_gateway '%s' does not exist!",route->dst_gateway);
-                       if(routing_get_network_element_type((const char*)route->src_gateway) == SURF_NETWORK_ELEMENT_NULL)
-                               xbt_die("The src_gateway '%s' does not exist!",route->src_gateway);
+                                route->src_gateway->name, dst, route->dst_gateway->name);
+                       if(route->dst_gateway->rc_type == SURF_NETWORK_ELEMENT_NULL)
+                               xbt_die("The dst_gateway '%s' does not exist!",route->dst_gateway->name);
+                       if(route->src_gateway->rc_type == SURF_NETWORK_ELEMENT_NULL)
+                               xbt_die("The src_gateway '%s' does not exist!",route->src_gateway->name);

                }
                }

-           TO_FLOYD_LINK(*src_id, *dst_id) =
+           TO_FLOYD_LINK(src_net_elm->id, dst_net_elm->id) =

                        generic_new_extended_route(rc->hierarchy, route, 1);
                        generic_new_extended_route(rc->hierarchy, route, 1);

-           TO_FLOYD_PRED(*src_id, *dst_id) = *src_id;
-           TO_FLOYD_COST(*src_id, *dst_id) =
-                       ((TO_FLOYD_LINK(*src_id, *dst_id))->link_list)->used;   /* count of links, old model assume 1 */
+           TO_FLOYD_PRED(src_net_elm->id, dst_net_elm->id) = src_net_elm->id;
+           TO_FLOYD_COST(src_net_elm->id, dst_net_elm->id) =
+                       ((TO_FLOYD_LINK(src_net_elm->id, dst_net_elm->id))->link_list)->used;   /* count of links, old model assume 1 */

        }
 
        if( A_surfxml_route_symmetrical == A_surfxml_route_symmetrical_YES
                || A_surfxml_ASroute_symmetrical == A_surfxml_ASroute_symmetrical_YES )
        {
        }
 
        if( A_surfxml_route_symmetrical == A_surfxml_route_symmetrical_YES
                || A_surfxml_ASroute_symmetrical == A_surfxml_ASroute_symmetrical_YES )
        {

-               if(TO_FLOYD_LINK(*dst_id, *src_id))
+               if(TO_FLOYD_LINK(dst_net_elm->id, src_net_elm->id))

                {
                        if(!route->dst_gateway && !route->src_gateway)
                          XBT_DEBUG("See Route from \"%s\" to \"%s\"", dst, src);
                        else
                          XBT_DEBUG("See ASroute from \"%s(%s)\" to \"%s(%s)\"", dst,
                {
                        if(!route->dst_gateway && !route->src_gateway)
                          XBT_DEBUG("See Route from \"%s\" to \"%s\"", dst, src);
                        else
                          XBT_DEBUG("See ASroute from \"%s(%s)\" to \"%s(%s)\"", dst,

-                                        route->src_gateway, src, route->dst_gateway);
+                                        route->src_gateway->name, src, route->dst_gateway->name);

                        char * link_name;
                        unsigned int i;
                        xbt_dynar_t link_route_to_test = xbt_dynar_new(global_routing->size_of_link, NULL);
                        char * link_name;
                        unsigned int i;
                        xbt_dynar_t link_route_to_test = xbt_dynar_new(global_routing->size_of_link, NULL);


@@ -334,7 +339,7 @@ void model_floyd_parse_route(AS_t rc, const char *src,
                                xbt_dynar_push(link_route_to_test,&link);
                        }
                        xbt_assert(!xbt_dynar_compare(
                                xbt_dynar_push(link_route_to_test,&link);
                        }
                        xbt_assert(!xbt_dynar_compare(

-                                 (void*)TO_FLOYD_LINK(*dst_id, *src_id)->link_list,
+                                 (void*)TO_FLOYD_LINK(dst_net_elm->id, src_net_elm->id)->link_list,

                              (void*)link_route_to_test,
                                  (int_f_cpvoid_cpvoid_t) floyd_pointer_resource_cmp),
                                  "The route between \"%s\" and \"%s\" already exists", src,dst);
                              (void*)link_route_to_test,
                                  (int_f_cpvoid_cpvoid_t) floyd_pointer_resource_cmp),
                                  "The route between \"%s\" and \"%s\" already exists", src,dst);


@@ -343,8 +348,8 @@ void model_floyd_parse_route(AS_t rc, const char *src,
                {
                        if(route->dst_gateway && route->src_gateway)
                        {
                {
                        if(route->dst_gateway && route->src_gateway)
                        {

-                          char *gw_src = route->src_gateway;
-                          char *gw_dst = route->dst_gateway;
+                         network_element_t gw_src = route->src_gateway;
+                         network_element_t gw_dst = route->dst_gateway;

                           route->src_gateway = gw_dst;
                           route->dst_gateway = gw_src;
                        }
                           route->src_gateway = gw_dst;
                           route->dst_gateway = gw_src;
                        }


@@ -353,13 +358,13 @@ void model_floyd_parse_route(AS_t rc, const char *src,
                          XBT_DEBUG("Load Route from \"%s\" to \"%s\"", dst, src);
                        else
                          XBT_DEBUG("Load ASroute from \"%s(%s)\" to \"%s(%s)\"", dst,
                          XBT_DEBUG("Load Route from \"%s\" to \"%s\"", dst, src);
                        else
                          XBT_DEBUG("Load ASroute from \"%s(%s)\" to \"%s(%s)\"", dst,

-                                        route->src_gateway, src, route->dst_gateway);
+                                        route->src_gateway->name, src, route->dst_gateway->name);

 
 

-                   TO_FLOYD_LINK(*dst_id, *src_id) =
+                   TO_FLOYD_LINK(dst_net_elm->id, src_net_elm->id) =

                                generic_new_extended_route(rc->hierarchy, route, 0);
                                generic_new_extended_route(rc->hierarchy, route, 0);

-                   TO_FLOYD_PRED(*dst_id, *src_id) = *dst_id;
-                   TO_FLOYD_COST(*dst_id, *src_id) =
-                               ((TO_FLOYD_LINK(*dst_id, *src_id))->link_list)->used;   /* count of links, old model assume 1 */
+                   TO_FLOYD_PRED(dst_net_elm->id, src_net_elm->id) = dst_net_elm->id;
+                   TO_FLOYD_COST(dst_net_elm->id, src_net_elm->id) =
+                               ((TO_FLOYD_LINK(dst_net_elm->id, src_net_elm->id))->link_list)->used;   /* count of links, old model assume 1 */

                }
        }
 }
                }
        }
 }

diff --git a/src/surf/surf_routing_full.c b/src/surf/surf_routing_full.c
index c752582..2f7af5e 100644 (file)
--- a/src/surf/surf_routing_full.c
+++ b/src/surf/surf_routing_full.c
@@ -25,64 +25,65 @@ typedef struct s_routing_component_full {
 static xbt_dynar_t full_get_onelink_routes(AS_t rc)
 {
   xbt_dynar_t ret = xbt_dynar_new(sizeof(onelink_t), xbt_free);
 static xbt_dynar_t full_get_onelink_routes(AS_t rc)
 {
   xbt_dynar_t ret = xbt_dynar_new(sizeof(onelink_t), xbt_free);

-
-  routing_component_full_t routing = (routing_component_full_t) rc;
-  size_t table_size = xbt_dict_length(routing->generic_routing.to_index);
-  xbt_dict_cursor_t c1 = NULL, c2 = NULL;
-  char *k1, *d1, *k2, *d2;
-  xbt_dict_foreach(routing->generic_routing.to_index, c1, k1, d1) {
-    xbt_dict_foreach(routing->generic_routing.to_index, c2, k2, d2) {
-      int *src_id = xbt_dict_get_or_null(routing->generic_routing.to_index, k1);
-      int *dst_id = xbt_dict_get_or_null(routing->generic_routing.to_index, k2);
-      xbt_assert(src_id && dst_id,
-                 "Ask for route \"from\"(%s)  or \"to\"(%s) "
-                 "no found in the local table", k1, k2);
-      route_t route = TO_ROUTE_FULL(*src_id, *dst_id);
-      if (route) {
-        if (xbt_dynar_length(route->link_list) == 1) {
-          void *link = *(void **) xbt_dynar_get_ptr(route->link_list, 0);
-          onelink_t onelink = xbt_new0(s_onelink_t, 1);
-          onelink->link_ptr = link;
-          if (routing->generic_routing.hierarchy == SURF_ROUTING_BASE) {
-            onelink->src = xbt_strdup(k1);
-            onelink->dst = xbt_strdup(k2);
-          } else if (routing->generic_routing.hierarchy ==
-                     SURF_ROUTING_RECURSIVE) {
-            onelink->src = xbt_strdup(route->src_gateway);
-            onelink->dst = xbt_strdup(route->dst_gateway);
-          }
-          xbt_dynar_push(ret, &onelink);
-        }
-      }
-    }
-  }
+THROW_UNIMPLEMENTED;
+//  routing_component_full_t routing = (routing_component_full_t) rc;
+//  size_t table_size = routing->generic_routing.nb_index;
+//  xbt_dict_cursor_t c1 = NULL, c2 = NULL;
+//  char *k1, *d1, *k2, *d2;
+//  xbt_dict_foreach(routing->generic_routing.to_index, c1, k1, d1) {
+//    xbt_dict_foreach(routing->generic_routing.to_index, c2, k2, d2) {
+//      int *src_id = xbt_dict_get_or_null(routing->generic_routing.to_index, k1);
+//      int *dst_id = xbt_dict_get_or_null(routing->generic_routing.to_index, k2);
+//      xbt_assert(src_id && dst_id,
+//                 "Ask for route \"from\"(%s)  or \"to\"(%s) "
+//                 "no found in the local table", k1, k2);
+//      route_t route = TO_ROUTE_FULL(*src_id, *dst_id);
+//      if (route) {
+//        if (xbt_dynar_length(route->link_list) == 1) {
+//          void *link = *(void **) xbt_dynar_get_ptr(route->link_list, 0);
+//          onelink_t onelink = xbt_new0(s_onelink_t, 1);
+//          onelink->link_ptr = link;
+//          if (routing->generic_routing.hierarchy == SURF_ROUTING_BASE) {
+//            onelink->src->routing_obj->name = xbt_strdup(k1);
+//            onelink->src->routing_obj->id = atoi(k1);
+//            onelink->dst->routing_obj->name = xbt_strdup(k2);
+//            onelink->dst->routing_obj->id = atoi(k2);
+//          } else if (routing->generic_routing.hierarchy ==
+//                     SURF_ROUTING_RECURSIVE) {
+//            onelink->src = route->src_gateway;
+//            onelink->dst = route->dst_gateway;
+//          }
+//          xbt_dynar_push(ret, &onelink);
+//        }
+//      }
+//    }
+//  }

   return ret;
 }
 
 static void full_get_route_and_latency(AS_t rc,
   return ret;
 }
 
 static void full_get_route_and_latency(AS_t rc,

-                                       const char *src, const char *dst,
+    network_element_t src, network_element_t dst,

                                        route_t res, double *lat)
 {
                                        route_t res, double *lat)
 {

+  XBT_DEBUG("full_get_route_and_latency from %s[%d] to %s[%d]",
+      src->name,
+      src->id,
+      dst->name,
+      dst->id  );

 
   /* set utils vars */
   routing_component_full_t routing = (routing_component_full_t) rc;
 
   /* set utils vars */
   routing_component_full_t routing = (routing_component_full_t) rc;

-  size_t table_size = xbt_dict_length(routing->generic_routing.to_index);
-
-  int *src_id = xbt_dict_get_or_null(routing->generic_routing.to_index, src);
-  int *dst_id = xbt_dict_get_or_null(routing->generic_routing.to_index, dst);
-
-  if (!src_id || !dst_id)
-    THROWF(arg_error, 0, "No route from '%s' to '%s'", src, dst);
+  size_t table_size = routing->generic_routing.nb_index;

 
   route_t e_route = NULL;
   void *link;
   unsigned int cpt = 0;
 
 
   route_t e_route = NULL;
   void *link;
   unsigned int cpt = 0;
 

-  e_route = TO_ROUTE_FULL(*src_id, *dst_id);
+  e_route = TO_ROUTE_FULL(src->id, dst->id);

 
   if (e_route) {
 
   if (e_route) {

-    res->src_gateway = xbt_strdup(e_route->src_gateway);
-    res->dst_gateway = xbt_strdup(e_route->dst_gateway);
+    res->src_gateway = e_route->src_gateway;
+    res->dst_gateway = e_route->dst_gateway;

     xbt_dynar_foreach(e_route->link_list, cpt, link) {
       xbt_dynar_push(res->link_list, &link);
       if (lat)
     xbt_dynar_foreach(e_route->link_list, cpt, link) {
       xbt_dynar_push(res->link_list, &link);
       if (lat)


@@ -94,7 +95,7 @@ static void full_get_route_and_latency(AS_t rc,
 static void full_finalize(AS_t rc)
 {
   routing_component_full_t routing = (routing_component_full_t) rc;
 static void full_finalize(AS_t rc)
 {
   routing_component_full_t routing = (routing_component_full_t) rc;

-  size_t table_size = xbt_dict_length(routing->generic_routing.to_index);
+  size_t table_size = routing->generic_routing.nb_index;

   int i, j;
   if (routing) {
     /* Delete routing table */
   int i, j;
   if (routing) {
     /* Delete routing table */


@@ -131,7 +132,7 @@ void model_full_end(AS_t current_routing)
   /* set utils vars */
   routing_component_full_t routing =
       ((routing_component_full_t) current_routing);
   /* set utils vars */
   routing_component_full_t routing =
       ((routing_component_full_t) current_routing);

-  size_t table_size = xbt_dict_length(routing->generic_routing.to_index);
+  size_t table_size = routing->generic_routing.nb_index;

 
   /* Create table if necessary */
   if (!routing->routing_table)
 
   /* Create table if necessary */
   if (!routing->routing_table)


@@ -161,14 +162,18 @@ static int full_pointer_resource_cmp(const void *a, const void *b)
 void model_full_set_route(AS_t rc, const char *src,
                           const char *dst, route_t route)
 {
 void model_full_set_route(AS_t rc, const char *src,
                           const char *dst, route_t route)
 {

-  int *src_id, *dst_id;
-  src_id = xbt_dict_get_or_null(rc->to_index, src);
-  dst_id = xbt_dict_get_or_null(rc->to_index, dst);
-  routing_component_full_t routing = (routing_component_full_t) rc;
-  size_t table_size = xbt_dict_length(routing->generic_routing.to_index);
+  network_element_t src_net_elm, dst_net_elm;
+
+  src_net_elm = (network_element_t)xbt_lib_get_or_null(host_lib, src, ROUTING_HOST_LEVEL);
+  dst_net_elm = (network_element_t)xbt_lib_get_or_null(host_lib, dst, ROUTING_HOST_LEVEL);
+  if(!src_net_elm) src_net_elm = (network_element_t)xbt_lib_get_or_null(as_router_lib, src, ROUTING_ASR_LEVEL);
+  if(!dst_net_elm) dst_net_elm = (network_element_t)xbt_lib_get_or_null(as_router_lib, dst, ROUTING_ASR_LEVEL);

 
 

-  xbt_assert(src_id, "Network elements %s not found", src);
-  xbt_assert(dst_id, "Network elements %s not found", dst);
+  xbt_assert(src_net_elm, "Network elements %s not found", src);
+  xbt_assert(dst_net_elm, "Network elements %s not found", dst);
+
+  routing_component_full_t routing = (routing_component_full_t) rc;
+  size_t table_size = routing->generic_routing.nb_index;

 
   xbt_assert(!xbt_dynar_is_empty(route->link_list),
              "Invalid count of links, must be greater than zero (%s,%s)",
 
   xbt_assert(!xbt_dynar_is_empty(route->link_list),
              "Invalid count of links, must be greater than zero (%s,%s)",


@@ -177,7 +182,7 @@ void model_full_set_route(AS_t rc, const char *src,
   if (!routing->routing_table)
     routing->routing_table = xbt_new0(route_t, table_size * table_size);
 
   if (!routing->routing_table)
     routing->routing_table = xbt_new0(route_t, table_size * table_size);
 

-  if (TO_ROUTE_FULL(*src_id, *dst_id)) {
+  if (TO_ROUTE_FULL(src_net_elm->id, dst_net_elm->id)) {

     char *link_name;
     unsigned int i;
     xbt_dynar_t link_route_to_test =
     char *link_name;
     unsigned int i;
     xbt_dynar_t link_route_to_test =


@@ -187,7 +192,7 @@ void model_full_set_route(AS_t rc, const char *src,
       xbt_assert(link, "Link : '%s' doesn't exists.", link_name);
       xbt_dynar_push(link_route_to_test, &link);
     }
       xbt_assert(link, "Link : '%s' doesn't exists.", link_name);
       xbt_dynar_push(link_route_to_test, &link);
     }

-    if (xbt_dynar_compare(TO_ROUTE_FULL(*src_id, *dst_id)->link_list,
+    if (xbt_dynar_compare(TO_ROUTE_FULL(src_net_elm->id, dst_net_elm->id)->link_list,

                           link_route_to_test, full_pointer_resource_cmp)) {
       surf_parse_error("A route between \"%s\" and \"%s\" already exists "
                        "with a different content. "
                           link_route_to_test, full_pointer_resource_cmp)) {
       surf_parse_error("A route between \"%s\" and \"%s\" already exists "
                        "with a different content. "


@@ -230,28 +235,26 @@ void model_full_set_route(AS_t rc, const char *src,
 //                         route->dst_gateway, subas->name);
 
       XBT_DEBUG("Load ASroute from \"%s(%s)\" to \"%s(%s)\"",
 //                         route->dst_gateway, subas->name);
 
       XBT_DEBUG("Load ASroute from \"%s(%s)\" to \"%s(%s)\"",

-                src, route->src_gateway, dst, route->dst_gateway);
-      if (routing_get_network_element_type(route->dst_gateway) ==
-          SURF_NETWORK_ELEMENT_NULL)
-        xbt_die("The dst_gateway '%s' does not exist!", route->dst_gateway);
-      if (routing_get_network_element_type(route->src_gateway) ==
-          SURF_NETWORK_ELEMENT_NULL)
-        xbt_die("The src_gateway '%s' does not exist!", route->src_gateway);
+                src, route->src_gateway->name, dst, route->dst_gateway->name);
+      if (route->dst_gateway->rc_type == SURF_NETWORK_ELEMENT_NULL)
+        xbt_die("The dst_gateway '%s' does not exist!", route->dst_gateway->name);
+      if (route->src_gateway->rc_type == SURF_NETWORK_ELEMENT_NULL)
+        xbt_die("The src_gateway '%s' does not exist!", route->src_gateway->name);

     }
     }

-    TO_ROUTE_FULL(*src_id, *dst_id) =
+    TO_ROUTE_FULL(src_net_elm->id, dst_net_elm->id) =

         generic_new_extended_route(rc->hierarchy, route, 1);
         generic_new_extended_route(rc->hierarchy, route, 1);

-    xbt_dynar_shrink(TO_ROUTE_FULL(*src_id, *dst_id)->link_list, 0);
+    xbt_dynar_shrink(TO_ROUTE_FULL(src_net_elm->id, dst_net_elm->id)->link_list, 0);

   }
 
   if (A_surfxml_route_symmetrical == A_surfxml_route_symmetrical_YES
       || A_surfxml_ASroute_symmetrical == A_surfxml_ASroute_symmetrical_YES) {
     if (route->dst_gateway && route->src_gateway) {
   }
 
   if (A_surfxml_route_symmetrical == A_surfxml_route_symmetrical_YES
       || A_surfxml_ASroute_symmetrical == A_surfxml_ASroute_symmetrical_YES) {
     if (route->dst_gateway && route->src_gateway) {

-      char *gw_tmp;
+      network_element_t gw_tmp;

       gw_tmp = route->src_gateway;
       route->src_gateway = route->dst_gateway;
       route->dst_gateway = gw_tmp;
     }
       gw_tmp = route->src_gateway;
       route->src_gateway = route->dst_gateway;
       route->dst_gateway = gw_tmp;
     }

-    if (TO_ROUTE_FULL(*dst_id, *src_id)) {
+    if (TO_ROUTE_FULL(dst_net_elm->id, src_net_elm->id)) {

       char *link_name;
       unsigned int i;
       xbt_dynar_t link_route_to_test =
       char *link_name;
       unsigned int i;
       xbt_dynar_t link_route_to_test =


@@ -262,7 +265,7 @@ void model_full_set_route(AS_t rc, const char *src,
         xbt_assert(link, "Link : '%s' doesn't exists.", link_name);
         xbt_dynar_push(link_route_to_test, &link);
       }
         xbt_assert(link, "Link : '%s' doesn't exists.", link_name);
         xbt_dynar_push(link_route_to_test, &link);
       }

-      xbt_assert(!xbt_dynar_compare(TO_ROUTE_FULL(*dst_id, *src_id)->link_list,
+      xbt_assert(!xbt_dynar_compare(TO_ROUTE_FULL(dst_net_elm->id, src_net_elm->id)->link_list,

                                     link_route_to_test,
                                     full_pointer_resource_cmp),
                  "The route between \"%s\" and \"%s\" already exists", src,
                                     link_route_to_test,
                                     full_pointer_resource_cmp),
                  "The route between \"%s\" and \"%s\" already exists", src,


@@ -272,10 +275,10 @@ void model_full_set_route(AS_t rc, const char *src,
         XBT_DEBUG("Load Route from \"%s\" to \"%s\"", dst, src);
       else
         XBT_DEBUG("Load ASroute from \"%s(%s)\" to \"%s(%s)\"",
         XBT_DEBUG("Load Route from \"%s\" to \"%s\"", dst, src);
       else
         XBT_DEBUG("Load ASroute from \"%s(%s)\" to \"%s(%s)\"",

-                  dst, route->src_gateway, src, route->dst_gateway);
-      TO_ROUTE_FULL(*dst_id, *src_id) =
+                  dst, route->src_gateway->name, src, route->dst_gateway->name);
+      TO_ROUTE_FULL(dst_net_elm->id, src_net_elm->id) =

           generic_new_extended_route(rc->hierarchy, route, 0);
           generic_new_extended_route(rc->hierarchy, route, 0);

-      xbt_dynar_shrink(TO_ROUTE_FULL(*dst_id, *src_id)->link_list, 0);
+      xbt_dynar_shrink(TO_ROUTE_FULL(dst_net_elm->id, src_net_elm->id)->link_list, 0);

     }
   }
 }
     }
   }
 }

diff --git a/src/surf/surf_routing_generic.c b/src/surf/surf_routing_generic.c
index ce41bac..c3d6d9a 100644 (file)
--- a/src/surf/surf_routing_generic.c
+++ b/src/surf/surf_routing_generic.c
@@ -30,35 +30,30 @@ AS_t model_generic_create_sized(size_t childsize) {
       generic_get_bypassroute;
   new_component->finalize = model_generic_finalize;
 
       generic_get_bypassroute;
   new_component->finalize = model_generic_finalize;
 

-  new_component->to_index = xbt_dict_new_homogeneous(xbt_free);
+  new_component->nb_index = 0;

   new_component->bypassRoutes = xbt_dict_new_homogeneous((void (*)(void *)) generic_free_route);
 
   return new_component;
 }
 void model_generic_finalize(AS_t as) {
   new_component->bypassRoutes = xbt_dict_new_homogeneous((void (*)(void *)) generic_free_route);
 
   return new_component;
 }
 void model_generic_finalize(AS_t as) {

-  xbt_dict_free(&as->to_index);

   xbt_dict_free(&as->bypassRoutes);
   model_none_finalize(as);
 }
 
   xbt_dict_free(&as->bypassRoutes);
   model_none_finalize(as);
 }
 

-void generic_parse_PU(AS_t as, const char *name)
+int generic_parse_PU(AS_t as, const char *name)

 {
   XBT_DEBUG("Load process unit \"%s\"", name);
 {
   XBT_DEBUG("Load process unit \"%s\"", name);

-  int *id = xbt_new0(int, 1);
-  xbt_dict_t _to_index;
-  _to_index = as->to_index;
-  *id = xbt_dict_length(_to_index);
-  xbt_dict_set(_to_index, name, id, NULL);
+  int id = as->nb_index;
+  (as->nb_index)++;
+  return id;

 }
 
 }
 

-void generic_parse_AS(AS_t as, const char *name)
+int generic_parse_AS(AS_t as, const char *name)

 {
   XBT_DEBUG("Load Autonomous system \"%s\"", name);
 {
   XBT_DEBUG("Load Autonomous system \"%s\"", name);

-  int *id = xbt_new0(int, 1);
-  xbt_dict_t _to_index;
-  _to_index = as->to_index;
-  *id = xbt_dict_length(_to_index);
-  xbt_dict_set(_to_index, name, id, NULL);
+  int id = as->nb_index;
+  as->nb_index++;
+  return id;

 }
 
 void generic_parse_bypassroute(AS_t rc,
 }
 
 void generic_parse_bypassroute(AS_t rc,


@@ -75,7 +70,7 @@ void generic_parse_bypassroute(AS_t rc,
              src, dst);
   xbt_assert(!xbt_dict_get_or_null(dict_bypassRoutes, route_name),
              "The bypass route between \"%s\"(\"%s\") and \"%s\"(\"%s\") already exists",
              src, dst);
   xbt_assert(!xbt_dict_get_or_null(dict_bypassRoutes, route_name),
              "The bypass route between \"%s\"(\"%s\") and \"%s\"(\"%s\") already exists",

-             src, e_route->src_gateway, dst, e_route->dst_gateway);
+             src, e_route->src_gateway->name, dst, e_route->dst_gateway->name);

 
   route_t new_e_route =
       generic_new_extended_route(SURF_ROUTING_RECURSIVE, e_route, 0);
 
   route_t new_e_route =
       generic_new_extended_route(SURF_ROUTING_RECURSIVE, e_route, 0);


@@ -95,7 +90,7 @@ xbt_dynar_t generic_get_onelink_routes(AS_t rc) { // FIXME: kill that stub
   return NULL;
 }
 
   return NULL;
 }
 

-route_t generic_get_bypassroute(AS_t rc, const char *src, const char *dst)
+route_t generic_get_bypassroute(AS_t rc, network_element_t src, network_element_t dst)

 {
   // If never set a bypass route return NULL without any further computations
   if(no_bypassroute_declared)
 {
   // If never set a bypass route return NULL without any further computations
   if(no_bypassroute_declared)


@@ -110,20 +105,15 @@ route_t generic_get_bypassroute(AS_t rc, const char *src, const char *dst)
   AS_t *current_src = NULL;
   AS_t *current_dst = NULL;
 
   AS_t *current_src = NULL;
   AS_t *current_dst = NULL;
 

-  /* (1) find the as where the src and dst are located */
-  void *src_data = xbt_lib_get_or_null(host_lib, src, ROUTING_HOST_LEVEL);
-  void *dst_data = xbt_lib_get_or_null(host_lib, dst, ROUTING_HOST_LEVEL);
-  if (!src_data)
-    src_data = xbt_lib_get_or_null(as_router_lib, src, ROUTING_ASR_LEVEL);
-  if (!dst_data)
-    dst_data = xbt_lib_get_or_null(as_router_lib, dst, ROUTING_ASR_LEVEL);
+  char* src_name = src->name;
+  char* dst_name = dst->name;

 
 

-  if (src_data == NULL || dst_data == NULL)
+  if (src == NULL || dst == NULL)

     xbt_die("Ask for route \"from\"(%s) or \"to\"(%s) no found at AS \"%s\"",
     xbt_die("Ask for route \"from\"(%s) or \"to\"(%s) no found at AS \"%s\"",

-            src, dst, rc->name);
+            src_name, dst_name, rc->name);

 
 

-  src_as = ((network_element_info_t) src_data)->rc_component;
-  dst_as = ((network_element_info_t) dst_data)->rc_component;
+  src_as = src->rc_component;
+  dst_as = dst->rc_component;

 
   /* (2) find the path to the root routing component */
   path_src = xbt_dynar_new(sizeof(AS_t), NULL);
 
   /* (2) find the path to the root routing component */
   path_src = xbt_dynar_new(sizeof(AS_t), NULL);


@@ -212,8 +202,8 @@ route_t generic_get_bypassroute(AS_t rc, const char *src, const char *dst)
     void *link;
     unsigned int cpt = 0;
     new_e_route = xbt_new0(s_route_t, 1);
     void *link;
     unsigned int cpt = 0;
     new_e_route = xbt_new0(s_route_t, 1);

-    new_e_route->src_gateway = xbt_strdup(e_route_bypass->src_gateway);
-    new_e_route->dst_gateway = xbt_strdup(e_route_bypass->dst_gateway);
+    new_e_route->src_gateway = e_route_bypass->src_gateway;
+    new_e_route->dst_gateway = e_route_bypass->dst_gateway;

     new_e_route->link_list =
         xbt_dynar_new(global_routing->size_of_link, NULL);
     xbt_dynar_foreach(e_route_bypass->link_list, cpt, link) {
     new_e_route->link_list =
         xbt_dynar_new(global_routing->size_of_link, NULL);
     xbt_dynar_foreach(e_route_bypass->link_list, cpt, link) {


@@ -293,8 +283,8 @@ generic_new_extended_route(e_surf_routing_hierarchy_t hierarchy,
     links = e_route->link_list;
 
     /* remeber not erase the gateway names */
     links = e_route->link_list;
 
     /* remeber not erase the gateway names */

-    new_e_route->src_gateway = strdup(e_route->src_gateway);
-    new_e_route->dst_gateway = strdup(e_route->dst_gateway);
+    new_e_route->src_gateway = e_route->src_gateway;
+    new_e_route->dst_gateway = e_route->dst_gateway;

   }
 
   links_id = new_e_route->link_list;
   }
 
   links_id = new_e_route->link_list;


@@ -318,8 +308,6 @@ void generic_free_route(route_t route)
 {
   if (route) {
     xbt_dynar_free(&route->link_list);
 {
   if (route) {
     xbt_dynar_free(&route->link_list);

-    xbt_free(route->src_gateway);
-    xbt_free(route->dst_gateway);

     xbt_free(route);
   }
 }
     xbt_free(route);
   }
 }


@@ -350,7 +338,7 @@ generic_autonomous_system_exist(AS_t rc, char *element)
   AS_t element_as, result, elem;
   xbt_dict_cursor_t cursor = NULL;
   char *key;
   AS_t element_as, result, elem;
   xbt_dict_cursor_t cursor = NULL;
   char *key;

-  element_as = ((network_element_info_t)
+  element_as = ((network_element_t)

                 xbt_lib_get_or_null(as_router_lib, element,
                                     ROUTING_ASR_LEVEL))->rc_component;
   result = ((AS_t) - 1);
                 xbt_lib_get_or_null(as_router_lib, element,
                                     ROUTING_ASR_LEVEL))->rc_component;
   result = ((AS_t) - 1);


@@ -374,7 +362,7 @@ AS_t
 generic_processing_units_exist(AS_t rc, char *element)
 {
   AS_t element_as;
 generic_processing_units_exist(AS_t rc, char *element)
 {
   AS_t element_as;

-  element_as = ((network_element_info_t)
+  element_as = ((network_element_t)

                 xbt_lib_get_or_null(host_lib,
                                     element, ROUTING_HOST_LEVEL))->rc_component;
   if (element_as == rc)
                 xbt_lib_get_or_null(host_lib,
                                     element, ROUTING_HOST_LEVEL))->rc_component;
   if (element_as == rc)


@@ -382,31 +370,35 @@ generic_processing_units_exist(AS_t rc, char *element)
   return generic_as_exist(rc, element_as);
 }
 
   return generic_as_exist(rc, element_as);
 }
 

-void generic_src_dst_check(AS_t rc, const char *src,
-                           const char *dst)
+void generic_src_dst_check(AS_t rc, network_element_t src,
+    network_element_t dst)

 {
 
 {
 

-  void *src_data = xbt_lib_get_or_null(host_lib, src, ROUTING_HOST_LEVEL);
-  void *dst_data = xbt_lib_get_or_null(host_lib, dst, ROUTING_HOST_LEVEL);
-  if (!src_data)
-    src_data = xbt_lib_get_or_null(as_router_lib, src, ROUTING_ASR_LEVEL);
-  if (!dst_data)
-    dst_data = xbt_lib_get_or_null(as_router_lib, dst, ROUTING_ASR_LEVEL);
+  network_element_t src_data = src;
+  network_element_t dst_data = dst;

 
   if (src_data == NULL || dst_data == NULL)
     xbt_die("Ask for route \"from\"(%s) or \"to\"(%s) no found at AS \"%s\"",
 
   if (src_data == NULL || dst_data == NULL)
     xbt_die("Ask for route \"from\"(%s) or \"to\"(%s) no found at AS \"%s\"",

-            src, dst, rc->name);
+        src->name,
+        dst->name,
+        rc->name);

 
   AS_t src_as =
 
   AS_t src_as =

-      ((network_element_info_t) src_data)->rc_component;
+      (src_data)->rc_component;

   AS_t dst_as =
   AS_t dst_as =

-      ((network_element_info_t) dst_data)->rc_component;
+      (dst_data)->rc_component;

 
   if (src_as != dst_as)
     xbt_die("The src(%s in %s) and dst(%s in %s) are in differents AS",
 
   if (src_as != dst_as)
     xbt_die("The src(%s in %s) and dst(%s in %s) are in differents AS",

-            src, src_as->name, dst, dst_as->name);
+        src->name, src_as->name,
+        dst->name, dst_as->name);
+

   if (rc != dst_as)
     xbt_die
         ("The routing component of src'%s' and dst'%s' is not the same as the network elements belong (%s?=%s?=%s)",
   if (rc != dst_as)
     xbt_die
         ("The routing component of src'%s' and dst'%s' is not the same as the network elements belong (%s?=%s?=%s)",

-         src, dst, src_as->name, dst_as->name, rc->name);
+            src->name,
+            dst->name,
+            src_as->name,
+            dst_as->name,
+            rc->name);

 }
 }

diff --git a/src/surf/surf_routing_none.c b/src/surf/surf_routing_none.c
index f605009..75d295b 100644 (file)
--- a/src/surf/surf_routing_none.c
+++ b/src/surf/surf_routing_none.c
@@ -12,23 +12,25 @@ static xbt_dynar_t none_get_onelink_routes(AS_t rc) {
   return NULL;
 }
 
   return NULL;
 }
 

-static void none_get_route_and_latency(AS_t rc, const char *src, const char *dst,
+static void none_get_route_and_latency(AS_t rc, network_element_t src, network_element_t dst,

                                        route_t res,double *lat)
 {
 }
 
 static route_t none_get_bypass_route(AS_t rc,
                                        route_t res,double *lat)
 {
 }
 
 static route_t none_get_bypass_route(AS_t rc,

-                                              const char *src,
-                                              const char *dst) {
+    network_element_t src,
+    network_element_t dst) {

   return NULL;
 }
 
   return NULL;
 }
 

-static void none_parse_PU(AS_t rc, const char *name) {
+static int none_parse_PU(AS_t rc, const char *name) {

   /* don't care about PUs */
   /* don't care about PUs */

+  return -1;

 }
 
 }
 

-static void none_parse_AS(AS_t rc, const char *name) {
+static int none_parse_AS(AS_t rc, const char *name) {

   /* even don't care about sub-ASes -- I'm as nihilist as an old punk*/
   /* even don't care about sub-ASes -- I'm as nihilist as an old punk*/

+  return -1;

 }
 
 /* Creation routing model functions */
 }
 
 /* Creation routing model functions */

diff --git a/src/surf/surf_routing_private.h b/src/surf/surf_routing_private.h
index 6f2fd75..fe451e3 100644 (file)
--- a/src/surf/surf_routing_private.h
+++ b/src/surf/surf_routing_private.h
@@ -29,8 +29,8 @@ void model_none_finalize(AS_t as);
 AS_t model_generic_create_sized(size_t childsize);
 void model_generic_finalize(AS_t as);
 
 AS_t model_generic_create_sized(size_t childsize);
 void model_generic_finalize(AS_t as);
 

-void generic_parse_PU(AS_t rc, const char *name);
-void generic_parse_AS(AS_t rc, const char *name);
+int generic_parse_PU(AS_t rc, const char *name);
+int generic_parse_AS(AS_t rc, const char *name);

 void generic_parse_bypassroute(AS_t rc, const char *src, const char *dst,
                                route_t e_route);
 
 void generic_parse_bypassroute(AS_t rc, const char *src, const char *dst,
                                route_t e_route);
 


@@ -39,8 +39,8 @@ void generic_parse_bypassroute(AS_t rc, const char *src, const char *dst,
 
 xbt_dynar_t generic_get_onelink_routes(AS_t rc);
 route_t generic_get_bypassroute(AS_t rc,
 
 xbt_dynar_t generic_get_onelink_routes(AS_t rc);
 route_t generic_get_bypassroute(AS_t rc,

-                                                const char *src,
-                                                const char *dst);
+    network_element_t src,
+    network_element_t dst);

 
 /* ************************************************************************** */
 /* ****************** GENERIC AUX FUNCTIONS (declarations) ****************** */
 
 /* ************************************************************************** */
 /* ****************** GENERIC AUX FUNCTIONS (declarations) ****************** */


@@ -55,8 +55,8 @@ AS_t
 generic_autonomous_system_exist(AS_t rc, char *element);
 AS_t
 generic_processing_units_exist(AS_t rc, char *element);
 generic_autonomous_system_exist(AS_t rc, char *element);
 AS_t
 generic_processing_units_exist(AS_t rc, char *element);

-void generic_src_dst_check(AS_t rc, const char *src,
-                                  const char *dst);
+void generic_src_dst_check(AS_t rc, network_element_t src,
+    network_element_t dst);

 
 
 /* ************************************************************************** */
 
 
 /* ************************************************************************** */

diff --git a/src/surf/surf_routing_rulebased.c b/src/surf/surf_routing_rulebased.c
index b4f3765..5481859 100644 (file)
--- a/src/surf/surf_routing_rulebased.c
+++ b/src/surf/surf_routing_rulebased.c
@@ -15,8 +15,8 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_route_rulebased, surf, "Routing part of sur
 
 typedef struct {
   s_as_t generic_routing;
 
 typedef struct {
   s_as_t generic_routing;

-  xbt_dict_t dict_processing_units;
-  xbt_dict_t dict_autonomous_systems;
+  int nb_processing_units;
+  int nb_autonomous_systems;

   xbt_dynar_t list_route;
   xbt_dynar_t list_ASroute;
 } s_AS_rulebased_t, *AS_rulebased_t;
   xbt_dynar_t list_route;
   xbt_dynar_t list_ASroute;
 } s_AS_rulebased_t, *AS_rulebased_t;


@@ -64,16 +64,18 @@ static void rule_route_extended_free(void *e)
 
 /* Parse routing model functions */
 
 
 /* Parse routing model functions */
 

-static void model_rulebased_parse_PU(AS_t rc, const char *name)
+static int model_rulebased_parse_PU(AS_t rc, const char *name)

 {
   AS_rulebased_t routing = (AS_rulebased_t) rc;
 {
   AS_rulebased_t routing = (AS_rulebased_t) rc;

-  xbt_dict_set(routing->dict_processing_units, name, (void *) (-1), NULL);
+  routing->nb_processing_units++;
+  return -1;

 }
 
 }
 

-static void model_rulebased_parse_AS(AS_t rc, const char *name)
+static int model_rulebased_parse_AS(AS_t rc, const char *name)

 {
   AS_rulebased_t routing = (AS_rulebased_t) rc;
 {
   AS_rulebased_t routing = (AS_rulebased_t) rc;

-  xbt_dict_set(routing->dict_autonomous_systems, name, (void *) (-1), NULL);
+  routing->nb_autonomous_systems++;
+  return -1;

 }
 
 static void model_rulebased_parse_route(AS_t rc,
 }
 
 static void model_rulebased_parse_route(AS_t rc,


@@ -131,8 +133,8 @@ static void model_rulebased_parse_ASroute(AS_t rc,
               erroffset, dst, error);
   ruleroute_e->generic_rule_route.re_str_link =
       route->link_list;
               erroffset, dst, error);
   ruleroute_e->generic_rule_route.re_str_link =
       route->link_list;

-  ruleroute_e->re_src_gateway = route->src_gateway;
-  ruleroute_e->re_dst_gateway = route->dst_gateway;
+  ruleroute_e->re_src_gateway = xbt_strdup((char *)route->src_gateway); // DIRTY HACK possible only
+  ruleroute_e->re_dst_gateway = xbt_strdup((char *)route->dst_gateway); // because of what is in routing_parse_E_ASroute

   xbt_dynar_push(routing->list_ASroute, &ruleroute_e);
 
   /* make sure that they don't get freed */
   xbt_dynar_push(routing->list_ASroute, &ruleroute_e);
 
   /* make sure that they don't get freed */


@@ -207,65 +209,66 @@ static char *remplace(char *value, const char **src_list, int src_size,
 }
 
 static void rulebased_get_route_and_latency(AS_t rc,
 }
 
 static void rulebased_get_route_and_latency(AS_t rc,

-                                const char *src, const char *dst,
+    network_element_t src, network_element_t dst,

                                 route_t res,double*lat);
 static xbt_dynar_t rulebased_get_onelink_routes(AS_t rc)
 {
   xbt_dynar_t ret = xbt_dynar_new (sizeof(onelink_t), xbt_free);
                                 route_t res,double*lat);
 static xbt_dynar_t rulebased_get_onelink_routes(AS_t rc)
 {
   xbt_dynar_t ret = xbt_dynar_new (sizeof(onelink_t), xbt_free);

-
-  //We have already bypass cluster routes with network NS3
-  if(!strcmp(surf_network_model->name,"network NS3"))
-       return ret;
-
-  AS_rulebased_t routing = (AS_rulebased_t)rc;
-
-  xbt_dict_cursor_t c1 = NULL;
-  char *k1, *d1;
-
-  //find router
-  char *router = NULL;
-  xbt_dict_foreach(routing->dict_processing_units, c1, k1, d1) {
-    if (routing_get_network_element_type(k1) == SURF_NETWORK_ELEMENT_ROUTER){
-      router = k1;
-      break;
-    }
-  }
-
-  if (!router)
-    xbt_die ("rulebased_get_onelink_routes works only if the AS is a cluster, sorry.");
-
-  xbt_dict_foreach(routing->dict_processing_units, c1, k1, d1) {
-    route_t route = xbt_new0(s_route_t,1);
-    route->link_list = xbt_dynar_new(global_routing->size_of_link,NULL);
-    rulebased_get_route_and_latency (rc, router, k1, route,NULL);
-
-    int number_of_links = xbt_dynar_length(route->link_list);
-
-    if(number_of_links == 1) {
-               //loopback
-    }
-    else{
-               if (number_of_links != 2) {
-                 xbt_die ("rulebased_get_onelink_routes works only if the AS is a cluster, sorry.");
-               }
-
-               void *link_ptr;
-               xbt_dynar_get_cpy (route->link_list, 1, &link_ptr);
-               onelink_t onelink = xbt_new0 (s_onelink_t, 1);
-               onelink->src = xbt_strdup (k1);
-               onelink->dst = xbt_strdup (router);
-               onelink->link_ptr = link_ptr;
-               xbt_dynar_push (ret, &onelink);
-    }
-  }
+  THROW_UNIMPLEMENTED;
+//  //We have already bypass cluster routes with network NS3
+//  if(!strcmp(surf_network_model->name,"network NS3"))
+//     return ret;
+//
+//  AS_rulebased_t routing = (AS_rulebased_t)rc;
+//
+//  xbt_dict_cursor_t c1 = NULL;
+//  char *k1, *d1;
+//
+//  //find router
+//  char *router = NULL;
+//  xbt_dict_foreach(routing->dict_processing_units, c1, k1, d1) {
+//    if (routing_get_network_element_type(k1) == SURF_NETWORK_ELEMENT_ROUTER){
+//      router = k1;
+//      break;
+//    }
+//  }
+//
+//  if (!router)
+//    xbt_die ("rulebased_get_onelink_routes works only if the AS is a cluster, sorry.");
+//
+//  xbt_dict_foreach(routing->dict_processing_units, c1, k1, d1) {
+//    route_t route = xbt_new0(s_route_t,1);
+//    route->link_list = xbt_dynar_new(global_routing->size_of_link,NULL);
+//    rulebased_get_route_and_latency (rc, router, k1, route,NULL);
+//
+//    int number_of_links = xbt_dynar_length(route->link_list);
+//
+//    if(number_of_links == 1) {
+//             //loopback
+//    }
+//    else{
+//             if (number_of_links != 2) {
+//               xbt_die ("rulebased_get_onelink_routes works only if the AS is a cluster, sorry.");
+//             }
+//
+//             void *link_ptr;
+//             xbt_dynar_get_cpy (route->link_list, 1, &link_ptr);
+//             onelink_t onelink = xbt_new0 (s_onelink_t, 1);
+//             onelink->src = xbt_strdup (k1);
+//             onelink->dst = xbt_strdup (router);
+//             onelink->link_ptr = link_ptr;
+//             xbt_dynar_push (ret, &onelink);
+//    }
+//  }

   return ret;
 }
 
 /* Business methods */
 static void rulebased_get_route_and_latency(AS_t rc,
   return ret;
 }
 
 /* Business methods */
 static void rulebased_get_route_and_latency(AS_t rc,

-                                const char *src, const char *dst,
+    network_element_t src, network_element_t dst,

                                 route_t route, double *lat)
 {
                                 route_t route, double *lat)
 {

+  XBT_DEBUG("rulebased_get_route_and_latency from '%s' to '%s'",src->name,dst->name);

   xbt_assert(rc && src
               && dst,
               "Invalid params for \"get_route\" function at AS \"%s\"",
   xbt_assert(rc && src
               && dst,
               "Invalid params for \"get_route\" function at AS \"%s\"",


@@ -274,24 +277,25 @@ static void rulebased_get_route_and_latency(AS_t rc,
   /* set utils vars */
   AS_rulebased_t routing = (AS_rulebased_t) rc;
 
   /* set utils vars */
   AS_rulebased_t routing = (AS_rulebased_t) rc;
 

+  char* src_name = src->name;
+  char* dst_name = dst->name;
+

   int are_processing_units=0;
   xbt_dynar_t rule_list;
   int are_processing_units=0;
   xbt_dynar_t rule_list;

-  if (xbt_dict_get_or_null(routing->dict_processing_units, src)
-      && xbt_dict_get_or_null(routing->dict_processing_units, dst)) {
+  if ((src->rc_type == SURF_NETWORK_ELEMENT_HOST || src->rc_type == SURF_NETWORK_ELEMENT_ROUTER)&&
+      (dst->rc_type == SURF_NETWORK_ELEMENT_HOST || dst->rc_type == SURF_NETWORK_ELEMENT_ROUTER)){

     are_processing_units = 1;
     rule_list = routing->list_route;
     are_processing_units = 1;
     rule_list = routing->list_route;

-  } else if (xbt_dict_get_or_null(routing->dict_autonomous_systems, src)
-             && xbt_dict_get_or_null(routing->dict_autonomous_systems,
-                                     dst)) {
+  } else if (src->rc_type == SURF_NETWORK_ELEMENT_AS && dst->rc_type == SURF_NETWORK_ELEMENT_AS) {

     are_processing_units = 0;
     rule_list = routing->list_ASroute;
   } else
     are_processing_units = 0;
     rule_list = routing->list_ASroute;
   } else

-    THROWF(arg_error,0,"No route from '%s' to '%s'",src,dst);
+    THROWF(arg_error,0,"No route from '%s' to '%s'",src_name,dst_name);

 
   int rc_src = -1;
   int rc_dst = -1;
 
   int rc_src = -1;
   int rc_dst = -1;

-  int src_length = (int) strlen(src);
-  int dst_length = (int) strlen(dst);
+  int src_length = (int) strlen(src_name);
+  int dst_length = (int) strlen(dst_name);

 
   rule_route_t ruleroute;
   unsigned int cpt;
 
   rule_route_t ruleroute;
   unsigned int cpt;


@@ -302,17 +306,17 @@ static void rulebased_get_route_and_latency(AS_t rc,
   _XBT_GNUC_UNUSED int res;
   xbt_dynar_foreach(rule_list, cpt, ruleroute) {
     rc_src =
   _XBT_GNUC_UNUSED int res;
   xbt_dynar_foreach(rule_list, cpt, ruleroute) {
     rc_src =

-        pcre_exec(ruleroute->re_src, NULL, src, src_length, 0, 0,
+        pcre_exec(ruleroute->re_src, NULL, src_name, src_length, 0, 0,

                   ovector_src, OVECCOUNT);
     if (rc_src >= 0) {
       rc_dst =
                   ovector_src, OVECCOUNT);
     if (rc_src >= 0) {
       rc_dst =

-          pcre_exec(ruleroute->re_dst, NULL, dst, dst_length, 0, 0,
+          pcre_exec(ruleroute->re_dst, NULL, dst_name, dst_length, 0, 0,

                     ovector_dst, OVECCOUNT);
       if (rc_dst >= 0) {
                     ovector_dst, OVECCOUNT);
       if (rc_dst >= 0) {

-        res = pcre_get_substring_list(src, ovector_src, rc_src, &list_src);
-        xbt_assert(!res, "error solving substring list for src \"%s\"", src);
-        res = pcre_get_substring_list(dst, ovector_dst, rc_dst, &list_dst);
-        xbt_assert(!res, "error solving substring list for src \"%s\"", dst);
+        res = pcre_get_substring_list(src_name, ovector_src, rc_src, &list_src);
+        xbt_assert(!res, "error solving substring list for src \"%s\"", src_name);
+        res = pcre_get_substring_list(dst_name, ovector_dst, rc_dst, &list_dst);
+        xbt_assert(!res, "error solving substring list for dst \"%s\"", dst_name);

         char *link_name;
         xbt_dynar_foreach(ruleroute->re_str_link, cpt, link_name) {
           char *new_link_name =
         char *link_name;
         xbt_dynar_foreach(ruleroute->re_str_link, cpt, link_name) {
           char *new_link_name =


@@ -335,24 +339,35 @@ static void rulebased_get_route_and_latency(AS_t rc,
 
   if (rc_src >= 0 && rc_dst >= 0) {
     /* matched src and dest, nothing more to do (?) */
 
   if (rc_src >= 0 && rc_dst >= 0) {
     /* matched src and dest, nothing more to do (?) */

-  } else if (!strcmp(src, dst) && are_processing_units) {
+  } else if (!strcmp(src_name, dst_name) && are_processing_units) {

     xbt_dynar_push(route->link_list, &(global_routing->loopback));
     if (lat)
       *lat += surf_network_model->extension.network.get_link_latency(global_routing->loopback);
   } else {
     xbt_dynar_push(route->link_list, &(global_routing->loopback));
     if (lat)
       *lat += surf_network_model->extension.network.get_link_latency(global_routing->loopback);
   } else {

-    THROWF(arg_error,0,"No route from '%s' to '%s'??",src,dst);
+    THROWF(arg_error,0,"No route from '%s' to '%s'??",src_name,dst_name);

     //xbt_dynar_reset(route->link_list);
   }
 
   if (!are_processing_units && !xbt_dynar_is_empty(route->link_list)) {
     rule_route_extended_t ruleroute_extended =
         (rule_route_extended_t) ruleroute;
     //xbt_dynar_reset(route->link_list);
   }
 
   if (!are_processing_units && !xbt_dynar_is_empty(route->link_list)) {
     rule_route_extended_t ruleroute_extended =
         (rule_route_extended_t) ruleroute;

-    route->src_gateway =
-        remplace(ruleroute_extended->re_src_gateway, list_src, rc_src,
-                 list_dst, rc_dst);
-    route->dst_gateway =
-        remplace(ruleroute_extended->re_dst_gateway, list_src, rc_src,
-                 list_dst, rc_dst);
+    char *gw_src_name = remplace(ruleroute_extended->re_src_gateway, list_src, rc_src,
+        list_dst, rc_dst);
+    route->src_gateway = (network_element_t)xbt_lib_get_or_null(host_lib, gw_src_name, ROUTING_HOST_LEVEL);
+    route->src_gateway = (network_element_t)xbt_lib_get_or_null(host_lib, gw_src_name, ROUTING_HOST_LEVEL);
+    if(!route->src_gateway)
+      route->src_gateway = (network_element_t)xbt_lib_get_or_null(as_router_lib, gw_src_name, ROUTING_ASR_LEVEL);
+    if(!route->src_gateway)
+      route->src_gateway = (network_element_t)xbt_lib_get_or_null(as_router_lib, gw_src_name, ROUTING_ASR_LEVEL);
+
+    char *gw_dst_name = remplace(ruleroute_extended->re_dst_gateway, list_src, rc_src,
+        list_dst, rc_dst);
+    route->dst_gateway = (network_element_t)xbt_lib_get_or_null(host_lib, gw_dst_name, ROUTING_HOST_LEVEL);
+    route->dst_gateway = (network_element_t)xbt_lib_get_or_null(host_lib, gw_dst_name, ROUTING_HOST_LEVEL);
+    if(!route->dst_gateway)
+      route->dst_gateway = (network_element_t)xbt_lib_get_or_null(as_router_lib, gw_dst_name, ROUTING_ASR_LEVEL);
+    if(!route->dst_gateway)
+      route->dst_gateway = (network_element_t)xbt_lib_get_or_null(as_router_lib, gw_dst_name, ROUTING_ASR_LEVEL);

   }
 
   if (list_src)
   }
 
   if (list_src)


@@ -361,7 +376,7 @@ static void rulebased_get_route_and_latency(AS_t rc,
     pcre_free_substring_list(list_dst);
 }
 
     pcre_free_substring_list(list_dst);
 }
 

-static route_t rulebased_get_bypass_route(AS_t rc, const char *src, const char *dst) {
+static route_t rulebased_get_bypass_route(AS_t rc, network_element_t src, network_element_t dst) {

   return NULL;
 }
 
   return NULL;
 }
 


@@ -370,11 +385,8 @@ static void rulebased_finalize(AS_t rc)
   AS_rulebased_t routing =
       (AS_rulebased_t) rc;
   if (routing) {
   AS_rulebased_t routing =
       (AS_rulebased_t) rc;
   if (routing) {

-    xbt_dict_free(&routing->dict_processing_units);
-    xbt_dict_free(&routing->dict_autonomous_systems);

     xbt_dynar_free(&routing->list_route);
     xbt_dynar_free(&routing->list_ASroute);
     xbt_dynar_free(&routing->list_route);
     xbt_dynar_free(&routing->list_ASroute);

-

     model_generic_finalize(rc);
   }
 }
     model_generic_finalize(rc);
   }
 }


@@ -395,8 +407,6 @@ AS_t model_rulebased_create(void) {
   new_component->generic_routing.get_bypass_route = rulebased_get_bypass_route;
   new_component->generic_routing.finalize = rulebased_finalize;
   /* initialization of internal structures */
   new_component->generic_routing.get_bypass_route = rulebased_get_bypass_route;
   new_component->generic_routing.finalize = rulebased_finalize;
   /* initialization of internal structures */

-  new_component->dict_processing_units = xbt_dict_new_homogeneous(NULL);
-  new_component->dict_autonomous_systems = xbt_dict_new_homogeneous(NULL);

   new_component->list_route = xbt_dynar_new(sizeof(rule_route_t), &rule_route_free);
   new_component->list_ASroute =
       xbt_dynar_new(sizeof(rule_route_extended_t),
   new_component->list_route = xbt_dynar_new(sizeof(rule_route_t), &rule_route_free);
   new_component->list_ASroute =
       xbt_dynar_new(sizeof(rule_route_extended_t),

diff --git a/src/surf/surf_routing_vivaldi.c b/src/surf/surf_routing_vivaldi.c
index 6ba2ebe..a460041 100644 (file)
--- a/src/surf/surf_routing_vivaldi.c
+++ b/src/surf/surf_routing_vivaldi.c
@@ -17,33 +17,58 @@ static XBT_INLINE double euclidean_dist_comp(int index, xbt_dynar_t src, xbt_dyn
 }
 
 static void vivaldi_get_route_and_latency(
 }
 
 static void vivaldi_get_route_and_latency(

-    AS_t rc, const char *src_p, const char *dst_p,
+    AS_t rc, network_element_t src_p, network_element_t dst_p,

     route_t route, double *lat)
 {
     route_t route, double *lat)
 {

-  char *src = (char*)src_p;
-  char *dst = (char*)dst_p;
+  XBT_DEBUG("vivaldi_get_route_and_latency from '%s'[%d] '%s'[%d]",src_p->name,src_p->id,dst_p->name,dst_p->id);
+  char *src = (char*)src_p->name;
+  char *dst = (char*)dst_p->name;

 
   if(routing_get_network_element_type(src) == SURF_NETWORK_ELEMENT_AS) {
 
   if(routing_get_network_element_type(src) == SURF_NETWORK_ELEMENT_AS) {

-    src = route->src_gateway = ROUTER_PEER(src);
-    dst = route->dst_gateway = ROUTER_PEER(dst);
+    route->src_gateway = xbt_lib_get_or_null(as_router_lib,ROUTER_PEER(src),ROUTING_ASR_LEVEL);
+    route->dst_gateway = xbt_lib_get_or_null(as_router_lib,ROUTER_PEER(dst),ROUTING_ASR_LEVEL);

   }
 
   double euclidean_dist;
   xbt_dynar_t src_ctn, dst_ctn;
   }
 
   double euclidean_dist;
   xbt_dynar_t src_ctn, dst_ctn;

-  src_ctn = xbt_lib_get_or_null(host_lib, src, COORD_HOST_LEVEL);
-  if(!src_ctn) src_ctn = xbt_lib_get_or_null(as_router_lib, src, COORD_ASR_LEVEL);
-  dst_ctn = xbt_lib_get_or_null(host_lib, dst, COORD_HOST_LEVEL);
-  if(!dst_ctn) dst_ctn = xbt_lib_get_or_null(as_router_lib, dst, COORD_ASR_LEVEL);
+  char *tmp_src_name, *tmp_dst_name;

 
 

-  xbt_assert(src_ctn,"No coordinate found for element '%s'",src);
-  xbt_assert(dst_ctn,"No coordinate found for element '%s'",dst);
+  if(src_p->rc_type == SURF_NETWORK_ELEMENT_HOST){
+    tmp_src_name = HOST_PEER(src);
+    src_ctn = xbt_lib_get_or_null(host_lib, tmp_src_name, COORD_HOST_LEVEL);
+    if(!src_ctn ) src_ctn = xbt_lib_get_or_null(host_lib, src, COORD_HOST_LEVEL);
+  }
+  else if(src_p->rc_type == SURF_NETWORK_ELEMENT_ROUTER || src_p->rc_type == SURF_NETWORK_ELEMENT_AS){
+    tmp_src_name = ROUTER_PEER(src);
+    src_ctn = xbt_lib_get_or_null(as_router_lib, tmp_src_name, COORD_ASR_LEVEL);
+  }
+  else{
+    xbt_die(" ");
+  }
+
+  if(dst_p->rc_type == SURF_NETWORK_ELEMENT_HOST){
+    tmp_dst_name = HOST_PEER(dst);
+    dst_ctn = xbt_lib_get_or_null(host_lib, tmp_dst_name, COORD_HOST_LEVEL);
+    if(!dst_ctn ) dst_ctn = xbt_lib_get_or_null(host_lib, dst, COORD_HOST_LEVEL);
+  }
+  else if(dst_p->rc_type == SURF_NETWORK_ELEMENT_ROUTER || dst_p->rc_type == SURF_NETWORK_ELEMENT_AS){
+    tmp_dst_name = ROUTER_PEER(dst);
+    dst_ctn = xbt_lib_get_or_null(as_router_lib, tmp_dst_name, COORD_ASR_LEVEL);
+  }
+  else{
+    xbt_die(" ");
+  }
+
+  xbt_assert(src_ctn,"No coordinate found for element '%s'",tmp_src_name);
+  xbt_assert(dst_ctn,"No coordinate found for element '%s'",tmp_dst_name);
+  free(tmp_src_name);
+  free(tmp_dst_name);

 
   euclidean_dist = sqrt (euclidean_dist_comp(0,src_ctn,dst_ctn)+euclidean_dist_comp(1,src_ctn,dst_ctn))
 
   euclidean_dist = sqrt (euclidean_dist_comp(0,src_ctn,dst_ctn)+euclidean_dist_comp(1,src_ctn,dst_ctn))

-                      + fabs(xbt_dynar_get_as(src_ctn, 2, double))+fabs(xbt_dynar_get_as(dst_ctn, 2, double));
+                  + fabs(xbt_dynar_get_as(src_ctn, 2, double))+fabs(xbt_dynar_get_as(dst_ctn, 2, double));

 
   if (lat)
     *lat += euclidean_dist / 1000; //From .ms to .s
 
   if (lat)
     *lat += euclidean_dist / 1000; //From .ms to .s

-

 }
 
 
 }
 
 

diff --git a/src/surf/workstation.c b/src/surf/workstation.c
index 88f4802..f090b9d 100644 (file)
--- a/src/surf/workstation.c
+++ b/src/surf/workstation.c
@@ -14,7 +14,7 @@
 typedef struct workstation_CLM03 {
   s_surf_resource_t generic_resource;   /* Must remain first to add this to a trace */
   void *cpu;
 typedef struct workstation_CLM03 {
   s_surf_resource_t generic_resource;   /* Must remain first to add this to a trace */
   void *cpu;

-  void *net_card;
+  void *net_elm;

   xbt_dynar_t storage;
 } s_workstation_CLM03_t, *workstation_CLM03_t;
 
   xbt_dynar_t storage;
 } s_workstation_CLM03_t, *workstation_CLM03_t;
 


@@ -31,6 +31,7 @@ static void workstation_new(sg_platf_host_cbarg_t host)
   workstation->generic_resource.name = xbt_strdup(host->id);
   workstation->cpu = xbt_lib_get_or_null(host_lib, host->id, SURF_CPU_LEVEL);
   workstation->storage = xbt_lib_get_or_null(storage_lib,host->id,ROUTING_STORAGE_HOST_LEVEL);
   workstation->generic_resource.name = xbt_strdup(host->id);
   workstation->cpu = xbt_lib_get_or_null(host_lib, host->id, SURF_CPU_LEVEL);
   workstation->storage = xbt_lib_get_or_null(storage_lib,host->id,ROUTING_STORAGE_HOST_LEVEL);

+  workstation->net_elm = xbt_lib_get_or_null(host_lib,host->id,ROUTING_HOST_LEVEL);

   XBT_DEBUG("Create workstation %s with %ld mounted disks",host->id,xbt_dynar_length(workstation->storage));
   xbt_lib_set(host_lib, host->id, SURF_WKS_LEVEL, workstation);
 }
   XBT_DEBUG("Create workstation %s with %ld mounted disks",host->id,xbt_dynar_length(workstation->storage));
   xbt_lib_set(host_lib, host->id, SURF_WKS_LEVEL, workstation);
 }


@@ -211,8 +212,8 @@ static surf_action_t ws_communicate(void *workstation_src,
   workstation_CLM03_t src = (workstation_CLM03_t) workstation_src;
   workstation_CLM03_t dst = (workstation_CLM03_t) workstation_dst;
   return surf_network_model->extension.network.
   workstation_CLM03_t src = (workstation_CLM03_t) workstation_src;
   workstation_CLM03_t dst = (workstation_CLM03_t) workstation_dst;
   return surf_network_model->extension.network.

-      communicate(surf_resource_name(src->cpu),
-                  surf_resource_name(dst->cpu), size, rate);
+      communicate(src->net_elm,
+                  dst->net_elm, size, rate);

 }
 
 static e_surf_resource_state_t ws_get_state(void *workstation)
 }
 
 static e_surf_resource_state_t ws_get_state(void *workstation)


@@ -246,10 +247,14 @@ static surf_action_t ws_execute_parallel_task(int workstation_nb,
 
 
 /* returns an array of network_link_CM02_t */
 
 
 /* returns an array of network_link_CM02_t */

-static xbt_dynar_t ws_get_route(void *src, void *dst)
+static xbt_dynar_t ws_get_route(void *workstation_src, void *workstation_dst)

 {
 {

+  XBT_INFO("ws_get_route");
+  workstation_CLM03_t src = (workstation_CLM03_t) workstation_src;
+  workstation_CLM03_t dst = (workstation_CLM03_t) workstation_dst;

   return surf_network_model->extension.
   return surf_network_model->extension.

-      network.get_route(surf_resource_name(src), surf_resource_name(dst));
+      network.get_route(src->net_elm,
+                  dst->net_elm);

 }
 
 static double ws_get_link_bandwidth(const void *link)
 }
 
 static double ws_get_link_bandwidth(const void *link)

diff --git a/src/surf/workstation_ptask_L07.c b/src/surf/workstation_ptask_L07.c
index 650f0cd..5e73d18 100644 (file)
--- a/src/surf/workstation_ptask_L07.c
+++ b/src/surf/workstation_ptask_L07.c
@@ -28,7 +28,7 @@ typedef struct cpu_L07 {
   tmgr_trace_event_t power_event;
   tmgr_trace_event_t state_event;
   e_surf_resource_state_t state_current;
   tmgr_trace_event_t power_event;
   tmgr_trace_event_t state_event;
   e_surf_resource_state_t state_current;

-  int id;                       /* cpu and network card are a single object... */
+  network_element_t info;

 } s_cpu_L07_t, *cpu_L07_t;
 
 /**************************************/
 } s_cpu_L07_t, *cpu_L07_t;
 
 /**************************************/


@@ -69,13 +69,13 @@ static int ptask_host_count = 0;
 static xbt_dict_t ptask_parallel_task_link_set = NULL;
 lmm_system_t ptask_maxmin_system = NULL;
 
 static xbt_dict_t ptask_parallel_task_link_set = NULL;
 lmm_system_t ptask_maxmin_system = NULL;
 

-static surf_action_t die_impossible_communicate (const char *src_name, const char *dst_name, double size, double rate)
+static surf_action_t die_impossible_communicate (void *src, void *dst, double size, double rate)

 {
   DIE_IMPOSSIBLE;
   return NULL;
 }
 
 {
   DIE_IMPOSSIBLE;
   return NULL;
 }
 

-static xbt_dynar_t die_impossible_get_route(const char *src_name, const char *dst_name)
+static xbt_dynar_t die_impossible_get_route(void *src, void *dst)

 {
   DIE_IMPOSSIBLE;
   return NULL;
 {
   DIE_IMPOSSIBLE;
   return NULL;


@@ -94,9 +94,8 @@ static void ptask_update_action_bound(surf_action_workstation_L07_t action)
 
       if (action->communication_amount[i * workstation_nb + j] > 0) {
         double lat = 0.0;
 
       if (action->communication_amount[i * workstation_nb + j] > 0) {
         double lat = 0.0;

-        routing_get_route_and_latency(surf_resource_name
-            (action->workstation_list[i]),
-            surf_resource_name(action->workstation_list[j]),
+        routing_get_route_and_latency(action->workstation_list[i]->info,
+            action->workstation_list[j]->info,

             &route, &lat);
         lat_current =
             MAX(lat_current,
             &route, &lat);
         lat_current =
             MAX(lat_current,


@@ -472,8 +471,8 @@ static surf_action_t ptask_execute_parallel_task(int workstation_nb,
         link_L07_t link;
 
         routing_get_route_and_latency(
         link_L07_t link;
 
         routing_get_route_and_latency(

-            surf_resource_name(workstation_list[i]),
-            surf_resource_name(workstation_list[j]),
+            ((cpu_L07_t)workstation_list[i])->info,
+            ((cpu_L07_t)workstation_list[j])->info,

             &route,&lat);
         latency = MAX(latency, lat);
 
             &route,&lat);
         latency = MAX(latency, lat);
 


@@ -526,8 +525,8 @@ static surf_action_t ptask_execute_parallel_task(int workstation_nb,
         continue;
 
       routing_get_route_and_latency(
         continue;
 
       routing_get_route_and_latency(

-          surf_resource_name(workstation_list[i]),
-          surf_resource_name(workstation_list[j]),
+          ((cpu_L07_t)workstation_list[i])->info,
+          ((cpu_L07_t)workstation_list[j])->info,

           &route,NULL);
 
       xbt_dynar_foreach(route, cpt, link) {
           &route,NULL);
 
       xbt_dynar_foreach(route, cpt, link) {


@@ -599,7 +598,7 @@ static xbt_dynar_t ptask_get_route(void *src, void *dst) // FIXME: kill that cal
 {
   xbt_dynar_t route=NULL;
   routing_get_route_and_latency(
 {
   xbt_dynar_t route=NULL;
   routing_get_route_and_latency(

-      surf_resource_name(src), surf_resource_name(dst),
+      ((cpu_L07_t)src)->info, ((cpu_L07_t)dst)->info,

       &route,NULL);
   return route;
 }
       &route,NULL);
   return route;
 }


@@ -639,7 +638,8 @@ static void* ptask_cpu_create_resource(const char *name, double power_scale,
           surf_workstation_model, name,cpu_properties);
 
   cpu->type = SURF_WORKSTATION_RESOURCE_CPU;
           surf_workstation_model, name,cpu_properties);
 
   cpu->type = SURF_WORKSTATION_RESOURCE_CPU;

-  cpu->id = ptask_host_count++;
+  cpu->info = (network_element_t)xbt_lib_get_or_null(host_lib,name,ROUTING_HOST_LEVEL);
+  if(!(cpu->info)) xbt_die("Don't find ROUTING_HOST_LEVEL for '%s'",name);

 
   cpu->power_scale = power_scale;
   xbt_assert(cpu->power_scale > 0, "Power has to be >0");
 
   cpu->power_scale = power_scale;
   xbt_assert(cpu->power_scale > 0, "Power has to be >0");

diff --git a/teshsuite/simdag/platforms/flatifier.c b/teshsuite/simdag/platforms/flatifier.c
index 5695df8..a893b25 100644 (file)
--- a/teshsuite/simdag/platforms/flatifier.c
+++ b/teshsuite/simdag/platforms/flatifier.c
@@ -53,7 +53,8 @@ int main(int argc, char **argv)
   xbt_lib_cursor_t cursor_src = NULL;
   xbt_lib_cursor_t cursor_dst = NULL;
   char *src,*dst,*key,*data;
   xbt_lib_cursor_t cursor_src = NULL;
   xbt_lib_cursor_t cursor_dst = NULL;
   char *src,*dst,*key,*data;

-  char **value;
+  network_element_t value1;
+  network_element_t value2;

   xbt_ex_t e;
 
   const SD_workstation_t *hosts;
   xbt_ex_t e;
 
   const SD_workstation_t *hosts;


@@ -100,8 +101,8 @@ int main(int argc, char **argv)
   }
 
   // Routers
   }
 
   // Routers

-  xbt_lib_foreach(as_router_lib, cursor_src, key, value) {
-         if(((network_element_info_t)xbt_lib_get_or_null(as_router_lib, key,
+  xbt_lib_foreach(as_router_lib, cursor_src, key, value1) {
+         if(((network_element_t)xbt_lib_get_or_null(as_router_lib, key,

                          ROUTING_ASR_LEVEL))->rc_type == SURF_NETWORK_ELEMENT_ROUTER)
          {
                  printf("  <router id=\"%s\"/>\n",key);
                          ROUTING_ASR_LEVEL))->rc_type == SURF_NETWORK_ELEMENT_ROUTER)
          {
                  printf("  <router id=\"%s\"/>\n",key);


@@ -129,15 +130,17 @@ int main(int argc, char **argv)
   }
 
 
   }
 
 

-  xbt_lib_foreach(host_lib, cursor_src, src, value) // Routes from host
+  xbt_lib_foreach(host_lib, cursor_src, src, value1) // Routes from host

   {
   {

-                 xbt_lib_foreach(host_lib, cursor_dst, dst, value) //to host
+          value1 = xbt_lib_get_or_null(host_lib,src,ROUTING_HOST_LEVEL);
+                 xbt_lib_foreach(host_lib, cursor_dst, dst, value2) //to host

                  {
                                printf("  <route src=\"%s\" dst=\"%s\">\n  "
                                          ,src
                                          ,dst);
                                xbt_dynar_t route=NULL;
                  {
                                printf("  <route src=\"%s\" dst=\"%s\">\n  "
                                          ,src
                                          ,dst);
                                xbt_dynar_t route=NULL;

-                               routing_get_route_and_latency(src,dst,&route,NULL);
+                               value2 = xbt_lib_get_or_null(host_lib,dst,ROUTING_HOST_LEVEL);
+                               routing_get_route_and_latency(value1,value2,&route,NULL);

                                for(i=0;i<xbt_dynar_length(route) ;i++)
                                {
                                        void *link = xbt_dynar_get_as(route,i,void *);
                                for(i=0;i<xbt_dynar_length(route) ;i++)
                                {
                                        void *link = xbt_dynar_get_as(route,i,void *);


@@ -148,14 +151,15 @@ int main(int argc, char **argv)
                                }
                                printf("\n  </route>\n");
                  }
                                }
                                printf("\n  </route>\n");
                  }

-                 xbt_lib_foreach(as_router_lib, cursor_dst, dst, value) //to router
+                 xbt_lib_foreach(as_router_lib, cursor_dst, dst, value2) //to router

                  {
                            if(routing_get_network_element_type(dst) == SURF_NETWORK_ELEMENT_ROUTER){
                                printf("  <route src=\"%s\" dst=\"%s\">\n  "
                                          ,src
                                          ,dst);
                                xbt_dynar_t route=NULL;
                  {
                            if(routing_get_network_element_type(dst) == SURF_NETWORK_ELEMENT_ROUTER){
                                printf("  <route src=\"%s\" dst=\"%s\">\n  "
                                          ,src
                                          ,dst);
                                xbt_dynar_t route=NULL;

-                               routing_get_route_and_latency(src,dst,&route,NULL);
+                               value2 = xbt_lib_get_or_null(as_router_lib,dst,ROUTING_ASR_LEVEL);
+                               routing_get_route_and_latency((network_element_t)value1,(network_element_t)value2,&route,NULL);

                                for(i=0;i<xbt_dynar_length(route) ;i++)
                                {
                                        void *link = xbt_dynar_get_as(route,i,void *);
                                for(i=0;i<xbt_dynar_length(route) ;i++)
                                {
                                        void *link = xbt_dynar_get_as(route,i,void *);


@@ -169,17 +173,19 @@ int main(int argc, char **argv)
                  }
   }
 
                  }
   }
 

-  xbt_lib_foreach(as_router_lib, cursor_src, src, value) // Routes from router
+  xbt_lib_foreach(as_router_lib, cursor_src, src, value1) // Routes from router

   {
   {

+      value1 = xbt_lib_get_or_null(as_router_lib,src,ROUTING_ASR_LEVEL);

          if(routing_get_network_element_type(src) == SURF_NETWORK_ELEMENT_ROUTER){
          if(routing_get_network_element_type(src) == SURF_NETWORK_ELEMENT_ROUTER){

-                 xbt_lib_foreach(as_router_lib, cursor_dst, dst, value) //to router
+                 xbt_lib_foreach(as_router_lib, cursor_dst, dst, value2) //to router

                  {
                                if(routing_get_network_element_type(dst) == SURF_NETWORK_ELEMENT_ROUTER){
                                printf("  <route src=\"%s\" dst=\"%s\">\n  "
                                          ,src
                                          ,dst);
                                xbt_dynar_t route=NULL;
                  {
                                if(routing_get_network_element_type(dst) == SURF_NETWORK_ELEMENT_ROUTER){
                                printf("  <route src=\"%s\" dst=\"%s\">\n  "
                                          ,src
                                          ,dst);
                                xbt_dynar_t route=NULL;

-                               routing_get_route_and_latency(src,dst,&route,NULL);
+                               value2 = xbt_lib_get_or_null(as_router_lib,dst,ROUTING_ASR_LEVEL);
+                               routing_get_route_and_latency((network_element_t)value1,(network_element_t)value2,&route,NULL);

                                for(i=0;i<xbt_dynar_length(route) ;i++)
                                {
                                        void *link = xbt_dynar_get_as(route,i,void *);
                                for(i=0;i<xbt_dynar_length(route) ;i++)
                                {
                                        void *link = xbt_dynar_get_as(route,i,void *);


@@ -191,12 +197,13 @@ int main(int argc, char **argv)
                                printf("\n  </route>\n");
                                }
                  }
                                printf("\n  </route>\n");
                                }
                  }

-                 xbt_lib_foreach(host_lib, cursor_dst, dst, value) //to host
+                 xbt_lib_foreach(host_lib, cursor_dst, dst, value2) //to host

                  {
                                printf("  <route src=\"%s\" dst=\"%s\">\n  "
                                          ,src, dst);
                                xbt_dynar_t route=NULL;
                  {
                                printf("  <route src=\"%s\" dst=\"%s\">\n  "
                                          ,src, dst);
                                xbt_dynar_t route=NULL;

-                               routing_get_route_and_latency(src,dst,&route, NULL);
+                               value2 = xbt_lib_get_or_null(host_lib,dst,ROUTING_HOST_LEVEL);
+                               routing_get_route_and_latency((network_element_t)value1,(network_element_t)value2,&route, NULL);

                                for(i=0;i<xbt_dynar_length(route) ;i++)
                                {
                                        void *link = xbt_dynar_get_as(route,i,void *);
                                for(i=0;i<xbt_dynar_length(route) ;i++)
                                {
                                        void *link = xbt_dynar_get_as(route,i,void *);

diff --git a/testsuite/surf/surf_usage.c b/testsuite/surf/surf_usage.c
index db55b75..3886c51 100644 (file)
--- a/testsuite/surf/surf_usage.c
+++ b/testsuite/surf/surf_usage.c
@@ -90,7 +90,7 @@ void test(char *platform)
   XBT_DEBUG("%s : %p", surf_resource_name(cardB), cardB);
 
   /* Let's do something on it */
   XBT_DEBUG("%s : %p", surf_resource_name(cardB), cardB);
 
   /* Let's do something on it */

-  surf_network_model->extension.network.communicate("Cpu A", "Cpu B",
+  surf_network_model->extension.network.communicate(cpuA, cpuB,

                                                     150.0, -1.0);
 
   surf_solve(-1.0);                 /* Takes traces into account. Returns 0.0 */
                                                     150.0, -1.0);
 
   surf_solve(-1.0);                 /* Takes traces into account. Returns 0.0 */