X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/53a14aeab09f8bcb214091691ef23b736e68e945..a246b2d82b1adcd5f8fbaa5791b660d331d7209a:/src/surf/storage.c diff --git a/src/surf/storage.c b/src/surf/storage.c index aa0f3eb37c..447c3c6ffa 100644 --- a/src/surf/storage.c +++ b/src/surf/storage.c @@ -1,8 +1,8 @@ -/* Copyright (c) 2004 - 2013. The SimGrid Team. - * All rights reserved. */ +/* Copyright (c) 2004-2013. The SimGrid Team. + * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it - * under the terms of the license (GNU LGPL) which comes with this package. */ + * under the terms of the license (GNU LGPL) which comes with this package. */ #include "xbt/ex.h" #include "xbt/dict.h" @@ -10,6 +10,7 @@ #include "surf_private.h" #include "storage_private.h" #include "surf/surf_resource.h" +#include XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_storage, surf, "Logging specific to the SURF storage module"); @@ -34,19 +35,19 @@ static xbt_dynar_t storage_list; #define GENERIC_LMM_ACTION(action) action->generic_lmm_action #define GENERIC_ACTION(action) GENERIC_LMM_ACTION(action).generic_action -static xbt_dict_t parse_storage_content(char *filename, size_t *used_size); +static xbt_dict_t parse_storage_content(char *filename, sg_storage_size_t *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, size_t size, e_surf_action_storage_type_t type); +static surf_action_t storage_action_execute (void *storage, sg_storage_size_t size, e_surf_action_storage_type_t type); static surf_action_t storage_action_ls(void *storage, const char* path) { surf_action_t action = storage_action_execute(storage,0, LS); action->ls_dict = NULL; - xbt_dict_t ls_dict = xbt_dict_new(); + xbt_dict_t ls_dict = xbt_dict_new_homogeneous(xbt_free); char* key; - size_t size = 0; + sg_storage_size_t size = 0; xbt_dict_cursor_t cursor = NULL; xbt_dynar_t dyn = NULL; @@ -64,7 +65,9 @@ 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,&size,NULL); + sg_storage_size_t *psize = xbt_new(sg_storage_size_t,1); + *psize=size; + xbt_dict_set(ls_dict,file,psize,NULL); } // Directory else @@ -86,10 +89,16 @@ static surf_action_t storage_action_open(void *storage, const char* mount, { XBT_DEBUG("\tOpen file '%s'",path); xbt_dict_t content_dict = ((storage_t)storage)->content; - size_t size = (size_t) xbt_dict_get_or_null(content_dict,path); + sg_storage_size_t size, *psize; + psize = (sg_storage_size_t*) xbt_dict_get_or_null(content_dict, path); + if (psize) + size = *psize; + else { // if file does not exist create an empty file - if(!size){ - xbt_dict_set(content_dict,path,&size,NULL); + psize = xbt_new(sg_storage_size_t,1); + size = 0; + *psize = size; + xbt_dict_set(content_dict,path,psize,NULL); XBT_DEBUG("File '%s' was not found, file created.",path); } surf_file_t file = xbt_new0(s_surf_file_t,1); @@ -105,7 +114,7 @@ static surf_action_t storage_action_open(void *storage, const char* mount, static surf_action_t storage_action_close(void *storage, surf_file_t fd) { char *filename = fd->name; - XBT_DEBUG("\tClose file '%s' size '%zu'",filename,fd->size); + XBT_DEBUG("\tClose file '%s' size '%" PRIu64 "'", filename, fd->size); // unref write actions from storage surf_action_storage_t write_action; unsigned int i; @@ -115,7 +124,6 @@ static surf_action_t storage_action_close(void *storage, surf_file_t fd) storage_action_unref((surf_action_t) write_action); } } - free(fd->name); free(fd->mount); xbt_free(fd); @@ -123,8 +131,7 @@ static surf_action_t storage_action_close(void *storage, surf_file_t fd) return action; } -static surf_action_t storage_action_read(void *storage, size_t size, - surf_file_t fd) +static surf_action_t storage_action_read(void *storage, surf_file_t fd, sg_storage_size_t size) { if(size > fd->size) size = fd->size; @@ -132,11 +139,11 @@ static surf_action_t storage_action_read(void *storage, size_t size, return action; } -static surf_action_t storage_action_write(void *storage, size_t size, - surf_file_t fd) +static surf_action_t storage_action_write(void *storage, surf_file_t fd, sg_storage_size_t size) { char *filename = fd->name; - XBT_DEBUG("\tWrite file '%s' size '%zu/%zu'",filename,size,fd->size); + XBT_DEBUG("\tWrite file '%s' size '%" PRIu64 "/%" PRIu64 "'", + filename, size, fd->size); surf_action_t action = storage_action_execute(storage,size,WRITE); action->file = fd; @@ -148,12 +155,12 @@ static surf_action_t storage_action_write(void *storage, size_t size, return action; } -static surf_action_t storage_action_execute (void *storage, size_t size, e_surf_action_storage_type_t type) +static surf_action_t storage_action_execute (void *storage, sg_storage_size_t size, e_surf_action_storage_type_t type) { surf_action_storage_t action = NULL; storage_t STORAGE = storage; - XBT_IN("(%s,%zu", surf_resource_name(STORAGE), size); + XBT_IN("(%s,%" PRIu64, 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); @@ -192,17 +199,59 @@ static surf_action_t storage_action_execute (void *storage, size_t size, e_surf_ return (surf_action_t) action; } +static xbt_dict_t storage_get_properties(const void *storage) +{ + return surf_resource_properties(surf_storage_resource_priv(storage)); +} + +static xbt_dict_t storage_get_content(void *storage) +{ + /* For the moment this action has no cost, but in the future we could take in account access latency of the disk */ + /*surf_action_t action = storage_action_execute(storage,0, LS);*/ + + void *storage_resource = surf_storage_resource_priv(storage); + xbt_dict_t content_dict = xbt_dict_new_homogeneous(NULL); + xbt_dict_cursor_t cursor = NULL; + char *file; + sg_storage_size_t *psize; + + xbt_dict_foreach(((storage_t)storage_resource)->content, cursor, file, psize){ + xbt_dict_set(content_dict,file,psize,NULL); + } + return content_dict; +} + +static sg_storage_size_t storage_get_size(void *storage){ + void *storage_resource = surf_storage_resource_priv(storage); + return ((storage_t)storage_resource)->size; +} + +static void storage_file_rename(void *storage, const char *src, const char *dest) +{ + void *storage_resource = surf_storage_resource_priv(storage); + + sg_storage_size_t *psize; + psize = (sg_storage_size_t*) xbt_dict_get_or_null(((storage_t)storage_resource)->content,src); + if (psize){// src file exists + xbt_dict_remove(((storage_t)storage_resource)->content, src); + xbt_dict_set(((storage_t)storage_resource)->content, dest, psize,NULL); + XBT_DEBUG("Change file name from %s to %s, size '%" PRIu64 "'",src, dest, *psize); + } + else + XBT_DEBUG("File %s doesn't exist",src); +} + + static void* storage_create_resource(const char* id, const char* model, - const char* type_id, const char* content_name, const char* content_type){ + const char* type_id, const char* content_name, const char* content_type, xbt_dict_t properties){ storage_t storage = NULL; xbt_assert(!surf_storage_resource_priv(surf_storage_resource_by_name(id)), "Storage '%s' declared several times in the platform file", id); storage = (storage_t) surf_resource_new(sizeof(s_storage_t), - surf_storage_model, id,NULL); + surf_storage_model, id, properties, NULL); - storage->generic_resource.name = xbt_strdup(id); storage->state_current = SURF_RESOURCE_ON; storage->used_size = 0; storage->size = 0; @@ -262,22 +311,26 @@ static void storage_update_actions_state(double now, double delta) surf_action_storage_t next_action = NULL; xbt_swag_t running_actions = surf_storage_model->states.running_action_set; - // Update the disk usage - // Update the file size - // For each action of type write + xbt_swag_foreach_safe(action, next_action, running_actions) { if(action->type == WRITE) { + // Update the disk usage + // Update the file size + // Update the storage content (with file size) double rate = lmm_variable_getvalue(GENERIC_LMM_ACTION(action).variable); /* Hack to avoid rounding differences between x86 and x86_64 - * (note that the next sizes are of type size_t). */ + * (note that the next sizes are of type sg_storage_size_t). */ long incr = delta * rate + MAXMIN_PRECISION; ((storage_t)(action->storage))->used_size += incr; // disk usage ((surf_action_t)action)->file->size += incr; // file size - } - } - xbt_swag_foreach_safe(action, next_action, running_actions) { + sg_storage_size_t *psize = xbt_new(sg_storage_size_t,1); + *psize = ((surf_action_t)action)->file->size; + + xbt_dict_t content_dict = ((storage_t)(action->storage))->content; + xbt_dict_set(content_dict,((surf_action_t)action)->file->name,psize,NULL); + } double_update(&(GENERIC_ACTION(action).remains), lmm_variable_getvalue(GENERIC_LMM_ACTION(action).variable) * delta); @@ -439,7 +492,8 @@ static void parse_storage_init(sg_platf_storage_cbarg_t storage) ((storage_type_t) stype)->model, ((storage_type_t) stype)->type_id, storage->content, - storage->content_type); + storage->content_type, + storage->properties); } static void parse_mstorage_init(sg_platf_mstorage_cbarg_t mstorage) @@ -497,11 +551,13 @@ static void surf_storage_model_init_internal(void) surf_storage_model->extension.storage.read = storage_action_read; surf_storage_model->extension.storage.write = storage_action_write; surf_storage_model->extension.storage.ls = storage_action_ls; - + surf_storage_model->extension.storage.get_properties = storage_get_properties; + surf_storage_model->extension.storage.get_content = storage_get_content; + surf_storage_model->extension.storage.get_size = storage_get_size; + surf_storage_model->extension.storage.rename = storage_file_rename; if (!storage_maxmin_system) { storage_maxmin_system = lmm_system_new(storage_selective_update); } - } void surf_storage_model_init_default(void) @@ -534,13 +590,13 @@ static void storage_parse_storage(sg_platf_storage_cbarg_t storage) (void *) xbt_strdup(storage->type_id)); } -static xbt_dict_t parse_storage_content(char *filename, size_t *used_size) +static xbt_dict_t parse_storage_content(char *filename, sg_storage_size_t *used_size) { *used_size = 0; if ((!filename) || (strcmp(filename, "") == 0)) return NULL; - xbt_dict_t parse_content = xbt_dict_new_homogeneous(NULL); + xbt_dict_t parse_content = xbt_dict_new_homogeneous(xbt_free); FILE *file = NULL; file = surf_fopen(filename, "r"); @@ -551,14 +607,15 @@ static xbt_dict_t parse_storage_content(char *filename, size_t *used_size) size_t len = 0; ssize_t read; char path[1024]; - size_t size; - + sg_storage_size_t size; while ((read = xbt_getline(&line, &len, file)) != -1) { if (read){ - if(sscanf(line,"%s %zu",path, &size)==2) { + if (sscanf(line,"%s %" SCNu64, path, &size) == 2) { *used_size += size; - xbt_dict_set(parse_content,path,(void*) size,NULL); + sg_storage_size_t *psize = xbt_new(sg_storage_size_t, 1); + *psize = size; + xbt_dict_set(parse_content,path,psize,NULL); } else { xbt_die("Be sure of passing a good format for content file.\n"); } @@ -681,3 +738,4 @@ void storage_register_callbacks() { sg_platf_storage_type_add_cb(storage_parse_storage_type); sg_platf_mount_add_cb(storage_parse_mount); } +