Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Simplify the way files are described. Get rid of the stats, the
authorsuter <frederic.suter@cc.in2p3.fr>
Wed, 5 Jun 2013 20:25:06 +0000 (22:25 +0200)
committersuter <frederic.suter@cc.in2p3.fr>
Wed, 5 Jun 2013 20:45:39 +0000 (22:45 +0200)
MSG_file_stat, and all the underlying functions

include/msg/msg.h
src/include/surf/surf.h
src/msg/msg_io.c
src/simix/smx_io.c
src/simix/smx_io_private.h
src/simix/smx_smurf_private.h
src/simix/smx_user.c
src/surf/storage.c
src/surf/storage_private.h

index 0826da7..891eb33 100644 (file)
@@ -71,12 +71,10 @@ XBT_PUBLIC(unsigned long int) MSG_get_sent_msg(void);
 
 
 /************************** File handling ***********************************/
-XBT_PUBLIC(double) MSG_file_read(void* ptr, size_t size, size_t nmemb, msg_file_t stream);
+XBT_PUBLIC(size_t) MSG_file_read(void* ptr, size_t size, size_t nmemb, msg_file_t stream);
 XBT_PUBLIC(size_t) MSG_file_write(const void* ptr, size_t size, size_t nmemb, msg_file_t stream);
 XBT_PUBLIC(msg_file_t) MSG_file_open(const char* mount, const char* path, const char* mode);
 XBT_PUBLIC(int) MSG_file_close(msg_file_t fp);
-XBT_PUBLIC(int) MSG_file_stat(msg_file_t fd, s_msg_stat_t *buf);
-XBT_PUBLIC(void) MSG_file_free_stat(s_msg_stat_t *stat);
 
 XBT_PUBLIC(int) MSG_file_unlink(msg_file_t fd);
 XBT_PUBLIC(xbt_dict_t) MSG_file_ls(const char *mount, const char *path);
index 1483505..ed1c0e4 100644 (file)
@@ -111,7 +111,6 @@ typedef struct surf_action {
   char *category;               /**< tracing category for categorized resource utilization monitoring */
 #endif
   surf_file_t file;        /**< surf_file_t for storage model */
-  s_file_stat_t stat;        /**< surf_file_t for storage model */
   xbt_dict_t ls_dict;
 } s_surf_action_t;
 
index 1932908..008c7bf 100644 (file)
@@ -28,7 +28,7 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_io, msg,
  * \param stream to read
  * \return the number of items successfully read
  */
-double MSG_file_read(void* ptr, size_t size, size_t nmemb,  msg_file_t stream)
+size_t MSG_file_read(void* ptr, size_t size, size_t nmemb,  msg_file_t stream)
 {
   return simcall_file_read(ptr, size, nmemb, stream->simdata->smx_file);
 }
@@ -89,34 +89,6 @@ int MSG_file_close(msg_file_t fp)
 }
 
 /** \ingroup msg_file_management
- * \brief Stats the file pointed by fd
- *
- * \param fd is the file descriptor (#msg_file_t)
- * \param buf is the return structure with informations
- * \return 0 on success or 1 on error
- */
-int MSG_file_stat(msg_file_t fd, s_msg_stat_t *buf)
-{
-  int res;
-  res = simcall_file_stat(fd->simdata->smx_file, buf);
-  return res;
-}
-
-/** \ingroup msg_file_management
- * \brief Free the stat structure
- *
- * \param stat the #s_msg_stat_t to free
- */
-void MSG_file_free_stat(s_msg_stat_t *stat)
-{
-  free(stat->date);
-  free(stat->group);
-  free(stat->time);
-  free(stat->user);
-  free(stat->user_rights);
-}
-
-/** \ingroup msg_file_management
  * \brief Unlink the file pointed by fd
  *
  * \param fd is the file descriptor (#msg_file_t)
index f261620..05a0d15 100644 (file)
@@ -161,40 +161,6 @@ smx_action_t SIMIX_file_close(smx_process_t process, smx_file_t fp)
   return action;
 }
 
-//SIMIX FILE STAT
-void SIMIX_pre_file_stat(smx_simcall_t simcall, smx_file_t fd, s_file_stat_t *buf)
-{
-  smx_action_t action = SIMIX_file_stat(simcall->issuer, fd, *buf);
-  xbt_fifo_push(action->simcalls, simcall);
-  simcall->issuer->waiting_action = action;
-}
-
-smx_action_t SIMIX_file_stat(smx_process_t process, smx_file_t fd, s_file_stat_t buf)
-{
-  smx_action_t action;
-  smx_host_t host = process->smx_host;
-  /* check if the host is active */
-  if (surf_workstation_model->extension.
-      workstation.get_state(host) != SURF_RESOURCE_ON) {
-    THROWF(host_error, 0, "Host %s failed, you cannot call this function",
-           sg_host_name(host));
-  }
-
-  action = xbt_mallocator_get(simix_global->action_mallocator);
-  action->type = SIMIX_ACTION_IO;
-  action->name = NULL;
-#ifdef HAVE_TRACING
-  action->category = NULL;
-#endif
-
-  action->io.host = host;
-  action->io.surf_io = surf_workstation_model->extension.workstation.stat(host, fd->surf_file);
-
-  surf_workstation_model->action_data_set(action->io.surf_io, action);
-  XBT_DEBUG("Create io action %p", action);
-
-  return action;
-}
 
 //SIMIX FILE UNLINK
 void SIMIX_pre_file_unlink(smx_simcall_t simcall, smx_file_t fd)
