src/surf/storage_interface.hpp

   1 /* Copyright (c) 2004-2015. The SimGrid Team.
   2  * All rights reserved.                                                     */
   3
   4 /* This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the license (GNU LGPL) which comes with this package. */
   6
   7 #include <xbt/base.h>
   8 #include <xbt/signal.hpp>
   9
  10 #include "surf_interface.hpp"
  11 #include "src/surf/PropertyHolder.hpp"
  12
  13 #ifndef STORAGE_INTERFACE_HPP_
  14 #define STORAGE_INTERFACE_HPP_
  15
  16 namespace simgrid {
  17 namespace surf {
  18
  19 /***********
  20  * Classes *
  21  ***********/
  22
  23 class StorageModel;
  24 class Storage;
  25 class StorageAction;
  26
  27 /*************
  28  * Callbacks *
  29  *************/
  30
  31 /** @ingroup SURF_callbacks
  32  * @brief Callbacks handler which emit the callbacks after Storage creation *
  33  * @details Callback functions have the following signature: `void(Storage*)`
  34  */
  35 XBT_PUBLIC_DATA(simgrid::xbt::signal<void(simgrid::surf::Storage*)>) storageCreatedCallbacks;
  36
  37 /** @ingroup SURF_callbacks
  38  * @brief Callbacks handler which emit the callbacks after Storage destruction *
  39  * @details Callback functions have the following signature: `void(StoragePtr)`
  40  */
  41 XBT_PUBLIC_DATA(simgrid::xbt::signal<void(simgrid::surf::Storage*)>) storageDestructedCallbacks;
  42
  43 /** @ingroup SURF_callbacks
  44  * @brief Callbacks handler which emit the callbacks after Storage State changed *
  45  * @details Callback functions have the following signature: `void(StorageAction *action, int previouslyOn, int currentlyOn)`
  46  */
  47 XBT_PUBLIC_DATA(simgrid::xbt::signal<void(simgrid::surf::Storage*, int, int)>) storageStateChangedCallbacks;
  48
  49 /** @ingroup SURF_callbacks
  50  * @brief Callbacks handler which emit the callbacks after StorageAction State changed *
  51  * @details Callback functions have the following signature: `void(StorageAction *action, simgrid::surf::Action::State old, simgrid::surf::Action::State current)`
  52  */
  53 XBT_PUBLIC_DATA(simgrid::xbt::signal<void(simgrid::surf::StorageAction*, simgrid::surf::Action::State, simgrid::surf::Action::State)>) storageActionStateChangedCallbacks;
  54
  55 /*********
  56  * Model *
  57  *********/
  58 /** @ingroup SURF_storage_interface
  59  * @brief SURF storage model interface class
  60  * @details A model is an object which handle the interactions between its Resources and its Actions
  61  */
  62 class StorageModel : public Model {
  63 public:
  64   StorageModel();
  65   ~StorageModel();
  66
  67   virtual Storage* createStorage(const char* id, const char* type_id, const char* content_name,
  68                                  const char* content_type, const char* attach) = 0;
  69
  70   std::vector<Storage*> p_storageList;
  71 };
  72
  73 /************
  74  * Resource *
  75  ************/
  76 /** @ingroup SURF_storage_interface
  77  * @brief SURF storage interface class
  78  * @details A Storage represent a storage unit (e.g.: hard drive, usb key)
  79  */
  80 class Storage : public simgrid::surf::Resource,
  81         public simgrid::surf::PropertyHolder {
  82 public:
  83
  84   /**
  85    * @brief Storage constructor
  86    *
  87    * @param model StorageModel associated to this Storage
  88    * @param name The name of the Storage
  89    * @param props Dictionary of properties associated to this Storage
  90    */
  91   Storage(Model* model, const char* name, lmm_system_t maxminSystem, double bread, double bwrite, double bconnection,
  92           const char* type_id, const char* content_name, const char* content_type, sg_size_t size, const char* attach);
  93
  94   ~Storage();
  95
  96   /** @brief Check if the Storage is used (if an action currently uses its resources) */
  97   bool isUsed() override;
  98
  99   void apply_event(tmgr_trace_iterator_t event, double value) override;
 100
 101   void turnOn() override;
 102   void turnOff() override;
 103
 104   xbt_dict_t content_;
 105   char* contentType_;
 106   sg_size_t size_;
 107   sg_size_t usedSize_;
 108   char * typeId_;
 109   char* attach_; //FIXME: this is the name of the host. Use the host directly
 110
 111   /**
 112    * @brief Open a file
 113    *
 114    * @param mount The mount point
 115    * @param path The path to the file
 116    *
 117    * @return The StorageAction corresponding to the opening
 118    */
 119   virtual StorageAction *open(const char* mount, const char* path)=0;
 120
 121   /**
 122    * @brief Close a file
 123    *
 124    * @param fd The file descriptor to close
 125    * @return The StorageAction corresponding to the closing
 126    */
 127   virtual StorageAction *close(surf_file_t fd)=0;
 128
 129   /**
 130    * @brief Read a file
 131    *
 132    * @param fd The file descriptor to read
 133    * @param size The size in bytes to read
 134    * @return The StorageAction corresponding to the reading
 135    */
 136   virtual StorageAction *read(surf_file_t fd, sg_size_t size)=0;
 137
 138   /**
 139    * @brief Write a file
 140    *
 141    * @param fd The file descriptor to write
 142    * @param size The size in bytes to write
 143    * @return The StorageAction corresponding to the writing
 144    */
 145   virtual StorageAction *write(surf_file_t fd, sg_size_t size)=0;
 146
 147   /**
 148    * @brief Get the content of the current Storage
 149    *
 150    * @return A xbt_dict_t with path as keys and size in bytes as values
 151    */
 152   virtual xbt_dict_t getContent();
 153
 154   /**
 155    * @brief Get the size in bytes of the current Storage
 156    *
 157    * @return The size in bytes of the current Storage
 158    */
 159   virtual sg_size_t getSize();
 160
 161   /**
 162    * @brief Get the available size in bytes of the current Storage
 163    *
 164    * @return The available size in bytes of the current Storage
 165    */
 166   virtual sg_size_t getFreeSize();
 167
 168   /**
 169    * @brief Get the used size in bytes of the current Storage
 170    *
 171    * @return The used size in bytes of the current Storage
 172    */
 173   virtual sg_size_t getUsedSize();
 174
 175
 176   xbt_dict_t parseContent(const char *filename);
 177
 178   std::vector<StorageAction*> writeActions_;
 179
 180   lmm_constraint_t constraintWrite_;    /* Constraint for maximum write bandwidth*/
 181   lmm_constraint_t constraintRead_;     /* Constraint for maximum write bandwidth*/
 182 };
 183
 184 /**********
 185  * Action *
 186  **********/
 187
 188 /** @ingroup SURF_storage_interface
 189  * @brief The possible type of action for the storage component
 190  */
 191 typedef enum {
 192   READ=0, /**< Read a file */
 193   WRITE,  /**< Write in a file */
 194   STAT,   /**< Stat a file */
 195   OPEN,   /**< Open a file */
 196   CLOSE  /**< Close a file */
 197 } e_surf_action_storage_type_t;
 198
 199 /** @ingroup SURF_storage_interface
 200  * @brief SURF storage action interface class
 201  */
 202 class StorageAction : public Action {
 203 public:
 204   /**
 205    * @brief StorageAction constructor
 206    *
 207    * @param model The StorageModel associated to this StorageAction
 208    * @param cost The cost of this  NetworkAction in [TODO]
 209    * @param failed [description]
 210    * @param storage The Storage associated to this StorageAction
 211    * @param type [description]
 212    */
 213   StorageAction(Model *model, double cost, bool failed, Storage *storage,
 214       e_surf_action_storage_type_t type);
 215
 216     /**
 217    * @brief StorageAction constructor
 218    *
 219    * @param model The StorageModel associated to this StorageAction
 220    * @param cost The cost of this  StorageAction in [TODO]
 221    * @param failed [description]
 222    * @param var The lmm variable associated to this StorageAction if it is part of a LMM component
 223    * @param storage The Storage associated to this StorageAction
 224    * @param type [description]
 225    */
 226   StorageAction(Model *model, double cost, bool failed, lmm_variable_t var,
 227       Storage *storage, e_surf_action_storage_type_t type);
 228
 229   void setState(simgrid::surf::Action::State state) override;
 230
 231   e_surf_action_storage_type_t type_;
 232   Storage* storage_;
 233   surf_file_t file_;
 234   double progress_;
 235 };
 236
 237 }
 238 }
 239
 240 typedef struct s_storage_type {
 241   char *model;
 242   char *content;
 243   char *content_type;
 244   char *type_id;
 245   xbt_dict_t properties;
 246   xbt_dict_t model_properties;
 247   sg_size_t size;
 248 } s_storage_type_t, *storage_type_t;
 249
 250 typedef struct s_mount {
 251   void *storage;
 252   char *name;
 253 } s_mount_t, *mount_t;
 254
 255 typedef struct surf_file {
 256   char *name;
 257   char *mount;
 258   sg_size_t size;
 259   sg_size_t current_position;
 260 } s_surf_file_t;
 261
 262 #endif /* STORAGE_INTERFACE_HPP_ */