src/surf/host_interface.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 "host_interface.hpp"
   8
   9 #include "src/simix/smx_private.h"
  10 #include "cpu_cas01.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,
  17                                 "Logging specific to the SURF host module");
  18
  19 simgrid::surf::HostModel *surf_host_model = NULL;
  20
  21 void host_add_traces(){
  22   surf_host_model->addTraces();
  23 }
  24
  25 /*************
  26  * Callbacks *
  27  *************/
  28
  29 namespace simgrid {
  30 namespace surf {
  31
  32 surf_callback(void, simgrid::surf::Host*) hostCreatedCallbacks;
  33 surf_callback(void, simgrid::surf::Host*) hostDestructedCallbacks;
  34 surf_callback(void, simgrid::surf::Host*, e_surf_resource_state_t, e_surf_resource_state_t) hostStateChangedCallbacks;
  35 surf_callback(void, simgrid::surf::HostAction*, e_surf_action_state_t, e_surf_action_state_t) hostActionStateChangedCallbacks;
  36
  37 /*********
  38  * Model *
  39  *********/
  40
  41 /* Each VM has a dummy CPU action on the PM layer. This CPU action works as the
  42  * constraint (capacity) of the VM in the PM layer. If the VM does not have any
  43  * active task, the dummy CPU action must be deactivated, so that the VM does
  44  * not get any CPU share in the PM layer. */
  45 void HostModel::adjustWeightOfDummyCpuActions()
  46 {
  47   /* iterate for all virtual machines */
  48   for (VMModel::vm_list_t::iterator iter =
  49          VMModel::ws_vms.begin();
  50        iter !=  VMModel::ws_vms.end(); ++iter) {
  51
  52     VirtualMachine *ws_vm = &*iter;
  53     CpuCas01 *cpu_cas01 = static_cast<CpuCas01*>(ws_vm->p_cpu);
  54     xbt_assert(cpu_cas01, "cpu-less host");
  55
  56     int is_active = lmm_constraint_used(cpu_cas01->getModel()->getMaxminSystem(), cpu_cas01->getConstraint());
  57     // int is_active_old = constraint_is_active(cpu_cas01);
  58
  59     if (is_active) {
  60       /* some tasks exist on this VM */
  61       XBT_DEBUG("set the weight of the dummy CPU action on PM to 1");
  62
  63       /* FIXME: we should use lmm_update_variable_weight() ? */
  64       /* FIXME: If we assign 1.05 and 0.05, the system makes apparently wrong values. */
  65       ws_vm->p_action->setPriority(1);
  66
  67     } else {
  68       /* no task exits on this VM */
  69       XBT_DEBUG("set the weight of the dummy CPU action on PM to 0");
  70
  71       ws_vm->p_action->setPriority(0);
  72     }
  73   }
  74 }
  75
  76 /************
  77  * Resource *
  78  ************/
  79 Host::Host(simgrid::surf::Model *model, const char *name, xbt_dict_t props,
  80                                  xbt_dynar_t storage, RoutingEdge *netElm, Cpu *cpu)
  81  : Resource(model, name, props)
  82  , p_storage(storage), p_netElm(netElm), p_cpu(cpu)
  83 {
  84   p_params.ramsize = 0;
  85 }
  86
  87 Host::Host(simgrid::surf::Model *model, const char *name, xbt_dict_t props, lmm_constraint_t constraint,
  88                                          xbt_dynar_t storage, RoutingEdge *netElm, Cpu *cpu)
  89  : Resource(model, name, props, constraint)
  90  , p_storage(storage), p_netElm(netElm), p_cpu(cpu)
  91 {
  92   p_params.ramsize = 0;
  93 }
  94
  95 Host::~Host(){
  96   surf_callback_emit(hostDestructedCallbacks, this);
  97 }
  98
  99 void Host::setState(e_surf_resource_state_t state){
 100   e_surf_resource_state_t old = Resource::getState();
 101   Resource::setState(state);
 102   surf_callback_emit(hostStateChangedCallbacks, this, old, state);
 103   p_cpu->setState(state);
 104 }
 105
 106 xbt_dict_t Host::getProperties()
 107 {
 108   return p_cpu->getProperties();
 109 }
 110
 111 simgrid::surf::Storage *Host::findStorageOnMountList(const char* mount)
 112 {
 113   simgrid::surf::Storage *st = NULL;
 114   s_mount_t mnt;
 115   unsigned int cursor;
 116
 117   XBT_DEBUG("Search for storage name '%s' on '%s'", mount, getName());
 118   xbt_dynar_foreach(p_storage,cursor,mnt)
 119   {
 120     XBT_DEBUG("See '%s'",mnt.name);
 121     if(!strcmp(mount,mnt.name)){
 122       st = static_cast<simgrid::surf::Storage*>(mnt.storage);
 123       break;
 124     }
 125   }
 126   if(!st) xbt_die("Can't find mount '%s' for '%s'", mount, getName());
 127   return st;
 128 }
 129
 130 xbt_dict_t Host::getMountedStorageList()
 131 {
 132   s_mount_t mnt;
 133   unsigned int i;
 134   xbt_dict_t storage_list = xbt_dict_new_homogeneous(NULL);
 135   char *storage_name = NULL;
 136
 137   xbt_dynar_foreach(p_storage,i,mnt){
 138     storage_name = (char *)static_cast<simgrid::surf::Storage*>(mnt.storage)->getName();
 139     xbt_dict_set(storage_list,mnt.name,storage_name,NULL);
 140   }
 141   return storage_list;
 142 }
 143
 144 xbt_dynar_t Host::getAttachedStorageList()
 145 {
 146   xbt_lib_cursor_t cursor;
 147   char *key;
 148   void **data;
 149   xbt_dynar_t result = xbt_dynar_new(sizeof(void*), NULL);
 150   xbt_lib_foreach(storage_lib, cursor, key, data) {
 151     if(xbt_lib_get_level(xbt_lib_get_elm_or_null(storage_lib, key), SURF_STORAGE_LEVEL) != NULL) {
 152           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));
 153           if(!strcmp((const char*)storage->p_attach,this->getName())){
 154             xbt_dynar_push_as(result, void *, (void*)storage->getName());
 155           }
 156         }
 157   }
 158   return result;
 159 }
 160
 161 Action *Host::open(const char* fullpath) {
 162
 163   simgrid::surf::Storage *st = NULL;
 164   s_mount_t mnt;
 165   unsigned int cursor;
 166   size_t longest_prefix_length = 0;
 167   char *path = NULL;
 168   char *file_mount_name = NULL;
 169   char *mount_name = NULL;
 170
 171   XBT_DEBUG("Search for storage name for '%s' on '%s'", fullpath, getName());
 172   xbt_dynar_foreach(p_storage,cursor,mnt)
 173   {
 174     XBT_DEBUG("See '%s'",mnt.name);
 175     file_mount_name = (char *) xbt_malloc ((strlen(mnt.name)+1));
 176     strncpy(file_mount_name,fullpath,strlen(mnt.name)+1);
 177     file_mount_name[strlen(mnt.name)] = '\0';
 178
 179     if(!strcmp(file_mount_name,mnt.name) && strlen(mnt.name)>longest_prefix_length)
 180     {/* The current mount name is found in the full path and is bigger than the previous*/
 181       longest_prefix_length = strlen(mnt.name);
 182       st = static_cast<simgrid::surf::Storage*>(mnt.storage);
 183     }
 184     free(file_mount_name);
 185   }
 186   if(longest_prefix_length>0)
 187   { /* Mount point found, split fullpath into mount_name and path+filename*/
 188         path = (char *) xbt_malloc ((strlen(fullpath)-longest_prefix_length+1));
 189         mount_name = (char *) xbt_malloc ((longest_prefix_length+1));
 190         strncpy(mount_name, fullpath, longest_prefix_length+1);
 191         strncpy(path, fullpath+longest_prefix_length, strlen(fullpath)-longest_prefix_length+1);
 192         path[strlen(fullpath)-longest_prefix_length] = '\0';
 193         mount_name[longest_prefix_length] = '\0';
 194   }
 195   else
 196     xbt_die("Can't find mount point for '%s' on '%s'", fullpath, getName());
 197
 198   XBT_DEBUG("OPEN %s on disk '%s'",path, st->getName());
 199   Action *action = st->open((const char*)mount_name, (const char*)path);
 200   free((char*)path);
 201   free((char*)mount_name);
 202   return action;
 203 }
 204
 205 Action *Host::close(surf_file_t fd) {
 206   simgrid::surf::Storage *st = findStorageOnMountList(fd->mount);
 207   XBT_DEBUG("CLOSE %s on disk '%s'",fd->name, st->getName());
 208   return st->close(fd);
 209 }
 210
 211 Action *Host::read(surf_file_t fd, sg_size_t size) {
 212   simgrid::surf::Storage *st = findStorageOnMountList(fd->mount);
 213   XBT_DEBUG("READ %s on disk '%s'",fd->name, st->getName());
 214   return st->read(fd, size);
 215 }
 216
 217 Action *Host::write(surf_file_t fd, sg_size_t size) {
 218   simgrid::surf::Storage *st = findStorageOnMountList(fd->mount);
 219   XBT_DEBUG("WRITE %s on disk '%s'",fd->name, st->getName());
 220   return st->write(fd, size);
 221 }
 222
 223 int Host::unlink(surf_file_t fd) {
 224   if (!fd){
 225     XBT_WARN("No such file descriptor. Impossible to unlink");
 226     return -1;
 227   } else {
 228
 229     simgrid::surf::Storage *st = findStorageOnMountList(fd->mount);
 230     /* Check if the file is on this storage */
 231     if (!xbt_dict_get_or_null(st->p_content, fd->name)){
 232       XBT_WARN("File %s is not on disk %s. Impossible to unlink", fd->name,
 233           st->getName());
 234       return -1;
 235     } else {
 236       XBT_DEBUG("UNLINK %s on disk '%s'",fd->name, st->getName());
 237       st->m_usedSize -= fd->size;
 238
 239       // Remove the file from storage
 240       xbt_dict_remove(st->p_content, fd->name);
 241
 242       xbt_free(fd->name);
 243       xbt_free(fd->mount);
 244       xbt_free(fd);
 245       return 0;
 246     }
 247   }
 248 }
 249
 250 sg_size_t Host::getSize(surf_file_t fd){
 251   return fd->size;
 252 }
 253
 254 xbt_dynar_t Host::getInfo( surf_file_t fd)
 255 {
 256   simgrid::surf::Storage *st = findStorageOnMountList(fd->mount);
 257   sg_size_t *psize = xbt_new(sg_size_t, 1);
 258   *psize = fd->size;
 259   xbt_dynar_t info = xbt_dynar_new(sizeof(void*), NULL);
 260   xbt_dynar_push_as(info, sg_size_t *, psize);
 261   xbt_dynar_push_as(info, void *, fd->mount);
 262   xbt_dynar_push_as(info, void *, (void *)st->getName());
 263   xbt_dynar_push_as(info, void *, st->p_typeId);
 264   xbt_dynar_push_as(info, void *, st->p_contentType);
 265
 266   return info;
 267 }
 268
 269 sg_size_t Host::fileTell(surf_file_t fd){
 270   return fd->current_position;
 271 }
 272
 273 int Host::fileSeek(surf_file_t fd, sg_offset_t offset, int origin){
 274
 275   switch (origin) {
 276   case SEEK_SET:
 277     fd->current_position = offset;
 278     return 0;
 279   case SEEK_CUR:
 280     fd->current_position += offset;
 281     return 0;
 282   case SEEK_END:
 283     fd->current_position = fd->size + offset;
 284     return 0;
 285   default:
 286     return -1;
 287   }
 288 }
 289
 290 int Host::fileMove(surf_file_t fd, const char* fullpath){
 291   /* Check if the new full path is on the same mount point */
 292   if(!strncmp((const char*)fd->mount, fullpath, strlen(fd->mount))) {
 293     sg_size_t *psize, *new_psize;
 294     psize = (sg_size_t*)
 295         xbt_dict_get_or_null(findStorageOnMountList(fd->mount)->p_content,
 296                              fd->name);
 297     new_psize = xbt_new(sg_size_t, 1);
 298     *new_psize = *psize;
 299     if (psize){// src file exists
 300       xbt_dict_remove(findStorageOnMountList(fd->mount)->p_content, fd->name);
 301       char *path = (char *) xbt_malloc ((strlen(fullpath)-strlen(fd->mount)+1));
 302       strncpy(path, fullpath+strlen(fd->mount),
 303               strlen(fullpath)-strlen(fd->mount)+1);
 304       xbt_dict_set(findStorageOnMountList(fd->mount)->p_content, path,
 305                    new_psize,NULL);
 306       XBT_DEBUG("Move file from %s to %s, size '%llu'",fd->name, fullpath, *psize);
 307       free(path);
 308       return 0;
 309     } else {
 310       XBT_WARN("File %s doesn't exist", fd->name);
 311       return -1;
 312     }
 313   } else {
 314     XBT_WARN("New full path %s is not on the same mount point: %s. Action has been canceled.",
 315              fullpath, fd->mount);
 316     return -1;
 317   }
 318 }
 319
 320 xbt_dynar_t Host::getVms()
 321 {
 322   xbt_dynar_t dyn = xbt_dynar_new(sizeof(simgrid::surf::VirtualMachine*), NULL);
 323
 324   /* iterate for all virtual machines */
 325   for (simgrid::surf::VMModel::vm_list_t::iterator iter =
 326          simgrid::surf::VMModel::ws_vms.begin();
 327        iter !=  simgrid::surf::VMModel::ws_vms.end(); ++iter) {
 328
 329     simgrid::surf::VirtualMachine *ws_vm = &*iter;
 330     if (this == ws_vm->p_subWs)
 331       xbt_dynar_push(dyn, &ws_vm);
 332   }
 333
 334   return dyn;
 335 }
 336
 337 void Host::getParams(vm_params_t params)
 338 {
 339   *params = p_params;
 340 }
 341
 342 void Host::setParams(vm_params_t params)
 343 {
 344   /* may check something here. */
 345   p_params = *params;
 346 }
 347
 348 /**********
 349  * Action *
 350  **********/
 351
 352 void HostAction::setState(e_surf_action_state_t state){
 353   e_surf_action_state_t old = getState();
 354   Action::setState(state);
 355   surf_callback_emit(hostActionStateChangedCallbacks, this, old, state);
 356 }
 357
 358 }
 359 }