Save information from routing corresponding to storage.

diff --git a/include/simgrid/platf.h b/include/simgrid/platf.h
index a08e6a6..a53982c 100644 (file)
--- a/include/simgrid/platf.h
+++ b/include/simgrid/platf.h
@@ -106,20 +106,20 @@ typedef struct s_sg_platf_cluster_cbarg {
 } s_sg_platf_cluster_cbarg_t;
 
 typedef struct {
-  const char* id;
-  const char* type_id;
+  char* id;
+  char* type_id;
 } s_sg_platf_storage_cbarg_t, *sg_platf_storage_cbarg_t;
 
 typedef struct {
-  const char* id;
-  const char* model;
-  const char* content;
+  char* id;
+  char* model;
+  char* content;
   xbt_dict_t properties;
 } s_sg_platf_storage_type_cbarg_t, *sg_platf_storage_type_cbarg_t;
 
 typedef struct {
-  const char* type_id;
-  const char* name;
+  char* type_id;
+  char* name;
 } s_sg_platf_mstorage_cbarg_t, *sg_platf_mstorage_cbarg_t;
 
 typedef struct {

diff --git a/include/surf/surf_routing.h b/include/surf/surf_routing.h
index 3539e39..7de832c 100644 (file)
--- a/include/surf/surf_routing.h
+++ b/include/surf/surf_routing.h
@@ -30,8 +30,9 @@ extern int COORD_ASR_LEVEL;   //Coordinates level
 extern int NS3_ASR_LEVEL;              //host node for ns3
 
 extern xbt_lib_t storage_lib;
-extern int ROUTING_STORAGE_LEVEL;   //Routing level
-extern int SURF_STORAGE_LEVEL;      //Surf level
+extern int ROUTING_STORAGE_LEVEL;        //Routing storage level
+extern int ROUTING_STORAGE_TYPE_LEVEL;   //Routing storage_type level
+extern int ROUTING_STORAGE_HOST_LEVEL;
 
 /* The callbacks to register for the routing to work */
 void routing_AS_begin(const char *AS_id, const char *wanted_routing_type);

diff --git a/src/include/surf/surf.h b/src/include/surf/surf.h
index 2c0d086..eb1a9a2 100644 (file)
--- a/src/include/surf/surf.h
+++ b/src/include/surf/surf.h
@@ -329,9 +329,6 @@ static inline void *surf_workstation_resource_by_name(const char *name){
 static inline void *surf_network_resource_by_name(const char *name){
        return xbt_lib_get_or_null(link_lib, name, SURF_LINK_LEVEL);
 }
-static inline void *surf_storage_resource_by_name(const char *name) {
-    return xbt_lib_get_or_null(storage_lib, name, SURF_STORAGE_LEVEL);
-}
 
 typedef struct surf_resource {
   surf_model_t model;
@@ -339,6 +336,21 @@ typedef struct surf_resource {
   xbt_dict_t properties;
 } s_surf_resource_t, *surf_resource_t;
 
+/**
+ * Storage struct
+ */
+typedef struct s_storage_type {
+  char *model;
+  char *content;
+  xbt_dict_t properties;
+  char *type_id;
+} s_storage_type_t, *storage_type_t;
+
+typedef struct s_mount {
+  char *type_id;
+  char *name;
+} s_mount_t, *mount_t;
+
 /**
  * Resource which have a metric handled by a maxmin system
  */

diff --git a/src/include/surf/surf_resource.h b/src/include/surf/surf_resource.h
index dc66869..8411837 100644 (file)
--- a/src/include/surf/surf_resource.h
+++ b/src/include/surf/surf_resource.h
@@ -20,6 +20,21 @@ static XBT_INLINE
   res->properties = props;
   return res;
 }
+static XBT_INLINE void routing_storage_type_free(void *r)
+{
+  storage_type_t stype = r;
+  free(stype->content);
+  free(stype->model);
+  free(stype->type_id);
+  xbt_dict_free(&stype->properties);
+  free(stype);
+}
+
+static XBT_INLINE void routing_storage_host_free(void *r)
+{
+  xbt_dynar_t dyn = r;
+  xbt_dynar_free(&dyn);
+}
 
 static XBT_INLINE void surf_resource_free(void *r)
 {

diff --git a/src/surf/storage.c b/src/surf/storage.c
index cd57539..8165a30 100644 (file)
--- a/src/surf/storage.c
+++ b/src/surf/storage.c
@@ -49,18 +49,7 @@ static surf_action_t storage_action_stat(void *storage, int fd, void* buf)
 static void* storage_create_resource(const char* id, const char* type,
                                     const char* content, xbt_dict_t storage_properties)
 {
-  xbt_assert(!surf_storage_resource_by_name(id),
-      "Storage '%s' declared several times in the platform file",
-      id);
-  XBT_DEBUG("Storage_create_resource '%s' at level SURF_STORAGE_LEVEL",id);
-  surf_storage_t storage = NULL;
-  storage = (surf_storage_t) surf_resource_new(sizeof(s_surf_storage_t),
-      surf_storage_model, id, storage_properties);
-  storage->type = type;
-  storage->content = content;
-  xbt_lib_set(storage_lib, id, SURF_STORAGE_LEVEL, storage);
-
-  return storage;
+  return NULL;
 }
 
 static void storage_finalize(void)
@@ -136,29 +125,29 @@ static void storage_action_set_priority(surf_action_t action, double priority)
 
 static void parse_storage_init(sg_platf_storage_cbarg_t storage)
 {
-  XBT_INFO("parse_storage_init");
+  XBT_DEBUG("parse_storage_init");
 }
 
 static void parse_mstorage_init(sg_platf_mstorage_cbarg_t mstorage)
 {
-  XBT_INFO("parse_mstorage_init");
+  XBT_DEBUG("parse_mstorage_init");
 }
 
 static void parse_storage_type_init(sg_platf_storage_type_cbarg_t storagetype_)
 {
-  XBT_INFO("parse_storage_type_init");
+  XBT_DEBUG("parse_storage_type_init");
 }
 
 static void parse_mount_init(sg_platf_mount_cbarg_t mount)
 {
-  XBT_INFO("parse_mount_init");
+  XBT_DEBUG("parse_mount_init");
 }
 
 static void storage_define_callbacks()
 {
   sg_platf_storage_add_cb(parse_storage_init);
-  sg_platf_mstorage_add_cb(parse_mstorage_init);
   sg_platf_storage_type_add_cb(parse_storage_type_init);
+  sg_platf_mstorage_add_cb(parse_mstorage_init);
   sg_platf_mount_add_cb(parse_mount_init);
 }
 

diff --git a/src/surf/surf.c b/src/surf/surf.c
index 41ec013..95cfaaf 100644 (file)
--- a/src/surf/surf.c
+++ b/src/surf/surf.c
@@ -316,14 +316,14 @@ void surf_init(int *argc, char **argv)
   XBT_DEBUG("ADD ROUTING LEVEL");
   ROUTING_HOST_LEVEL = xbt_lib_add_level(host_lib,xbt_free);
   ROUTING_ASR_LEVEL  = xbt_lib_add_level(as_router_lib,xbt_free);
-  // FOR NOW UNUSED
-//  ROUTING_STORAGE_LEVEL = xbt_lib_add_level(storage_lib,NULL);
+  ROUTING_STORAGE_LEVEL = xbt_lib_add_level(storage_lib,xbt_free);
+  ROUTING_STORAGE_TYPE_LEVEL = xbt_lib_add_level(storage_lib,routing_storage_type_free);
+  ROUTING_STORAGE_HOST_LEVEL = xbt_lib_add_level(storage_lib,routing_storage_host_free);
 
   XBT_DEBUG("ADD SURF LEVELS");
   SURF_CPU_LEVEL = xbt_lib_add_level(host_lib,surf_resource_free);
   SURF_WKS_LEVEL = xbt_lib_add_level(host_lib,surf_resource_free);
   SURF_LINK_LEVEL = xbt_lib_add_level(link_lib,surf_resource_free);
-  SURF_STORAGE_LEVEL = xbt_lib_add_level(storage_lib,surf_resource_free);
 
   /* Connect our log channels: that must be done manually under windows */
   XBT_LOG_CONNECT(surf_cpu, surf);

diff --git a/src/surf/surf_routing.c b/src/surf/surf_routing.c
index 1f1591e..dc6f29a 100644 (file)
--- a/src/surf/surf_routing.c
+++ b/src/surf/surf_routing.c
@@ -35,8 +35,9 @@ int NS3_ASR_LEVEL;              //host node for ns3
 static xbt_dict_t random_value = NULL;
 
 xbt_lib_t storage_lib;
-int ROUTING_STORAGE_LEVEL;      //Routing level
-int SURF_STORAGE_LEVEL;         //Surf level
+int ROUTING_STORAGE_LEVEL;      //Routing for storagelevel
+int ROUTING_STORAGE_TYPE_LEVEL; //Routing for storage_type level
+int ROUTING_STORAGE_HOST_LEVEL;
 
 /* Global vars */
 routing_global_t global_routing = NULL;
@@ -44,6 +45,7 @@ AS_t current_routing = NULL;
 
 /* global parse functions */
 xbt_dynar_t parsed_link_list = NULL;   /* temporary store of current list link of a route */
+xbt_dynar_t mount_list = NULL;  /* temporary store of current mount storage */
 static const char *src = NULL;  /* temporary store the source name of a route */
 static const char *dst = NULL;  /* temporary store the destination name of a route */
 static char *gw_src = NULL;     /* temporary store the gateway source name of a route */
@@ -108,6 +110,12 @@ static void parse_S_host(sg_platf_host_cbarg_t host)
   info->rc_component = current_routing;
   info->rc_type = SURF_NETWORK_ELEMENT_HOST;
   xbt_lib_set(host_lib, host->id, ROUTING_HOST_LEVEL, (void *) info);
+
+  if(mount_list){
+    xbt_lib_set(storage_lib, host->id, ROUTING_STORAGE_HOST_LEVEL, (void *) mount_list);
+    mount_list = NULL;
+  }
+
   if (host->coord && strcmp(host->coord, "")) {
     unsigned int cursor;
     char*str;
@@ -718,19 +726,63 @@ void routing_model_create(size_t size_of_links, void *loopback)
 
 static void routing_parse_storage(sg_platf_storage_cbarg_t storage)
 {
+  xbt_assert(!xbt_lib_get_or_null(storage_lib, storage->id,ROUTING_STORAGE_LEVEL),
+               "Reading a storage, processing unit \"%s\" already exists", storage->id);
+
+  // Verification of an existing type_id
+  void* storage_type = xbt_lib_get_or_null(storage_lib, storage->type_id,ROUTING_STORAGE_TYPE_LEVEL);
+  xbt_assert(storage_type,"Reading a storage, type id \"%s\" does not exists", storage->type_id);
+
   XBT_INFO("ROUTING Create a storage name '%s' with type_id '%s'",storage->id,storage->type_id);
-}
-static void routing_parse_mstorage(sg_platf_mstorage_cbarg_t mstorage)
-{
-  XBT_INFO("ROUTING Mount a storage name '%s' with type_id '%s'",mstorage->name, mstorage->type_id);
+
+  xbt_lib_set(storage_lib,storage->id,ROUTING_STORAGE_LEVEL,(void *) xbt_strdup(storage->type_id));
 }
 static void routing_parse_storage_type(sg_platf_storage_type_cbarg_t storage_type)
 {
+  xbt_assert(!xbt_lib_get_or_null(storage_lib, storage_type->id,ROUTING_STORAGE_TYPE_LEVEL),
+               "Reading a storage type, processing unit \"%s\" already exists", storage_type->id);
+
   XBT_INFO("ROUTING Create a storage type_id '%s' with model '%s'",storage_type->id,storage_type->model);
+  storage_type_t stype = xbt_new0(s_storage_type_t, 1);
+  stype->model = xbt_strdup(storage_type->model);
+  stype->properties = storage_type->properties;
+  stype->content = xbt_strdup(storage_type->content);
+  stype->type_id = xbt_strdup(storage_type->id);
+
+  xbt_lib_set(storage_lib,storage_type->id,ROUTING_STORAGE_TYPE_LEVEL,(void *) stype);
+}
+static void routing_parse_mstorage(sg_platf_mstorage_cbarg_t mstorage)
+{
+  mount_t mnt = xbt_new0(s_mount_t, 1);
+  mnt->type_id = xbt_strdup(mstorage->type_id);
+  mnt->name = xbt_strdup(mstorage->name);
+
+  if(!mount_list){
+    XBT_INFO("Creata a Mount list for %s",A_surfxml_host_id);
+    mount_list = xbt_dynar_new(sizeof(char *), NULL);
+  }
+  xbt_dynar_push(mount_list,(void *) mnt);
+  free(mnt->type_id);
+  free(mnt->name);
+  xbt_free(mnt);
+  XBT_INFO("ROUTING Mount a storage name '%s' with type_id '%s'",mstorage->name, mstorage->type_id);
 }
 static void routing_parse_mount(sg_platf_mount_cbarg_t mount)
 {
-  XBT_INFO("ROUTING Mount '%s' on '%s'",mount->id, mount->name);
+
+  // Verification of an existing storage
+  void* storage = xbt_lib_get_or_null(storage_lib, mount->id,ROUTING_STORAGE_LEVEL);
+  xbt_assert(storage,"Disk id \"%s\" does not exists", mount->id);
+
+  XBT_DEBUG("ROUTING Mount '%s' on '%s'",mount->id, mount->name);
+  sg_platf_mstorage_cbarg_t mstorage = xbt_new0(s_sg_platf_mstorage_cbarg_t, 1);
+  mstorage->name = xbt_strdup(mount->name);
+  mstorage->type_id = xbt_strdup((const char*)storage);
+
+  routing_parse_mstorage(mstorage);
+  free(mstorage->name);
+  free(mstorage->type_id);
+  xbt_free(mstorage);
 }
 
 static void routing_parse_cluster(sg_platf_cluster_cbarg_t cluster)