src/surf/workstation.cpp

   1 #include "workstation.hpp"
   2 #include "vm_workstation.hpp"
   3 #include "cpu_cas01.hpp"
   4 #include "simgrid/sg_config.h"
   5
   6 extern "C" {
   7 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_workstation, surf,
   8                                 "Logging specific to the SURF workstation module");
   9 }
  10
  11 WorkstationModelPtr surf_workstation_model = NULL;
  12
  13 //FIXME:Faire hériter ou composer de cup et network
  14
  15 /*************
  16  * CallBacks *
  17  *************/
  18
  19 static void workstation_new(sg_platf_host_cbarg_t host){
  20   surf_workstation_model->createResource(host->id);
  21 }
  22
  23 /*********
  24  * Model *
  25  *********/
  26
  27 void surf_workstation_model_init_current_default(void)
  28 {
  29   surf_workstation_model = new WorkstationModel();
  30   xbt_cfg_setdefault_boolean(_sg_cfg_set, "network/crosstraffic", "yes");
  31   surf_cpu_model_init_Cas01();
  32   surf_network_model_init_LegrandVelho();
  33   surf_workstation_model->p_cpuModel = surf_cpu_model_pm;
  34
  35   ModelPtr model = static_cast<ModelPtr>(surf_workstation_model);
  36   xbt_dynar_push(model_list, &model);
  37   xbt_dynar_push(model_list_invoke, &model);
  38   sg_platf_host_add_cb(workstation_new);
  39 }
  40
  41 void surf_workstation_model_init_compound()
  42 {
  43
  44   xbt_assert(surf_cpu_model_pm, "No CPU model defined yet!");
  45   xbt_assert(surf_network_model, "No network model defined yet!");
  46   surf_workstation_model = new WorkstationModel();
  47
  48   ModelPtr model = static_cast<ModelPtr>(surf_workstation_model);
  49   xbt_dynar_push(model_list, &model);
  50   xbt_dynar_push(model_list_invoke, &model);
  51   sg_platf_host_add_cb(workstation_new);
  52 }
  53
  54 WorkstationModel::WorkstationModel() : Model("Workstation") {
  55   p_cpuModel = surf_cpu_model_pm;
  56 }
  57
  58 WorkstationModel::~WorkstationModel() {
  59 }
  60
  61 void WorkstationModel::parseInit(sg_platf_host_cbarg_t host){
  62   createResource(host->id);
  63 }
  64
  65 WorkstationCLM03Ptr WorkstationModel::createResource(string name){
  66
  67   WorkstationCLM03Ptr workstation = new WorkstationCLM03(surf_workstation_model, name.c_str(), NULL,
  68                   (xbt_dynar_t)xbt_lib_get_or_null(storage_lib, name.c_str(), ROUTING_STORAGE_HOST_LEVEL),
  69                   (RoutingEdgePtr)xbt_lib_get_or_null(host_lib, name.c_str(), ROUTING_HOST_LEVEL),
  70                   dynamic_cast<CpuPtr>(static_cast<ResourcePtr>(xbt_lib_get_or_null(host_lib, name.c_str(), SURF_CPU_LEVEL))));
  71   XBT_DEBUG("Create workstation %s with %ld mounted disks", name.c_str(), xbt_dynar_length(workstation->p_storage));
  72   xbt_lib_set(host_lib, name.c_str(), SURF_WKS_LEVEL, static_cast<ResourcePtr>(workstation));
  73   return workstation;
  74 }
  75
  76 /* Each VM has a dummy CPU action on the PM layer. This CPU action works as the
  77  * constraint (capacity) of the VM in the PM layer. If the VM does not have any
  78  * active task, the dummy CPU action must be deactivated, so that the VM does
  79  * not get any CPU share in the PM layer. */
  80 void WorkstationModel::adjustWeightOfDummyCpuActions()
  81 {
  82   /* iterate for all hosts including virtual machines */
  83   xbt_lib_cursor_t cursor;
  84   char *key;
  85   void **ind_host;
  86
  87   xbt_lib_foreach(host_lib, cursor, key, ind_host) {
  88     WorkstationCLM03Ptr ws_clm03 = dynamic_cast<WorkstationCLM03Ptr>(
  89                                        static_cast<ResourcePtr>(ind_host[SURF_WKS_LEVEL]));
  90     CpuCas01LmmPtr cpu_cas01 = dynamic_cast<CpuCas01LmmPtr>(
  91                                static_cast<ResourcePtr>(ind_host[SURF_CPU_LEVEL]));
  92
  93     if (!ws_clm03)
  94       continue;
  95     /* skip if it is not a virtual machine */
  96     if (ws_clm03->p_model != static_cast<ModelPtr>(surf_vm_workstation_model))
  97       continue;
  98     xbt_assert(cpu_cas01, "cpu-less workstation");
  99
 100     /* It is a virtual machine, so we can cast it to workstation_VM2013_t */
 101     WorkstationVM2013Ptr ws_vm2013 = dynamic_cast<WorkstationVM2013Ptr>(ws_clm03);
 102
 103     int is_active = lmm_constraint_used(cpu_cas01->p_model->p_maxminSystem, cpu_cas01->p_constraint);
 104     // int is_active_old = constraint_is_active(cpu_cas01);
 105
 106     // {
 107     //   xbt_assert(is_active == is_active_old, "%d %d", is_active, is_active_old);
 108     // }
 109
 110     if (is_active) {
 111       /* some tasks exist on this VM */
 112       XBT_DEBUG("set the weight of the dummy CPU action on PM to 1");
 113
 114       /* FIXME: we shoud use lmm_update_variable_weight() ? */
 115       /* FIXME: If we assgign 1.05 and 0.05, the system makes apparently wrong values. */
 116       surf_action_set_priority(ws_vm2013->p_action, 1);
 117
 118     } else {
 119       /* no task exits on this VM */
 120       XBT_DEBUG("set the weight of the dummy CPU action on PM to 0");
 121
 122       surf_action_set_priority(ws_vm2013->p_action, 0);
 123     }
 124   }
 125 }
 126
 127 double WorkstationModel::shareResources(double now){
 128   adjustWeightOfDummyCpuActions();
 129
 130   double min_by_cpu = p_cpuModel->shareResources(now);
 131   double min_by_net = surf_network_model->shareResources(now);
 132
 133   XBT_DEBUG("model %p, %s min_by_cpu %f, %s min_by_net %f",
 134       this, surf_cpu_model_pm->m_name.c_str(), min_by_cpu, surf_network_model->m_name.c_str(), min_by_net);
 135
 136   if (min_by_cpu >= 0.0 && min_by_net >= 0.0)
 137     return min(min_by_cpu, min_by_net);
 138   else if (min_by_cpu >= 0.0)
 139     return min_by_cpu;
 140   else if (min_by_net >= 0.0)
 141     return min_by_net;
 142   else
 143     return min_by_cpu;  /* probably min_by_cpu == min_by_net == -1 */
 144 }
 145
 146 void WorkstationModel::updateActionsState(double /*now*/, double /*delta*/){
 147   return;
 148 }
 149
 150 ActionPtr WorkstationModel::executeParallelTask(int workstation_nb,
 151                                         void **workstation_list,
 152                                         double *computation_amount,
 153                                         double *communication_amount,
 154                                         double rate){
 155 #define cost_or_zero(array,pos) ((array)?(array)[pos]:0.0)
 156   if ((workstation_nb == 1)
 157       && (cost_or_zero(communication_amount, 0) == 0.0))
 158     return ((WorkstationCLM03Ptr)workstation_list[0])->execute(computation_amount[0]);
 159   else if ((workstation_nb == 1)
 160            && (cost_or_zero(computation_amount, 0) == 0.0))
 161     return communicate((WorkstationCLM03Ptr)workstation_list[0], (WorkstationCLM03Ptr)workstation_list[0],communication_amount[0], rate);
 162   else if ((workstation_nb == 2)
 163              && (cost_or_zero(computation_amount, 0) == 0.0)
 164              && (cost_or_zero(computation_amount, 1) == 0.0)) {
 165     int i,nb = 0;
 166     double value = 0.0;
 167
 168     for (i = 0; i < workstation_nb * workstation_nb; i++) {
 169       if (cost_or_zero(communication_amount, i) > 0.0) {
 170         nb++;
 171         value = cost_or_zero(communication_amount, i);
 172       }
 173     }
 174     if (nb == 1)
 175       return communicate((WorkstationCLM03Ptr)workstation_list[0], (WorkstationCLM03Ptr)workstation_list[1],value, rate);
 176   }
 177 #undef cost_or_zero
 178
 179   THROW_UNIMPLEMENTED;          /* This model does not implement parallel tasks */
 180   return NULL;
 181 }
 182
 183 /* returns an array of network_link_CM02_t */
 184 xbt_dynar_t WorkstationModel::getRoute(WorkstationCLM03Ptr src, WorkstationCLM03Ptr dst)
 185 {
 186   XBT_DEBUG("ws_get_route");
 187   return surf_network_model->getRoute(src->p_netElm, dst->p_netElm);
 188 }
 189
 190 ActionPtr WorkstationModel::communicate(WorkstationCLM03Ptr src, WorkstationCLM03Ptr dst, double size, double rate){
 191   return surf_network_model->communicate(src->p_netElm, dst->p_netElm, size, rate);
 192 }
 193
 194
 195
 196 /************
 197  * Resource *
 198  ************/
 199 WorkstationCLM03::WorkstationCLM03(WorkstationModelPtr model, const char* name, xbt_dict_t properties, xbt_dynar_t storage, RoutingEdgePtr netElm, CpuPtr cpu)
 200   : Resource(model, name, properties), p_storage(storage), p_netElm(netElm), p_cpu(cpu) {}
 201
 202 bool WorkstationCLM03::isUsed(){
 203   THROW_IMPOSSIBLE;             /* This model does not implement parallel tasks */
 204   return -1;
 205 }
 206
 207 void WorkstationCLM03::updateState(tmgr_trace_event_t /*event_type*/, double /*value*/, double /*date*/){
 208   THROW_IMPOSSIBLE;             /* This model does not implement parallel tasks */
 209 }
 210
 211 ActionPtr WorkstationCLM03::execute(double size) {
 212   return p_cpu->execute(size);
 213 }
 214
 215 ActionPtr WorkstationCLM03::sleep(double duration) {
 216   return p_cpu->sleep(duration);
 217 }
 218
 219 e_surf_resource_state_t WorkstationCLM03::getState() {
 220   return p_cpu->getState();
 221 }
 222
 223 int WorkstationCLM03::getCore(){
 224   return p_cpu->getCore();
 225 }
 226
 227 double WorkstationCLM03::getSpeed(double load){
 228   return p_cpu->getSpeed(load);
 229 }
 230
 231 double WorkstationCLM03::getAvailableSpeed(){
 232   return p_cpu->getAvailableSpeed();
 233 }
 234
 235 double WorkstationCLM03::getCurrentPowerPeak()
 236 {
 237   return p_cpu->getCurrentPowerPeak();
 238 }
 239
 240 double WorkstationCLM03::getPowerPeakAt(int pstate_index)
 241 {
 242   return p_cpu->getPowerPeakAt(pstate_index);
 243 }
 244
 245 int WorkstationCLM03::getNbPstates()
 246 {
 247   return p_cpu->getNbPstates();
 248 }
 249
 250 void WorkstationCLM03::setPowerPeakAt(int pstate_index)
 251 {
 252         p_cpu->setPowerPeakAt(pstate_index);
 253 }
 254
 255 double WorkstationCLM03::getConsumedEnergy()
 256 {
 257   return p_cpu->getConsumedEnergy();
 258 }
 259
 260
 261 xbt_dict_t WorkstationCLM03::getProperties()
 262 {
 263   return p_cpu->m_properties;
 264 }
 265
 266
 267 StoragePtr WorkstationCLM03::findStorageOnMountList(const char* mount)
 268 {
 269   StoragePtr st = NULL;
 270   s_mount_t mnt;
 271   unsigned int cursor;
 272
 273   XBT_DEBUG("Search for storage name '%s' on '%s'", mount, m_name);
 274   xbt_dynar_foreach(p_storage,cursor,mnt)
 275   {
 276     XBT_DEBUG("See '%s'",mnt.name);
 277     if(!strcmp(mount,mnt.name)){
 278       st = dynamic_cast<StoragePtr>(static_cast<ResourcePtr>(mnt.storage));
 279       break;
 280     }
 281   }
 282   if(!st) xbt_die("Can't find mount '%s' for '%s'", mount, m_name);
 283   return st;
 284 }
 285
 286 xbt_dict_t WorkstationCLM03::getStorageList()
 287 {
 288   s_mount_t mnt;
 289   unsigned int i;
 290   xbt_dict_t storage_list = xbt_dict_new_homogeneous(NULL);
 291   char *storage_name = NULL;
 292
 293   xbt_dynar_foreach(p_storage,i,mnt){
 294     storage_name = (char *)dynamic_cast<StoragePtr>(static_cast<ResourcePtr>(mnt.storage))->m_name;
 295     xbt_dict_set(storage_list,mnt.name,storage_name,NULL);
 296   }
 297   return storage_list;
 298 }
 299
 300 ActionPtr WorkstationCLM03::open(const char* mount, const char* path) {
 301   StoragePtr st = findStorageOnMountList(mount);
 302   XBT_DEBUG("OPEN on disk '%s'", st->m_name);
 303   return st->open(mount, path);
 304 }
 305
 306 ActionPtr WorkstationCLM03::close(surf_file_t fd) {
 307   StoragePtr st = findStorageOnMountList(fd->mount);
 308   XBT_DEBUG("CLOSE on disk '%s'",st->m_name);
 309   return st->close(fd);
 310 }
 311
 312 ActionPtr WorkstationCLM03::read(surf_file_t fd, sg_size_t size) {
 313   StoragePtr st = findStorageOnMountList(fd->mount);
 314   XBT_DEBUG("READ on disk '%s'",st->m_name);
 315   return st->read(fd, size);
 316 }
 317
 318 ActionPtr WorkstationCLM03::write(surf_file_t fd, sg_size_t size) {
 319   StoragePtr st = findStorageOnMountList(fd->mount);
 320   XBT_DEBUG("WRITE on disk '%s'",st->m_name);
 321   return st->write(fd, size);
 322 }
 323
 324 int WorkstationCLM03::unlink(surf_file_t fd) {
 325   if (!fd){
 326     XBT_WARN("No such file descriptor. Impossible to unlink");
 327     return 0;
 328   } else {
 329 //    XBT_INFO("%s %zu", fd->storage, fd->size);
 330     StoragePtr st = findStorageOnMountList(fd->mount);
 331     /* Check if the file is on this storage */
 332     if (!xbt_dict_get_or_null(st->p_content, fd->name)){
 333       XBT_WARN("File %s is not on disk %s. Impossible to unlink", fd->name,
 334           st->m_name);
 335       return 0;
 336     } else {
 337       XBT_DEBUG("UNLINK on disk '%s'",st->m_name);
 338       st->m_usedSize -= fd->size;
 339
 340       // Remove the file from storage
 341       xbt_dict_remove(st->p_content, fd->name);
 342
 343       free(fd->name);
 344       free(fd->mount);
 345       xbt_free(fd);
 346       return 1;
 347     }
 348   }
 349 }
 350
 351 ActionPtr WorkstationCLM03::ls(const char* mount, const char *path){
 352   XBT_DEBUG("LS on mount '%s' and file '%s'", mount, path);
 353   StoragePtr st = findStorageOnMountList(mount);
 354   return st->ls(path);
 355 }
 356
 357 sg_size_t WorkstationCLM03::getSize(surf_file_t fd){
 358   return fd->size;
 359 }
 360
 361 xbt_dynar_t WorkstationCLM03::getInfo( surf_file_t fd)
 362 {
 363   StoragePtr st = findStorageOnMountList(fd->mount);
 364   sg_size_t *psize = xbt_new(sg_size_t, 1);
 365   *psize = fd->size;
 366   xbt_dynar_t info = xbt_dynar_new(sizeof(void*), NULL);
 367   xbt_dynar_push_as(info, sg_size_t *, psize);
 368   xbt_dynar_push_as(info, void *, fd->mount);
 369   xbt_dynar_push_as(info, void *, (void *)st->m_name);
 370   xbt_dynar_push_as(info, void *, st->p_typeId);
 371   xbt_dynar_push_as(info, void *, st->p_contentType);
 372
 373   return info;
 374 }
 375
 376 sg_size_t WorkstationCLM03::getFreeSize(const char* name)
 377 {
 378   StoragePtr st = findStorageOnMountList(name);
 379   return st->m_size - st->m_usedSize;
 380 }
 381
 382 sg_size_t WorkstationCLM03::getUsedSize(const char* name)
 383 {
 384   StoragePtr st = findStorageOnMountList(name);
 385   return st->m_usedSize;
 386 }
 387
 388 e_surf_resource_state_t WorkstationCLM03Lmm::getState() {
 389   return WorkstationCLM03::getState();
 390 }
 391
 392 xbt_dynar_t WorkstationCLM03::getVms()
 393 {
 394   xbt_dynar_t dyn = xbt_dynar_new(sizeof(smx_host_t), NULL);
 395
 396   /* iterate for all hosts including virtual machines */
 397   xbt_lib_cursor_t cursor;
 398   char *key;
 399   void **ind_host;
 400   xbt_lib_foreach(host_lib, cursor, key, ind_host) {
 401     WorkstationCLM03Ptr ws_clm03 = dynamic_cast<WorkstationCLM03Ptr>(static_cast<ResourcePtr>(ind_host[SURF_WKS_LEVEL]));
 402     if (!ws_clm03)
 403       continue;
 404     /* skip if it is not a virtual machine */
 405     if (ws_clm03->p_model != static_cast<ModelPtr>(surf_vm_workstation_model))
 406       continue;
 407
 408     /* It is a virtual machine, so we can cast it to workstation_VM2013_t */
 409     WorkstationVM2013Ptr ws_vm2013 = dynamic_cast<WorkstationVM2013Ptr>(ws_clm03);
 410     if (this == ws_vm2013-> p_subWs)
 411       xbt_dynar_push(dyn, &ws_vm2013->p_subWs);
 412   }
 413
 414   return dyn;
 415 }
 416
 417 void WorkstationCLM03::getParams(ws_params_t params)
 418 {
 419   memcpy(params, &p_params, sizeof(s_ws_params_t));
 420 }
 421
 422 void WorkstationCLM03::setParams(ws_params_t params)
 423 {
 424   /* may check something here. */
 425   memcpy(&p_params, params, sizeof(s_ws_params_t));
 426 }
 427 /**********
 428  * Action *
 429  **********/