@@ -264,25 +230,14 @@ smx_action_t SIMIX_file_ls(smx_process_t process, const char* mount, const char
   return action;
 }
 
-static void free_file_stat(void *p)
-{
-  file_stat_t fs = p;
-  xbt_free(fs->date);
-  xbt_free(fs->group);
-  xbt_free(fs->time);
-  xbt_free(fs->user);
-  xbt_free(fs->user_rights);
-  xbt_free(fs);
-}
-
 void SIMIX_post_io(smx_action_t action)
 {
   xbt_fifo_item_t i;
   smx_simcall_t simcall;
-  char* key;
-  xbt_dict_cursor_t cursor = NULL;
-  s_file_stat_t *dst = NULL;
-  s_file_stat_t *src = NULL;
+//  char* key;
+//  xbt_dict_cursor_t cursor = NULL;
+//  s_file_stat_t *dst = NULL;
+//  s_file_stat_t *src = NULL;
 
   xbt_fifo_foreach(action->simcalls,i,simcall,smx_simcall_t) {
     switch (simcall->call) {
@@ -305,27 +260,20 @@ void SIMIX_post_io(smx_action_t action)
       simcall_file_read__set__result(simcall, (action->io.surf_io)->cost);
       break;
 
-    case SIMCALL_FILE_STAT:
-      simcall_file_stat__set__result(simcall, 0);
-      dst = simcall_file_stat__get__buf(simcall);
-      src = &((action->io.surf_io)->stat);
-      file_stat_copy(src,dst);
-      break;
-
     case SIMCALL_FILE_UNLINK:
       xbt_free(simcall_file_unlink__get__fd(simcall));
       simcall_file_unlink__set__result(simcall, 0);
       break;
 
     case SIMCALL_FILE_LS:
-      xbt_dict_foreach((action->io.surf_io)->ls_dict,cursor,key, src){
-        // if there is a stat we have to duplicate it
-        if(src){
-          dst = xbt_new0(s_file_stat_t,1);
-          file_stat_copy(src, dst);
-          xbt_dict_set((action->io.surf_io)->ls_dict,key,dst,free_file_stat);
-        }
-      }
+//      xbt_dict_foreach((action->io.surf_io)->ls_dict,cursor,key, src){
+//        // if there is a stat we have to duplicate it
+//        if(src){
+//          dst = xbt_new0(s_file_stat_t,1);
+//          file_stat_copy(src, dst);
+//          xbt_dict_set((action->io.surf_io)->ls_dict,key,dst,xbt_free);
+//        }
+//      }
       simcall_file_ls__set__result(simcall, (action->io.surf_io)->ls_dict);
       break;
 
index c158322..92a04e3 100644 (file)
@@ -17,7 +17,6 @@ void SIMIX_pre_file_write(smx_simcall_t simcall, const void *ptr, size_t size,
 void SIMIX_pre_file_open(smx_simcall_t simcall, const char* mount,
                         const char* path, const char* mode);
 void SIMIX_pre_file_close(smx_simcall_t simcall, smx_file_t fp);
-void SIMIX_pre_file_stat(smx_simcall_t simcall, smx_file_t fd, s_file_stat_t *buf);
 void SIMIX_pre_file_unlink(smx_simcall_t simcall, smx_file_t fd);
 void SIMIX_pre_file_ls(smx_simcall_t simcall,
                        const char* mount, const char* path);
@@ -26,7 +25,6 @@ smx_action_t SIMIX_file_read(smx_process_t process, void* ptr, size_t size, size
 smx_action_t SIMIX_file_write(smx_process_t process, const void* ptr, size_t size, size_t nmemb, smx_file_t stream);
 smx_action_t SIMIX_file_open(smx_process_t process, const char* storage, const char* path, const char* mode);
 smx_action_t SIMIX_file_close(smx_process_t process, smx_file_t fp);
-smx_action_t SIMIX_file_stat(smx_process_t process, smx_file_t fd, s_file_stat_t buf);
 smx_action_t SIMIX_file_unlink(smx_process_t process, smx_file_t fd);
 smx_action_t SIMIX_file_ls(smx_process_t process, const char *mount, const char *path);
 
index c55fa36..3a77d74 100644 (file)
@@ -343,7 +343,6 @@ ACTION(SIMCALL_FILE_READ, file_read, WITHOUT_ANSWER, TDOUBLE(result), TPTR(ptr),
 ACTION(SIMCALL_FILE_WRITE, file_write, WITHOUT_ANSWER, TSIZE(result), TCPTR(ptr), TSIZE(size), TSIZE(nmemb), TSPEC(stream, smx_file_t)) sep \
 ACTION(SIMCALL_FILE_OPEN, file_open, WITHOUT_ANSWER, TSPEC(result, smx_file_t), TSTRING(mount), TSTRING(path), TSTRING(mode)) sep \
 ACTION(SIMCALL_FILE_CLOSE, file_close, WITHOUT_ANSWER, TINT(result), TSPEC(fp, smx_file_t)) sep \
-ACTION(SIMCALL_FILE_STAT, file_stat, WITHOUT_ANSWER, TINT(result), TSPEC(fd, smx_file_t), TSPEC(buf, s_file_stat_t*)) sep \
 ACTION(SIMCALL_FILE_UNLINK, file_unlink, WITHOUT_ANSWER, TINT(result), TSPEC(fd, smx_file_t)) sep \
 ACTION(SIMCALL_FILE_LS, file_ls, WITHOUT_ANSWER, TSPEC(result, xbt_dict_t), TSTRING(mount), TSTRING(path)) sep \
 ACTION(SIMCALL_ASR_GET_PROPERTIES, asr_get_properties, WITH_ANSWER, TSPEC(result, xbt_dict_t), TSTRING(name)) sep 
index a23e346..918687c 100644 (file)
@@ -1127,15 +1127,6 @@ int simcall_file_close(smx_file_t fp)
  * \ingroup simix_file_management
  *
  */
-int simcall_file_stat(smx_file_t fd, s_file_stat_t *buf)
-{
-  return simcall_BODY_file_stat(fd, buf);
-}
-
-/**
- * \ingroup simix_file_management
- *
- */
 int simcall_file_unlink(smx_file_t fd)
 {
   return simcall_BODY_file_unlink(fd);
index 9de73f7..2449e3c 100644 (file)
@@ -39,15 +39,6 @@ static xbt_dict_t parse_storage_content(char *filename, unsigned long *used_size
 static int storage_action_unref(surf_action_t action);
 static void storage_action_state_set(surf_action_t action, e_surf_action_state_t state);
 static surf_action_t storage_action_execute (void *storage, double size, e_surf_action_storage_type_t type);
-static void free_storage_content(void *p);
-
-static surf_action_t storage_action_stat(void *storage, surf_file_t stream)
-{
-  surf_action_t action = storage_action_execute(storage,0, STAT);
-  action->file = stream;
-  action->stat = stream->content->stat;
-  return action;
-}
 
 static surf_action_t storage_action_ls(void *storage, const char* path)
 {
@@ -56,14 +47,14 @@ static surf_action_t storage_action_ls(void *storage, const char* path)
   xbt_dict_t ls_dict = xbt_dict_new();
 
   char* key;
-  surf_stat_t data = NULL;
+  unsigned long size = 0;
   xbt_dict_cursor_t cursor = NULL;
 
   xbt_dynar_t dyn = NULL;
   char* file = NULL;
 
-  // foreach file int the storage
-  xbt_dict_foreach(((storage_t)storage)->content,cursor,key,data){
+  // for each file in the storage content
+  xbt_dict_foreach(((storage_t)storage)->content,cursor,key,size){
     // Search if file start with the prefix 'path'
     if(xbt_str_start_with(key,path)){
       file = &key[strlen(path)];
@@ -74,12 +65,12 @@ static surf_action_t storage_action_ls(void *storage, const char* path)
 
       // file
       if(xbt_dynar_length(dyn) == 1){
-        xbt_dict_set(ls_dict,file,&(data->stat),NULL);
+        xbt_dict_set(ls_dict,file,&size,NULL);
       }
       // Directory
       else
       {
-        // if directory does not exist yet in dict
+        // if directory does not exist yet in the dictionary
         if(!xbt_dict_get_or_null(ls_dict,file))
           xbt_dict_set(ls_dict,file,NULL,NULL);
       }
@@ -96,7 +87,7 @@ static surf_action_t storage_action_unlink(void *storage, surf_file_t stream)
   surf_action_t action = storage_action_execute(storage,0, UNLINK);
 
   // Add memory to storage
-  ((storage_t)storage)->used_size -= stream->content->stat.size;
+  ((storage_t)storage)->used_size -= stream->size;
 
   // Remove the file from storage
   xbt_dict_t content_dict = ((storage_t)storage)->content;
@@ -112,23 +103,15 @@ static surf_action_t storage_action_open(void *storage, const char* mount, const
 {
   XBT_DEBUG("\tOpen file '%s'",path);
   xbt_dict_t content_dict = ((storage_t)storage)->content;
-  surf_stat_t content = xbt_dict_get_or_null(content_dict,path);
-
+  unsigned long size = (unsigned long) xbt_dict_get_or_null(content_dict,path);
   // if file does not exist create an empty file
-  if(!content){
-    content = xbt_new0(s_surf_stat_t,1);
-    content->stat.date = xbt_strdup("");
-    content->stat.group = xbt_strdup("");
-    content->stat.size = 0;
-    content->stat.time = xbt_strdup("");
-    content->stat.user = xbt_strdup("");
-    content->stat.user_rights = xbt_strdup("");
-    xbt_dict_set(content_dict,path,content,NULL);
+  if(!size){
+    xbt_dict_set(content_dict,path,&size,NULL);
     XBT_DEBUG("File '%s' was not found, file created.",path);
   }
   surf_file_t file = xbt_new0(s_surf_file_t,1);
   file->name = xbt_strdup(path);
-  file->content = content;
+  file->size = size;
   file->storage = mount;
 
   surf_action_t action = storage_action_execute(storage,0, OPEN);
@@ -139,7 +122,7 @@ static surf_action_t storage_action_open(void *storage, const char* mount, const
 static surf_action_t storage_action_close(void *storage, surf_file_t fp)
 {
   char *filename = fp->name;
-  XBT_DEBUG("\tClose file '%s' size '%f'",filename,fp->content->stat.size);
+  XBT_DEBUG("\tClose file '%s' size '%zu'",filename,fp->size);
   // unref write actions from storage
   surf_action_storage_t write_action;
   unsigned int i;
@@ -158,9 +141,8 @@ static surf_action_t storage_action_close(void *storage, surf_file_t fp)
 
 static surf_action_t storage_action_read(void *storage, void* ptr, double size, size_t nmemb, surf_file_t stream)
 {
-  surf_stat_t content = stream->content;
-  if(size > content->stat.size)
-    size = content->stat.size;
+  if(size > stream->size)
+    size = stream->size;
   surf_action_t action = storage_action_execute(storage,size,READ);
   return action;
 }
@@ -168,8 +150,7 @@ static surf_action_t storage_action_read(void *storage, void* ptr, double size,
 static surf_action_t storage_action_write(void *storage, const void* ptr, size_t size, size_t nmemb, surf_file_t stream)
 {
   char *filename = stream->name;
-  surf_stat_t content = stream->content;
-  XBT_DEBUG("\tWrite file '%s' size '%zu/%f'",filename,size,content->stat.size);
+  XBT_DEBUG("\tWrite file '%s' size '%zu/%zu'",filename,size,stream->size);
 
   surf_action_t action = storage_action_execute(storage,size,WRITE);
   action->file = stream;
@@ -186,7 +167,7 @@ static surf_action_t storage_action_execute (void *storage, double size, e_surf_
   surf_action_storage_t action = NULL;
   storage_t STORAGE = storage;
 
-  XBT_IN("(%s,%f)", surf_resource_name(STORAGE), size);
+  XBT_IN("(%s,%f", surf_resource_name(STORAGE), size);
   action =
       surf_action_new(sizeof(s_surf_action_storage_t), size, surf_storage_model,
           STORAGE->state_current != SURF_RESOURCE_ON);
@@ -290,13 +271,13 @@ static void storage_update_actions_state(double now, double delta)
 
   // Update the disk usage
   // Update the file size
-  // Foreach action of type write
+  // For each action of type write
   xbt_swag_foreach_safe(action, next_action, running_actions) {
     if(action->type == WRITE)
     {
       double rate = lmm_variable_getvalue(GENERIC_LMM_ACTION(action).variable);
       ((storage_t)(action->storage))->used_size += delta * rate; // disk usage
-      ((surf_action_t)action)->file->content->stat.size += delta * rate; // file size
+      ((surf_action_t)action)->file->size += delta * rate; // file size
     }
   }
 
@@ -512,7 +493,6 @@ static void surf_storage_model_init_internal(void)
   surf_storage_model->extension.storage.close = storage_action_close;
   surf_storage_model->extension.storage.read = storage_action_read;
   surf_storage_model->extension.storage.write = storage_action_write;
-  surf_storage_model->extension.storage.stat = storage_action_stat;
   surf_storage_model->extension.storage.unlink = storage_action_unlink;
   surf_storage_model->extension.storage.ls = storage_action_ls;
 
@@ -552,24 +532,13 @@ static void storage_parse_storage(sg_platf_storage_cbarg_t storage)
       (void *) xbt_strdup(storage->type_id));
 }
 
-static void free_storage_content(void *p)
-{
-  surf_stat_t content = p;
-  free(content->stat.date);
-  free(content->stat.group);
-  free(content->stat.time);
-  free(content->stat.user);
-  free(content->stat.user_rights);
-  free(content);
-}
-
 static xbt_dict_t parse_storage_content(char *filename, unsigned long *used_size)
 {
   *used_size = 0;
   if ((!filename) || (strcmp(filename, "") == 0))
     return NULL;
 
-  xbt_dict_t parse_content = xbt_dict_new_homogeneous(free_storage_content);
+  xbt_dict_t parse_content = xbt_dict_new_homogeneous(NULL);
   FILE *file = NULL;
 
   file = surf_fopen(filename, "r");
@@ -579,33 +548,17 @@ static xbt_dict_t parse_storage_content(char *filename, unsigned long *used_size
   char *line = NULL;
   size_t len = 0;
   ssize_t read;
-  char user_rights[12];
-  char user[100];
-  char group[100];
-  char date[12];
-  char time[12];
   char path[1024];
-  int nb;
   unsigned long size;
 
-  surf_stat_t content;
 
   while ((read = xbt_getline(&line, &len, file)) != -1) {
     if (read){
-    content = xbt_new0(s_surf_stat_t,1);
-    if(sscanf(line,"%s %d %s %s %ld %s %s %s",user_rights,&nb,user,group,&size,date,time,path)==8) {
-        content->stat.date = xbt_strdup(date);
-        content->stat.group = xbt_strdup(group);
-        content->stat.size = size;
-        content->stat.time = xbt_strdup(time);
-        content->stat.user = xbt_strdup(user);
-        content->stat.user_rights = xbt_strdup(user_rights);
-        *used_size += content->stat.size;
-        xbt_dict_set(parse_content,path,content,NULL);
+    if(sscanf(line,"%s %ld",path, &size)==2) {
+        *used_size += size;
+        xbt_dict_set(parse_content,path,(void*) size,NULL);
       } else {
         xbt_die("Be sure of passing a good format for content file.\n");
-        // You can generate this kind of file with command line:
-        // find /path/you/want -type f -exec ls -l {} \; 2>/dev/null > ./content.txt
       }
     }
   }
index bc02af1..1fc8621 100644 (file)
@@ -23,7 +23,7 @@ typedef struct s_mount {
 typedef struct surf_file {
   char *name;
   const char* storage;
-  double size;
+  size_t size;
 } s_surf_file_t;
 
 typedef struct storage {
@@ -32,7 +32,7 @@ typedef struct storage {
   lmm_constraint_t constraint;          /* Constraint for maximum bandwidth from connection */
   lmm_constraint_t constraint_write;    /* Constraint for maximum write bandwidth*/
   lmm_constraint_t constraint_read;     /* Constraint for maximum write bandwidth*/
-  xbt_dict_t content; /* char * -> s_surf_stat_t */
+  xbt_dict_t content; /* char * -> s_surf_file_t */
   unsigned long size;
   unsigned long used_size;
   xbt_dynar_t write_actions;