Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Merge branch 'master' of scm.gforge.inria.fr:/gitroot/simgrid/simgrid
[simgrid.git] / src / surf / HostImpl.cpp
1 /* Copyright (c) 2013-2016. The SimGrid Team. All rights reserved.          */
2
3 /* This program is free software; you can redistribute it and/or modify it
4  * under the terms of the license (GNU LGPL) which comes with this package. */
5
6 #include <simgrid/s4u/host.hpp>
7
8 #include "src/simix/smx_private.h"
9 #include "cpu_cas01.hpp"
10 #include "src/surf/HostImpl.hpp"
11 #include "simgrid/sg_config.h"
12
13 #include "network_interface.hpp"
14 #include "virtual_machine.hpp"
15
16 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_host, surf, "Logging specific to the SURF host module");
17
18 simgrid::surf::HostModel *surf_host_model = nullptr;
19
20 /*************
21  * Callbacks *
22  *************/
23
24 namespace simgrid {
25 namespace surf {
26
27 simgrid::xbt::Extension<simgrid::s4u::Host, HostImpl> HostImpl::EXTENSION_ID;
28
29 /*********
30  * Model *
31  *********/
32 HostImpl *HostModel::createHost(const char *name, kernel::routing::NetCard *netElm, Cpu *cpu){
33   xbt_dynar_t storageList = (xbt_dynar_t)xbt_lib_get_or_null(storage_lib, name, ROUTING_STORAGE_HOST_LEVEL);
34
35   HostImpl *host = new simgrid::surf::HostImpl(surf_host_model, name, storageList, cpu);
36   XBT_DEBUG("Create host %s with %ld mounted disks", name, xbt_dynar_length(host->storage_));
37   return host;
38 }
39
40 /* Each VM has a dummy CPU action on the PM layer. This CPU action works as the
41  * constraint (capacity) of the VM in the PM layer. If the VM does not have any
42  * active task, the dummy CPU action must be deactivated, so that the VM does
43  * not get any CPU share in the PM layer. */
44 void HostModel::adjustWeightOfDummyCpuActions()
45 {
46   /* iterate for all virtual machines */
47   for (VirtualMachine *ws_vm : VirtualMachine::allVms_) {
48
49     Cpu *cpu = ws_vm->cpu_;
50
51     int is_active = lmm_constraint_used(cpu->getModel()->getMaxminSystem(), cpu->getConstraint());
52
53     if (is_active) {
54       /* some tasks exist on this VM */
55       XBT_DEBUG("set the weight of the dummy CPU action on PM to 1");
56
57       /* FIXME: we should use lmm_update_variable_weight() ? */
58       /* FIXME: If we assign 1.05 and 0.05, the system makes apparently wrong values. */
59       ws_vm->action_->setPriority(1);
60
61     } else {
62       /* no task exits on this VM */
63       XBT_DEBUG("set the weight of the dummy CPU action on PM to 0");
64
65       ws_vm->action_->setPriority(0);
66     }
67   }
68 }
69
70 Action *HostModel::executeParallelTask(int host_nb,
71     sg_host_t *host_list,
72     double *flops_amount,
73     double *bytes_amount,
74     double rate)
75 {
76 #define cost_or_zero(array,pos) ((array)?(array)[pos]:0.0)
77   Action *action =nullptr;
78   if ((host_nb == 1)
79       && (cost_or_zero(bytes_amount, 0) == 0.0)){
80     action = host_list[0]->pimpl_cpu->execution_start(flops_amount[0]);
81   } else if ((host_nb == 1)
82            && (cost_or_zero(flops_amount, 0) == 0.0)) {
83     action = surf_network_model->communicate(host_list[0]->pimpl_netcard,
84                                          host_list[0]->pimpl_netcard,
85                        bytes_amount[0], rate);
86   } else if ((host_nb == 2)
87              && (cost_or_zero(flops_amount, 0) == 0.0)
88              && (cost_or_zero(flops_amount, 1) == 0.0)) {
89     int i,nb = 0;
90     double value = 0.0;
91
92     for (i = 0; i < host_nb * host_nb; i++) {
93       if (cost_or_zero(bytes_amount, i) > 0.0) {
94         nb++;
95         value = cost_or_zero(bytes_amount, i);
96       }
97     }
98     if (nb == 1) {
99       action = surf_network_model->communicate(host_list[0]->pimpl_netcard, host_list[1]->pimpl_netcard, value, rate);
100     } else if (nb == 0) {
101        xbt_die("Cannot have a communication with no flop to exchange in this model. You should consider using the ptask model");
102     } else {       
103        xbt_die("Cannot have a communication that is not a simple point-to-point in this model. You should consider using the ptask model");
104     }
105   } else 
106     xbt_die("This model only accepts one of the following. You should consider using the ptask model for the other cases.\n - execution with one host only and no communication\n - Self-comms with one host only\n - Communications with two hosts and no computation");
107 #undef cost_or_zero
108   xbt_free(host_list);
109   return action;
110 }
111
112 /************
113  * Resource *
114  ************/
115 HostImpl::HostImpl(simgrid::surf::HostModel *model, const char *name, xbt_dynar_t storage, Cpu *cpu)
116  : Resource(model, name)
117  , PropertyHolder(nullptr)
118  , storage_(storage), cpu_(cpu)
119 {
120   if (!EXTENSION_ID.valid())
121     EXTENSION_ID = simgrid::s4u::Host::extension_create<simgrid::surf::HostImpl>();
122   params_.ramsize = 0;
123 }
124
125 HostImpl::HostImpl(simgrid::surf::HostModel *model, const char *name, lmm_constraint_t constraint,
126                  xbt_dynar_t storage, Cpu *cpu)
127  : Resource(model, name, constraint)
128  , PropertyHolder(nullptr)
129  , storage_(storage), cpu_(cpu)
130 {
131   params_.ramsize = 0;
132 }
133
134 /** @brief use destroy() instead of this destructor */
135 HostImpl::~HostImpl()
136 {
137 }
138
139 void HostImpl::attach(simgrid::s4u::Host* host)
140 {
141   if (piface_ != nullptr)
142     xbt_die("Already attached to host %s", host->name().c_str());
143   host->extension_set(this);
144   piface_ = host;
145 }
146
147 bool HostImpl::isOn() const {
148   return cpu_->isOn();
149 }
150 bool HostImpl::isOff() const {
151   return cpu_->isOff();
152 }
153 void HostImpl::turnOn(){
154   if (isOff()) {
155     cpu_->turnOn();
156     simgrid::s4u::Host::onStateChange(*this->piface_);
157   }
158 }
159 void HostImpl::turnOff(){
160   if (isOn()) {
161     cpu_->turnOff();
162     simgrid::s4u::Host::onStateChange(*this->piface_);
163   }
164 }
165
166 simgrid::surf::Storage *HostImpl::findStorageOnMountList(const char* mount)
167 {
168   simgrid::surf::Storage *st = nullptr;
169   s_mount_t mnt;
170   unsigned int cursor;
171
172   XBT_DEBUG("Search for storage name '%s' on '%s'", mount, getName());
173   xbt_dynar_foreach(storage_,cursor,mnt){
174     XBT_DEBUG("See '%s'",mnt.name);
175     if(!strcmp(mount,mnt.name)){
176       st = static_cast<simgrid::surf::Storage*>(mnt.storage);
177       break;
178     }
179   }
180   if(!st)
181     xbt_die("Can't find mount '%s' for '%s'", mount, getName());
182   return st;
183 }
184
185 xbt_dict_t HostImpl::getMountedStorageList()
186 {
187   s_mount_t mnt;
188   unsigned int i;
189   xbt_dict_t storage_list = xbt_dict_new_homogeneous(nullptr);
190   char *storage_name = nullptr;
191
192   xbt_dynar_foreach(storage_,i,mnt){
193     storage_name = (char *)static_cast<simgrid::surf::Storage*>(mnt.storage)->getName();
194     xbt_dict_set(storage_list,mnt.name,storage_name,nullptr);
195   }
196   return storage_list;
197 }
198
199 xbt_dynar_t HostImpl::getAttachedStorageList()
200 {
201   xbt_lib_cursor_t cursor;
202   char *key;
203   void **data;
204   xbt_dynar_t result = xbt_dynar_new(sizeof(void*), nullptr);
205   xbt_lib_foreach(storage_lib, cursor, key, data) {
206     if(xbt_lib_get_level(xbt_lib_get_elm_or_null(storage_lib, key), SURF_STORAGE_LEVEL) != nullptr) {
207     simgrid::surf::Storage *storage = static_cast<simgrid::surf::Storage*>(xbt_lib_get_level(xbt_lib_get_elm_or_null(storage_lib, key), SURF_STORAGE_LEVEL));
208     if(!strcmp((const char*)storage->attach_,this->getName())){
209       xbt_dynar_push_as(result, void *, (void*)storage->getName());
210     }
211   }
212   }
213   return result;
214 }
215
216 Action *HostImpl::open(const char* fullpath) {
217
218   simgrid::surf::Storage *st = nullptr;
219   s_mount_t mnt;
220   unsigned int cursor;
221   size_t longest_prefix_length = 0;
222   char *path = nullptr;
223   char *file_mount_name = nullptr;
224   char *mount_name = nullptr;
225
226   XBT_DEBUG("Search for storage name for '%s' on '%s'", fullpath, getName());
227   xbt_dynar_foreach(storage_,cursor,mnt)
228   {
229     XBT_DEBUG("See '%s'",mnt.name);
230     file_mount_name = (char *) xbt_malloc ((strlen(mnt.name)+1));
231     strncpy(file_mount_name,fullpath,strlen(mnt.name)+1);
232     file_mount_name[strlen(mnt.name)] = '\0';
233
234     if(!strcmp(file_mount_name,mnt.name) && strlen(mnt.name)>longest_prefix_length)
235     {/* The current mount name is found in the full path and is bigger than the previous*/
236       longest_prefix_length = strlen(mnt.name);
237       st = static_cast<simgrid::surf::Storage*>(mnt.storage);
238     }
239     free(file_mount_name);
240   }
241   if(longest_prefix_length>0)
242   { /* Mount point found, split fullpath into mount_name and path+filename*/
243   path = (char *) xbt_malloc ((strlen(fullpath)-longest_prefix_length+1));
244   mount_name = (char *) xbt_malloc ((longest_prefix_length+1));
245   strncpy(mount_name, fullpath, longest_prefix_length+1);
246   strncpy(path, fullpath+longest_prefix_length, strlen(fullpath)-longest_prefix_length+1);
247   path[strlen(fullpath)-longest_prefix_length] = '\0';
248   mount_name[longest_prefix_length] = '\0';
249   }
250   else
251     xbt_die("Can't find mount point for '%s' on '%s'", fullpath, getName());
252
253   XBT_DEBUG("OPEN %s on disk '%s'",path, st->getName());
254   Action *action = st->open((const char*)mount_name, (const char*)path);
255   free((char*)path);
256   free((char*)mount_name);
257   return action;
258 }
259
260 Action *HostImpl::close(surf_file_t fd) {
261   simgrid::surf::Storage *st = findStorageOnMountList(fd->mount);
262   XBT_DEBUG("CLOSE %s on disk '%s'",fd->name, st->getName());
263   return st->close(fd);
264 }
265
266 Action *HostImpl::read(surf_file_t fd, sg_size_t size) {
267   simgrid::surf::Storage *st = findStorageOnMountList(fd->mount);
268   XBT_DEBUG("READ %s on disk '%s'",fd->name, st->getName());
269   return st->read(fd, size);
270 }
271
272 Action *HostImpl::write(surf_file_t fd, sg_size_t size) {
273   simgrid::surf::Storage *st = findStorageOnMountList(fd->mount);
274   XBT_DEBUG("WRITE %s on disk '%s'",fd->name, st->getName());
275   return st->write(fd, size);
276 }
277
278 int HostImpl::unlink(surf_file_t fd) {
279   if (!fd){
280     XBT_WARN("No such file descriptor. Impossible to unlink");
281     return -1;
282   } else {
283
284     simgrid::surf::Storage *st = findStorageOnMountList(fd->mount);
285     /* Check if the file is on this storage */
286     if (!xbt_dict_get_or_null(st->content_, fd->name)){
287       XBT_WARN("File %s is not on disk %s. Impossible to unlink", fd->name,
288           st->getName());
289       return -1;
290     } else {
291       XBT_DEBUG("UNLINK %s on disk '%s'",fd->name, st->getName());
292       st->usedSize_ -= fd->size;
293
294       // Remove the file from storage
295       xbt_dict_remove(st->content_, fd->name);
296
297       xbt_free(fd->name);
298       xbt_free(fd->mount);
299       xbt_free(fd);
300       return 0;
301     }
302   }
303 }
304
305 sg_size_t HostImpl::getSize(surf_file_t fd){
306   return fd->size;
307 }
308
309 xbt_dynar_t HostImpl::getInfo( surf_file_t fd)
310 {
311   simgrid::surf::Storage *st = findStorageOnMountList(fd->mount);
312   sg_size_t *psize = xbt_new(sg_size_t, 1);
313   *psize = fd->size;
314   xbt_dynar_t info = xbt_dynar_new(sizeof(void*), nullptr);
315   xbt_dynar_push_as(info, sg_size_t *, psize);
316   xbt_dynar_push_as(info, void *, fd->mount);
317   xbt_dynar_push_as(info, void *, (void *)st->getName());
318   xbt_dynar_push_as(info, void *, st->typeId_);
319   xbt_dynar_push_as(info, void *, st->contentType_);
320
321   return info;
322 }
323
324 sg_size_t HostImpl::fileTell(surf_file_t fd){
325   return fd->current_position;
326 }
327
328 int HostImpl::fileSeek(surf_file_t fd, sg_offset_t offset, int origin){
329
330   switch (origin) {
331   case SEEK_SET:
332     fd->current_position = offset;
333     return 0;
334   case SEEK_CUR:
335     fd->current_position += offset;
336     return 0;
337   case SEEK_END:
338     fd->current_position = fd->size + offset;
339     return 0;
340   default:
341     return -1;
342   }
343 }
344
345 int HostImpl::fileMove(surf_file_t fd, const char* fullpath){
346   /* Check if the new full path is on the same mount point */
347   if(!strncmp((const char*)fd->mount, fullpath, strlen(fd->mount))) {
348     sg_size_t *psize, *new_psize;
349     psize = (sg_size_t*)
350         xbt_dict_get_or_null(findStorageOnMountList(fd->mount)->content_,
351                              fd->name);
352     new_psize = xbt_new(sg_size_t, 1);
353     *new_psize = *psize;
354     if (psize){// src file exists
355       xbt_dict_remove(findStorageOnMountList(fd->mount)->content_, fd->name);
356       char *path = (char *) xbt_malloc ((strlen(fullpath)-strlen(fd->mount)+1));
357       strncpy(path, fullpath+strlen(fd->mount),
358               strlen(fullpath)-strlen(fd->mount)+1);
359       xbt_dict_set(findStorageOnMountList(fd->mount)->content_, path,
360                    new_psize,nullptr);
361       XBT_DEBUG("Move file from %s to %s, size '%llu'",fd->name, fullpath, *psize);
362       free(path);
363       return 0;
364     } else {
365       XBT_WARN("File %s doesn't exist", fd->name);
366       return -1;
367     }
368   } else {
369     XBT_WARN("New full path %s is not on the same mount point: %s. Action has been canceled.",
370              fullpath, fd->mount);
371     return -1;
372   }
373 }
374
375 xbt_dynar_t HostImpl::getVms()
376 {
377   xbt_dynar_t dyn = xbt_dynar_new(sizeof(simgrid::surf::VirtualMachine*), nullptr);
378
379   for (VirtualMachine *ws_vm : VirtualMachine::allVms_) {
380     if (this == ws_vm->getPm()->extension<simgrid::surf::HostImpl>())
381       xbt_dynar_push(dyn, &ws_vm);
382   }
383
384   return dyn;
385 }
386
387 void HostImpl::getParams(vm_params_t params)
388 {
389   *params = params_;
390 }
391
392 void HostImpl::setParams(vm_params_t params)
393 {
394   /* may check something here. */
395   params_ = *params;
396 }
397
398 }}