Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
sed -i -e 's/\t/ /g' [sources] Please people, stop using tabs
[simgrid.git] / src / surf / storage_n11.cpp
1 /* Copyright (c) 2013-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 "storage_n11.hpp"
8 #include "surf_private.h"
9 #include <math.h> /*ceil*/
10 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(surf_storage);
11
12 static int storage_selective_update = 0;
13 static xbt_swag_t storage_running_action_set_that_does_not_need_being_checked = NULL;
14
15 /*************
16  * CallBacks *
17  *************/
18
19 static XBT_INLINE void routing_storage_type_free(void *r)
20 {
21   storage_type_t stype = (storage_type_t) r;
22   free(stype->model);
23   free(stype->type_id);
24   free(stype->content);
25   free(stype->content_type);
26   xbt_dict_free(&(stype->properties));
27   xbt_dict_free(&(stype->model_properties));
28   free(stype);
29 }
30
31 static XBT_INLINE void surf_storage_resource_free(void *r)
32 {
33   // specific to storage
34   simgrid::surf::Storage *storage = static_cast<simgrid::surf::Storage*>(r);
35   // generic resource
36   delete storage;
37 }
38
39 static XBT_INLINE void routing_storage_host_free(void *r)
40 {
41   xbt_dynar_t dyn = (xbt_dynar_t) r;
42   xbt_dynar_free(&dyn);
43 }
44
45 void storage_register_callbacks()
46 {
47   ROUTING_STORAGE_LEVEL = xbt_lib_add_level(storage_lib, xbt_free_f);
48   ROUTING_STORAGE_HOST_LEVEL = xbt_lib_add_level(storage_lib, routing_storage_host_free);
49   ROUTING_STORAGE_TYPE_LEVEL = xbt_lib_add_level(storage_type_lib, routing_storage_type_free);
50   SURF_STORAGE_LEVEL = xbt_lib_add_level(storage_lib, surf_storage_resource_free);
51 }
52
53 /*********
54  * Model *
55  *********/
56
57 void surf_storage_model_init_default(void)
58 {
59   surf_storage_model = new simgrid::surf::StorageN11Model();
60   xbt_dynar_push(all_existing_models, &surf_storage_model);
61 }
62
63 namespace simgrid {
64 namespace surf {
65
66 StorageN11Model::StorageN11Model() : StorageModel() {
67   Action *action = NULL;
68
69   XBT_DEBUG("surf_storage_model_init_internal");
70
71   storage_running_action_set_that_does_not_need_being_checked =
72       xbt_swag_new(xbt_swag_offset(*action, p_stateHookup));
73   if (!p_maxminSystem) {
74     p_maxminSystem = lmm_system_new(storage_selective_update);
75   }
76 }
77
78 StorageN11Model::~StorageN11Model(){
79   xbt_swag_free(storage_running_action_set_that_does_not_need_being_checked);
80   storage_running_action_set_that_does_not_need_being_checked = NULL;
81 }
82
83 Storage *StorageN11Model::createStorage(const char* id, const char* type_id,
84     const char* content_name, const char* content_type, xbt_dict_t properties,
85     const char* attach)
86 {
87
88   xbt_assert(!surf_storage_resource_priv(surf_storage_resource_by_name(id)),
89               "Storage '%s' declared several times in the platform file",
90               id);
91
92   storage_type_t storage_type = (storage_type_t) xbt_lib_get_or_null(storage_type_lib, type_id,ROUTING_STORAGE_TYPE_LEVEL);
93
94   double Bread  = surf_parse_get_bandwidth((char*)xbt_dict_get(storage_type->model_properties, "Bread"));
95   double Bwrite = surf_parse_get_bandwidth((char*)xbt_dict_get(storage_type->model_properties, "Bwrite"));
96   double Bconnection   = surf_parse_get_bandwidth((char*)xbt_dict_get(storage_type->model_properties, "Bconnection"));
97
98   Storage *storage = new StorageN11(this, id, properties, p_maxminSystem,
99       Bread, Bwrite, Bconnection, type_id, (char *)content_name,
100       xbt_strdup(content_type), storage_type->size, (char *) attach);
101   storageCreatedCallbacks(storage);
102   xbt_lib_set(storage_lib, id, SURF_STORAGE_LEVEL, storage);
103
104   XBT_DEBUG("SURF storage create resource\n\t\tid '%s'\n\t\ttype '%s'\n\t\tproperties '%p'\n\t\tBread '%f'\n",
105       id,
106       type_id,
107       properties,
108       Bread);
109
110   if(!p_storageList)
111     p_storageList = xbt_dynar_new(sizeof(char *),NULL);
112   xbt_dynar_push(p_storageList, &storage);
113
114   return storage;
115 }
116
117 double StorageN11Model::shareResources(double /*now*/)
118 {
119   XBT_DEBUG("storage_share_resources");
120   unsigned int i, j;
121   Storage *storage;
122   void *_write_action;
123   StorageAction *write_action;
124
125   double min_completion = shareResourcesMaxMin(getRunningActionSet(),
126       p_maxminSystem, lmm_solve);
127
128   double rate;
129   // Foreach disk
130   xbt_dynar_foreach(p_storageList,i,storage)
131   {
132     rate = 0;
133     // Foreach write action on disk
134     xbt_dynar_foreach(storage->p_writeActions, j, _write_action)
135     {
136       write_action = static_cast<StorageAction*>(_write_action);
137       rate += lmm_variable_getvalue(write_action->getVariable());
138     }
139     if(rate > 0)
140       min_completion = MIN(min_completion, (storage->m_size-storage->m_usedSize)/rate);
141   }
142
143   return min_completion;
144 }
145
146 void StorageN11Model::updateActionsState(double /*now*/, double delta)
147 {
148   StorageAction *action = NULL;
149
150   ActionList *actionSet = getRunningActionSet();
151   for(ActionList::iterator it(actionSet->begin()), itNext=it, itend(actionSet->end())
152      ; it != itend ; it=itNext) {
153     ++itNext;
154     action = static_cast<StorageAction*>(&*it);
155
156     if(action->m_type == WRITE)
157     {
158       // Update the disk usage
159       // Update the file size
160       // For each action of type write
161       volatile double current_progress =
162           delta * lmm_variable_getvalue(action->getVariable());
163       long int incr = current_progress;
164
165       XBT_DEBUG("%s:\n\t progress =  %.2f, current_progress = %.2f, "
166                 "incr = %ld, lrint(1) = %ld, lrint(2) = %ld",
167                 action->p_file->name,
168                 action->progress,  current_progress, incr,
169                 lrint(action->progress + current_progress),
170                 lrint(action->progress)+ incr);
171
172       /* take care of rounding error accumulation */
173       if (lrint(action->progress + current_progress) >
174           lrint(action->progress)+ incr)
175         incr++;
176
177       action->progress +=current_progress;
178
179       action->p_storage->m_usedSize += incr; // disk usage
180       action->p_file->current_position+= incr; // current_position
181       //  which becomes the new file size
182       action->p_file->size = action->p_file->current_position ;
183
184       sg_size_t *psize = xbt_new(sg_size_t,1);
185       *psize = action->p_file->size;
186       xbt_dict_t content_dict = action->p_storage->p_content;
187       xbt_dict_set(content_dict, action->p_file->name, psize, NULL);
188     }
189
190     action->updateRemains(lmm_variable_getvalue(action->getVariable()) * delta);
191
192     if (action->getMaxDuration() != NO_MAX_DURATION)
193       action->updateMaxDuration(delta);
194
195     if(action->getRemainsNoUpdate() > 0 &&
196         lmm_get_variable_weight(action->getVariable()) > 0 &&
197         action->p_storage->m_usedSize == action->p_storage->m_size)
198     {
199       action->finish();
200       action->setState(SURF_ACTION_FAILED);
201     } else if ((action->getRemainsNoUpdate() <= 0) &&
202         (lmm_get_variable_weight(action->getVariable()) > 0))
203     {
204       action->finish();
205       action->setState(SURF_ACTION_DONE);
206     } else if ((action->getMaxDuration() != NO_MAX_DURATION) &&
207                (action->getMaxDuration() <= 0))
208     {
209       action->finish();
210       action->setState(SURF_ACTION_DONE);
211     }
212   }
213   return;
214 }
215
216 /************
217  * Resource *
218  ************/
219
220 StorageN11::StorageN11(StorageModel *model, const char* name,
221     xbt_dict_t properties, lmm_system_t maxminSystem, double bread,
222     double bwrite, double bconnection, const char* type_id, char *content_name,
223     char *content_type, sg_size_t size, char *attach)
224  : Storage(model, name, properties,
225          maxminSystem, bread, bwrite, bconnection, type_id, content_name, content_type, size, attach) {
226   XBT_DEBUG("Create resource with Bconnection '%f' Bread '%f' Bwrite '%f' and Size '%llu'", bconnection, bread, bwrite, size);
227 }
228
229 StorageAction *StorageN11::open(const char* mount, const char* path)
230 {
231   XBT_DEBUG("\tOpen file '%s'",path);
232
233   sg_size_t size, *psize;
234   psize = (sg_size_t*) xbt_dict_get_or_null(p_content, path);
235   // if file does not exist create an empty file
236   if(psize)
237     size = *psize;
238   else {
239     psize = xbt_new(sg_size_t,1);
240     size = 0;
241     *psize = size;
242     xbt_dict_set(p_content, path, psize, NULL);
243     XBT_DEBUG("File '%s' was not found, file created.",path);
244   }
245   surf_file_t file = xbt_new0(s_surf_file_t,1);
246   file->name = xbt_strdup(path);
247   file->size = size;
248   file->mount = xbt_strdup(mount);
249   file->current_position = 0;
250
251   StorageAction *action = new StorageN11Action(getModel(), 0, isOff(), this, OPEN);
252   action->p_file = file;
253
254   return action;
255 }
256
257 StorageAction *StorageN11::close(surf_file_t fd)
258 {
259   char *filename = fd->name;
260   XBT_DEBUG("\tClose file '%s' size '%llu'", filename, fd->size);
261   // unref write actions from storage
262   void *_write_action;
263   StorageAction *write_action;
264   unsigned int i;
265   xbt_dynar_foreach(p_writeActions, i, _write_action) {
266   write_action = static_cast<StorageAction*>(_write_action);
267     if ((write_action->p_file) == fd) {
268       xbt_dynar_cursor_rm(p_writeActions, &i);
269       write_action->unref();
270     }
271   }
272   free(fd->name);
273   free(fd->mount);
274   xbt_free(fd);
275   StorageAction *action = new StorageN11Action(getModel(), 0, isOff(), this, CLOSE);
276   return action;
277 }
278
279 StorageAction *StorageN11::read(surf_file_t fd, sg_size_t size)
280 {
281   if(fd->current_position + size > fd->size){
282     if (fd->current_position > fd->size){
283       size = 0;
284     } else {
285       size = fd->size - fd->current_position;
286     }
287     fd->current_position = fd->size;
288   }
289   else
290     fd->current_position += size;
291
292   StorageAction *action = new StorageN11Action(getModel(), size, isOff(), this, READ);
293   return action;
294 }
295
296 StorageAction *StorageN11::write(surf_file_t fd, sg_size_t size)
297 {
298   char *filename = fd->name;
299   XBT_DEBUG("\tWrite file '%s' size '%llu/%llu'",filename,size,fd->size);
300
301   StorageAction *action = new StorageN11Action(getModel(), size, isOff(), this, WRITE);
302   action->p_file = fd;
303   /* Substract the part of the file that might disappear from the used sized on
304    * the storage element */
305   m_usedSize -= (fd->size - fd->current_position);
306   // If the storage is full before even starting to write
307   if(m_usedSize==m_size) {
308     action->setState(SURF_ACTION_FAILED);
309   }
310   return action;
311 }
312
313 /**********
314  * Action *
315  **********/
316
317 StorageN11Action::StorageN11Action(Model *model, double cost, bool failed, Storage *storage, e_surf_action_storage_type_t type)
318   : StorageAction(model, cost, failed,
319               lmm_variable_new(model->getMaxminSystem(), this, 1.0, -1.0 , 3),
320               storage, type) {
321   XBT_IN("(%s,%g", storage->getName(), cost);
322
323   // Must be less than the max bandwidth for all actions
324   lmm_expand(model->getMaxminSystem(), storage->getConstraint(), getVariable(), 1.0);
325   switch(type) {
326   case OPEN:
327   case CLOSE:
328   case STAT:
329     break;
330   case READ:
331     lmm_expand(model->getMaxminSystem(), storage->p_constraintRead,
332                getVariable(), 1.0);
333     break;
334   case WRITE:
335     lmm_expand(model->getMaxminSystem(), storage->p_constraintWrite,
336                getVariable(), 1.0);
337
338 //TODO there is something annoying with what's below. Have to sort it out...
339 //    Action *action = this;
340 //    xbt_dynar_push(storage->p_writeActions, &action);
341 //    ref();
342     break;
343   }
344   XBT_OUT();
345 }
346
347 int StorageN11Action::unref()
348 {
349   m_refcount--;
350   if (!m_refcount) {
351   if (action_hook.is_linked())
352     p_stateSet->erase(p_stateSet->iterator_to(*this));
353     if (getVariable())
354       lmm_variable_free(getModel()->getMaxminSystem(), getVariable());
355     xbt_free(getCategory());
356     delete this;
357     return 1;
358   }
359   return 0;
360 }
361
362 void StorageN11Action::cancel()
363 {
364   setState(SURF_ACTION_FAILED);
365   return;
366 }
367
368 void StorageN11Action::suspend()
369 {
370   XBT_IN("(%p)", this);
371   if (m_suspended != 2) {
372     lmm_update_variable_weight(getModel()->getMaxminSystem(),
373                                getVariable(),
374                                0.0);
375     m_suspended = 1;
376   }
377   XBT_OUT();
378 }
379
380 void StorageN11Action::resume()
381 {
382   THROW_UNIMPLEMENTED;
383 }
384
385 bool StorageN11Action::isSuspended()
386 {
387   return m_suspended == 1;
388 }
389
390 void StorageN11Action::setMaxDuration(double /*duration*/)
391 {
392   THROW_UNIMPLEMENTED;
393 }
394
395 void StorageN11Action::setPriority(double /*priority*/)
396 {
397   THROW_UNIMPLEMENTED;
398 }
399
400 }
401 }