src/surf/storage_interface.cpp

   1 /* Copyright (c) 2013-2017. 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 "storage_interface.hpp"
   8 #include "surf_private.h"
   9 #include "xbt/file.h" /* xbt_getline */
  10 #include <boost/algorithm/string.hpp>
  11 #include <boost/algorithm/string/join.hpp>
  12 #include <boost/algorithm/string/split.hpp>
  13 #include <fstream>
  14
  15 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_storage, surf, "Logging specific to the SURF storage module");
  16
  17 xbt_lib_t storage_lib;
  18 int MSG_STORAGE_LEVEL          = -1; // Msg storage level
  19 int ROUTING_STORAGE_LEVEL      = -1; // Routing for storage level
  20 int SURF_STORAGE_LEVEL = -1;
  21 simgrid::surf::StorageModel *surf_storage_model = nullptr;
  22
  23 namespace simgrid {
  24 namespace surf {
  25
  26 /*************
  27  * Callbacks *
  28  *************/
  29
  30 simgrid::xbt::signal<void(Storage*)> storageCreatedCallbacks;
  31 simgrid::xbt::signal<void(Storage*)> storageDestructedCallbacks;
  32 simgrid::xbt::signal<void(Storage*, int, int)> storageStateChangedCallbacks; // signature: wasOn, isOn
  33 simgrid::xbt::signal<void(StorageAction*, Action::State, Action::State)> storageActionStateChangedCallbacks;
  34
  35 /*********
  36  * Model *
  37  *********/
  38
  39 StorageModel::StorageModel(): Model()
  40 {
  41   maxminSystem_ = lmm_system_new(true /* lazy update */);
  42 }
  43
  44 StorageModel::~StorageModel(){
  45   lmm_system_free(maxminSystem_);
  46   surf_storage_model = nullptr;
  47 }
  48
  49 /************
  50  * Resource *
  51  ************/
  52
  53 Storage::Storage(Model* model, const char* name, lmm_system_t maxminSystem, double bread, double bwrite,
  54                  double bconnection, const char* type_id, const char* content_name, const char* content_type,
  55                  sg_size_t size, const char* attach)
  56     : Resource(model, name, lmm_constraint_new(maxminSystem, this, bconnection))
  57     , contentType_(xbt_strdup(content_type))
  58     , size_(size)
  59     , usedSize_(0)
  60     , typeId_(xbt_strdup(type_id))
  61     , writeActions_(std::vector<StorageAction*>())
  62 {
  63   content_ = parseContent(content_name);
  64   attach_  = xbt_strdup(attach);
  65   turnOn();
  66   XBT_DEBUG("Create resource with Bconnection '%f' Bread '%f' Bwrite '%f' and Size '%llu'", bconnection, bread, bwrite, size);
  67   constraintRead_  = lmm_constraint_new(maxminSystem, this, bread);
  68   constraintWrite_ = lmm_constraint_new(maxminSystem, this, bwrite);
  69 }
  70
  71 Storage::~Storage(){
  72   storageDestructedCallbacks(this);
  73   if (content_ != nullptr) {
  74     for (auto entry : *content_)
  75       delete entry.second;
  76     delete content_;
  77   }
  78   free(typeId_);
  79   free(contentType_);
  80   free(attach_);
  81 }
  82
  83 std::map<std::string, sg_size_t*>* Storage::parseContent(const char* filename)
  84 {
  85   usedSize_ = 0;
  86   if ((!filename) || (strcmp(filename, "") == 0))
  87     return nullptr;
  88
  89   std::map<std::string, sg_size_t*>* parse_content = new std::map<std::string, sg_size_t*>();
  90
  91   std::ifstream* fs = surf_ifsopen(filename);
  92
  93   std::string line;
  94   std::vector<std::string> tokens;
  95   do {
  96     std::getline(*fs, line);
  97     boost::trim(line);
  98     if (line.length() > 0) {
  99       boost::split(tokens, line, boost::is_any_of(" \t"), boost::token_compress_on);
 100       xbt_assert(tokens.size() == 2, "Parse error in %s: %s", filename, line.c_str());
 101       sg_size_t size = std::stoull(tokens.at(1));
 102
 103       usedSize_ += size;
 104       sg_size_t* psize = new sg_size_t;
 105       *psize = size;
 106       parse_content->insert({tokens.front(), psize});
 107     }
 108   } while (!fs->eof());
 109   delete fs;
 110   return parse_content;
 111 }
 112
 113 bool Storage::isUsed()
 114 {
 115   THROW_UNIMPLEMENTED;
 116   return false;
 117 }
 118
 119 void Storage::apply_event(tmgr_trace_event_t /*event*/, double /*value*/)
 120 {
 121   THROW_UNIMPLEMENTED;
 122 }
 123
 124 void Storage::turnOn() {
 125   if (isOff()) {
 126     Resource::turnOn();
 127     storageStateChangedCallbacks(this, 0, 1);
 128   }
 129 }
 130 void Storage::turnOff() {
 131   if (isOn()) {
 132     Resource::turnOff();
 133     storageStateChangedCallbacks(this, 1, 0);
 134   }
 135 }
 136
 137 std::map<std::string, sg_size_t*>* Storage::getContent()
 138 {
 139   /* For the moment this action has no cost, but in the future we could take in account access latency of the disk */
 140   return content_;
 141 }
 142
 143 sg_size_t Storage::getFreeSize(){
 144   return size_ - usedSize_;
 145 }
 146
 147 sg_size_t Storage::getUsedSize(){
 148   return usedSize_;
 149 }
 150
 151 /**********
 152  * Action *
 153  **********/
 154 StorageAction::StorageAction(Model* model, double cost, bool failed, Storage* storage,
 155                              e_surf_action_storage_type_t type)
 156     : Action(model, cost, failed), type_(type), storage_(storage), file_(nullptr)
 157 {
 158   progress_ = 0;
 159 };
 160
 161 StorageAction::StorageAction(Model* model, double cost, bool failed, lmm_variable_t var, Storage* storage,
 162                              e_surf_action_storage_type_t type)
 163     : Action(model, cost, failed, var), type_(type), storage_(storage), file_(nullptr)
 164 {
 165   progress_ = 0;
 166 }
 167
 168 void StorageAction::setState(Action::State state){
 169   Action::State old = getState();
 170   Action::setState(state);
 171   storageActionStateChangedCallbacks(this, old, state);
 172 }
 173
 174 }
 175 }