src/msg/msg_vm.c

   1 /* Copyright (c) 2012. 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 // QUESTIONS:
   7 // 1./ check how and where a new VM is added to the list of the hosts
   8 // 2./ Diff between SIMIX_Actions and SURF_Actions
   9 // => SIMIX_actions : point synchro entre processus de niveau (theoretically speaking I do not have to create such SIMIX_ACTION
  10 // =>  Surf_Actions
  11
  12 // TODO
  13 //      MSG_TRACE can be revisited in order to use  the host
  14 //      To implement a mixed model between workstation and vm_workstation,
  15 //     please give a look at surf_model_private_t model_private at SURF Level and to the share resource functions
  16 //     double (*share_resources) (double now);
  17 //      For the action into the vm workstation model, we should be able to leverage the usual one (and if needed, look at
  18 //              the workstation model.
  19
  20 #include "msg_private.h"
  21 #include "xbt/sysdep.h"
  22 #include "xbt/log.h"
  23
  24 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_vm, msg,
  25                                 "Cloud-oriented parts of the MSG API");
  26
  27
  28 /* **** ******** GENERAL ********* **** */
  29
  30 /** \ingroup m_vm_management
  31  * \brief Returns the value of a given vm property
  32  *
  33  * \param vm a vm
  34  * \param name a property name
  35  * \return value of a property (or NULL if property not set)
  36  */
  37
  38 const char *MSG_vm_get_property_value(msg_vm_t vm, const char *name)
  39 {
  40   return MSG_host_get_property_value(vm, name);
  41 }
  42
  43 /** \ingroup m_vm_management
  44  * \brief Returns a xbt_dict_t consisting of the list of properties assigned to this host
  45  *
  46  * \param vm a vm
  47  * \return a dict containing the properties
  48  */
  49 xbt_dict_t MSG_vm_get_properties(msg_vm_t vm)
  50 {
  51   xbt_assert((vm != NULL), "Invalid parameters (vm is NULL)");
  52
  53   return (simcall_host_get_properties(vm));
  54 }
  55
  56 /** \ingroup m_host_management
  57  * \brief Change the value of a given host property
  58  *
  59  * \param host a host
  60  * \param name a property name
  61  * \param value what to change the property to
  62  * \param free_ctn the freeing function to use to kill the value on need
  63  */
  64 void MSG_vm_set_property_value(msg_vm_t vm, const char *name, void *value, void_f_pvoid_t free_ctn)
  65 {
  66   xbt_dict_set(MSG_host_get_properties(vm), name, value, free_ctn);
  67 }
  68
  69 /** \ingroup msg_vm_management
  70  * \brief Finds a msg_vm_t using its name.
  71  *
  72  * This is a name directory service
  73  * \param name the name of a vm.
  74  * \return the corresponding vm
  75  *
  76  * Please note that a VM is a specific host. Hence, you should give a different name
  77  * for each VM/PM.
  78  */
  79
  80 msg_vm_t MSG_vm_get_by_name(const char *name)
  81 {
  82         return MSG_get_host_by_name(name);
  83 }
  84
  85 /** \ingroup m_vm_management
  86  *
  87  * \brief Return the name of the #msg_host_t.
  88  *
  89  * This functions checks whether \a host is a valid pointer or not and return
  90    its name.
  91  */
  92 const char *MSG_vm_get_name(msg_vm_t vm)
  93 {
  94   return MSG_host_get_name(vm);
  95 }
  96
  97
  98 /* **** Check state of a VM **** */
  99 static inline int __MSG_vm_is_state(msg_vm_t vm, e_surf_vm_state_t state)
 100 {
 101   return simcall_vm_get_state(vm) == state;
 102 }
 103
 104 /** @brief Returns whether the given VM has just reated, not running.
 105  *  @ingroup msg_VMs
 106  */
 107 int MSG_vm_is_created(msg_vm_t vm)
 108 {
 109   return __MSG_vm_is_state(vm, SURF_VM_STATE_CREATED);
 110 }
 111
 112 /** @brief Returns whether the given VM is currently running
 113  *  @ingroup msg_VMs
 114  */
 115 int MSG_vm_is_running(msg_vm_t vm)
 116 {
 117   return __MSG_vm_is_state(vm, SURF_VM_STATE_RUNNING);
 118 }
 119
 120 /** @brief Returns whether the given VM is currently migrating
 121  *  @ingroup msg_VMs
 122  */
 123 int MSG_vm_is_migrating(msg_vm_t vm)
 124 {
 125   return __MSG_vm_is_state(vm, SURF_VM_STATE_MIGRATING);
 126 }
 127
 128 /** @brief Returns whether the given VM is currently suspended, not running.
 129  *  @ingroup msg_VMs
 130  */
 131 int MSG_vm_is_suspended(msg_vm_t vm)
 132 {
 133   return __MSG_vm_is_state(vm, SURF_VM_STATE_SUSPENDED);
 134 }
 135
 136 /** @brief Returns whether the given VM is being saved (FIXME: live saving or not?).
 137  *  @ingroup msg_VMs
 138  */
 139 int MSG_vm_is_saving(msg_vm_t vm)
 140 {
 141   return __MSG_vm_is_state(vm, SURF_VM_STATE_SAVING);
 142 }
 143
 144 /** @brief Returns whether the given VM has been saved, not running.
 145  *  @ingroup msg_VMs
 146  */
 147 int MSG_vm_is_saved(msg_vm_t vm)
 148 {
 149   return __MSG_vm_is_state(vm, SURF_VM_STATE_SAVED);
 150 }
 151
 152 /** @brief Returns whether the given VM is being restored, not running.
 153  *  @ingroup msg_VMs
 154  */
 155 int MSG_vm_is_restoring(msg_vm_t vm)
 156 {
 157   return __MSG_vm_is_state(vm, SURF_VM_STATE_RESTORING);
 158 }
 159
 160
 161
 162 /* ------------------------------------------------------------------------- */
 163 /* ------------------------------------------------------------------------- */
 164
 165 /* **** ******** MSG vm actions ********* **** */
 166
 167 /** @brief Create a new VM with specified parameters.
 168  *  @ingroup msg_VMs*
 169  *  All parameters are in MBytes
 170  *
 171  */
 172 msg_vm_t MSG_vm_create(msg_host_t ind_pm, const char *name, int ncpus, int ramsize,
 173                                              int net_cap, char *disk_path, int disksize,
 174                                                  int mig_netspeed, int dp_intensity)
 175 {
 176         /* For the moment, intensity_rate is the percentage against the migration bandwidth */
 177         double host_speed = MSG_get_host_speed(ind_pm);
 178         double update_speed = ((double)dp_intensity/100) * mig_netspeed;
 179
 180         msg_vm_t vm = MSG_vm_create_core(ind_pm, name);
 181         s_ws_params_t params;
 182         memset(&params, 0, sizeof(params));
 183         params.ramsize = 1L * 1024 * 1024 * ramsize;
 184         //params.overcommit = 0;
 185         params.devsize = 0;
 186         params.skip_stage2 = 0;
 187         params.max_downtime = 0.03;
 188         params.dp_rate = (update_speed * 1L * 1024 * 1024 ) / host_speed;
 189         params.dp_cap = params.ramsize / 0.9; // working set memory is 90%
 190         params.mig_speed = 1L * 1024 * 1024 * mig_netspeed; // mig_speed
 191
 192    //XBT_INFO("dp rate %f migspeed : %f intensity mem : %d, updatespeed %f, hostspeed %f",params.dp_rate, params.mig_speed, dp_intensity, update_speed, host_speed);
 193         simcall_host_set_params(vm, &params);
 194
 195         return vm;
 196 }
 197
 198
 199 /** @brief Create a new VM object. The VM is not yet started. The resource of the VM is allocated upon MSG_vm_start().
 200  *  @ingroup msg_VMs*
 201  *
 202  * A VM is treated as a host. The name of the VM must be unique among all hosts.
 203  */
 204 msg_vm_t MSG_vm_create_core(msg_host_t ind_pm, const char *name)
 205 {
 206   /* make sure the VM of the same name does not exit */
 207   {
 208     void *ind_host_tmp = xbt_lib_get_elm_or_null(host_lib, name);
 209     if (ind_host_tmp) {
 210       XBT_ERROR("host %s already exits", name);
 211       return NULL;
 212     }
 213   }
 214
 215   /* Note: ind_vm and vm_workstation point to the same elm object. */
 216   msg_vm_t ind_vm = NULL;
 217   void *ind_vm_workstation =  NULL;
 218
 219   /* Ask the SIMIX layer to create the surf vm resource */
 220   ind_vm_workstation = simcall_vm_create(name, ind_pm);
 221   ind_vm = (msg_vm_t) __MSG_host_create(ind_vm_workstation);
 222
 223   XBT_DEBUG("A new VM (%s) has been created", name);
 224
 225   #ifdef HAVE_TRACING
 226   TRACE_msg_vm_create(name, ind_pm);
 227   #endif
 228
 229   return ind_vm;
 230 }
 231
 232 /** @brief Destroy a VM. Destroy the VM object from the simulation.
 233  *  @ingroup msg_VMs
 234  */
 235 void MSG_vm_destroy(msg_vm_t vm)
 236 {
 237   /* First, terminate all processes on the VM if necessary */
 238   if (MSG_vm_is_running(vm))
 239       simcall_vm_shutdown(vm);
 240
 241   if (!MSG_vm_is_created(vm)) {
 242     XBT_CRITICAL("shutdown the given VM before destroying it");
 243     DIE_IMPOSSIBLE;
 244   }
 245
 246   /* Then, destroy the VM object */
 247   simcall_vm_destroy(vm);
 248
 249   __MSG_host_destroy(vm);
 250
 251   #ifdef HAVE_TRACING
 252   TRACE_msg_vm_end(vm);
 253   #endif
 254 }
 255
 256
 257 /** @brief Start a vm (i.e., boot the guest operating system)
 258  *  @ingroup msg_VMs
 259  *
 260  *  If the VM cannot be started, an exception is generated.
 261  *
 262  */
 263 void MSG_vm_start(msg_vm_t vm)
 264 {
 265   simcall_vm_start(vm);
 266
 267   #ifdef HAVE_TRACING
 268   TRACE_msg_vm_start(vm);
 269   #endif
 270 }
 271
 272
 273
 274 /** @brief Immediately kills all processes within the given VM. Any memory that they allocated will be leaked.
 275  *  @ingroup msg_VMs
 276  *
 277  * FIXME: No extra delay occurs. If you want to simulate this too, you want to
 278  * use a #MSG_process_sleep() or something. I'm not quite sure.
 279  */
 280 void MSG_vm_shutdown(msg_vm_t vm)
 281 {
 282   /* msg_vm_t equals to msg_host_t */
 283   simcall_vm_shutdown(vm);
 284
 285   // #ifdef HAVE_TRACING
 286   // TRACE_msg_vm_(vm);
 287   // #endif
 288 }
 289
 290
 291
 292 /* We have two mailboxes. mbox is used to transfer migration data between
 293  * source and destiantion PMs. mbox_ctl is used to detect the completion of a
 294  * migration. The names of these mailboxes must not conflict with others. */
 295 static inline char *get_mig_mbox_src_dst(const char *vm_name, const char *src_pm_name, const char *dst_pm_name)
 296 {
 297   return bprintf("__mbox_mig_src_dst:%s(%s-%s)", vm_name, src_pm_name, dst_pm_name);
 298 }
 299
 300 static inline char *get_mig_mbox_ctl(const char *vm_name, const char *src_pm_name, const char *dst_pm_name)
 301 {
 302   return bprintf("__mbox_mig_ctl:%s(%s-%s)", vm_name, src_pm_name, dst_pm_name);
 303 }
 304
 305 static inline char *get_mig_process_tx_name(const char *vm_name, const char *src_pm_name, const char *dst_pm_name)
 306 {
 307   return bprintf("__pr_mig_tx:%s(%s-%s)", vm_name, src_pm_name, dst_pm_name);
 308 }
 309
 310 static inline char *get_mig_process_rx_name(const char *vm_name, const char *src_pm_name, const char *dst_pm_name)
 311 {
 312   return bprintf("__pr_mig_rx:%s(%s-%s)", vm_name, src_pm_name, dst_pm_name);
 313 }
 314
 315 static inline char *get_mig_task_name(const char *vm_name, const char *src_pm_name, const char *dst_pm_name, int stage)
 316 {
 317   return bprintf("__task_mig_stage%d:%s(%s-%s)", stage, vm_name, src_pm_name, dst_pm_name);
 318 }
 319
 320 static void launch_deferred_exec_process(msg_host_t host, double computation, double prio);
 321
 322 static int migration_rx_fun(int argc, char *argv[])
 323 {
 324   XBT_DEBUG("mig: rx_start");
 325
 326   xbt_assert(argc == 4);
 327   const char *vm_name = argv[1];
 328   const char *src_pm_name  = argv[2];
 329   const char *dst_pm_name  = argv[3];
 330   msg_vm_t vm = MSG_get_host_by_name(vm_name);
 331   msg_host_t src_pm = MSG_get_host_by_name(src_pm_name);
 332   msg_host_t dst_pm = MSG_get_host_by_name(dst_pm_name);
 333
 334
 335   s_ws_params_t params;
 336   simcall_host_get_params(vm, &params);
 337   const double xfer_cpu_overhead = params.xfer_cpu_overhead;
 338
 339
 340   int need_exit = 0;
 341
 342   char *mbox = get_mig_mbox_src_dst(vm_name, src_pm_name, dst_pm_name);
 343   char *mbox_ctl = get_mig_mbox_ctl(vm_name, src_pm_name, dst_pm_name);
 344   char *finalize_task_name = get_mig_task_name(vm_name, src_pm_name, dst_pm_name, 3);
 345
 346   for (;;) {
 347     msg_task_t task = NULL;
 348     MSG_task_recv(&task, mbox);
 349     {
 350       double received = MSG_task_get_data_size(task);
 351       /* TODO: clean up */
 352       // const double alpha = 0.22L * 1.0E8 / (80L * 1024 * 1024);
 353       launch_deferred_exec_process(vm, received * xfer_cpu_overhead, 1);
 354     }
 355
 356     if (strcmp(task->name, finalize_task_name) == 0)
 357       need_exit = 1;
 358
 359     MSG_task_destroy(task);
 360
 361     if (need_exit)
 362       break;
 363   }
 364
 365
 366   /* deinstall the current affinity setting */
 367   simcall_vm_set_affinity(vm, src_pm, 0);
 368
 369   simcall_vm_migrate(vm, dst_pm);
 370   simcall_vm_resume(vm);
 371
 372   /* install the affinity setting of the VM on the destination pm */
 373   {
 374     msg_host_priv_t priv = msg_host_resource_priv(vm);
 375
 376     unsigned long affinity_mask = (unsigned long) xbt_dict_get_or_null_ext(priv->affinity_mask_db, (char *) dst_pm, sizeof(msg_host_t));
 377     simcall_vm_set_affinity(vm, dst_pm, affinity_mask);
 378     XBT_INFO("set affinity(0x%04lx@%s) for %s", affinity_mask, MSG_host_get_name(dst_pm), MSG_host_get_name(vm));
 379   }
 380
 381   {
 382     char *task_name = get_mig_task_name(vm_name, src_pm_name, dst_pm_name, 4);
 383
 384     msg_task_t task = MSG_task_create(task_name, 0, 0, NULL);
 385     msg_error_t ret = MSG_task_send(task, mbox_ctl);
 386     xbt_assert(ret == MSG_OK);
 387
 388     xbt_free(task_name);
 389   }
 390
 391
 392   xbt_free(mbox);
 393   xbt_free(mbox_ctl);
 394   xbt_free(finalize_task_name);
 395
 396   XBT_DEBUG("mig: rx_done");
 397
 398   return 0;
 399 }
 400
 401 static void reset_dirty_pages(msg_vm_t vm)
 402 {
 403   msg_host_priv_t priv = msg_host_resource_priv(vm);
 404
 405   char *key = NULL;
 406   xbt_dict_cursor_t cursor = NULL;
 407   dirty_page_t dp = NULL;
 408   xbt_dict_foreach(priv->dp_objs, cursor, key, dp) {
 409     double remaining = MSG_task_get_remaining_computation(dp->task);
 410     dp->prev_clock = MSG_get_clock();
 411     dp->prev_remaining = remaining;
 412
 413     // XBT_INFO("%s@%s remaining %f", key, sg_host_name(vm), remaining);
 414   }
 415 }
 416
 417 static void start_dirty_page_tracking(msg_vm_t vm)
 418 {
 419   msg_host_priv_t priv = msg_host_resource_priv(vm);
 420   priv->dp_enabled = 1;
 421
 422   reset_dirty_pages(vm);
 423 }
 424
 425 static void stop_dirty_page_tracking(msg_vm_t vm)
 426 {
 427   msg_host_priv_t priv = msg_host_resource_priv(vm);
 428   priv->dp_enabled = 0;
 429 }
 430
 431 #if 0
 432 /* It might be natural that we define dp_rate for each task. But, we will also
 433  * have to care about how each task behavior affects the memory update behavior
 434  * at the operating system level. It may not be easy to model it with a simple algorithm. */
 435 double calc_updated_pages(char *key, msg_vm_t vm, dirty_page_t dp, double remaining, double clock)
 436 {
 437     double computed = dp->prev_remaining - remaining;
 438     double duration = clock - dp->prev_clock;
 439     double updated = dp->task->dp_rate * computed;
 440
 441     XBT_INFO("%s@%s: computated %f ops (remaining %f -> %f) in %f secs (%f -> %f)",
 442         key, sg_host_name(vm), computed, dp->prev_remaining, remaining, duration, dp->prev_clock, clock);
 443     XBT_INFO("%s@%s: updated %f bytes, %f Mbytes/s",
 444         key, sg_host_name(vm), updated, updated / duration / 1000 / 1000);
 445
 446     return updated;
 447 }
 448 #endif
 449
 450 static double get_computed(char *key, msg_vm_t vm, dirty_page_t dp, double remaining, double clock)
 451 {
 452   double computed = dp->prev_remaining - remaining;
 453   double duration = clock - dp->prev_clock;
 454
 455   XBT_DEBUG("%s@%s: computated %f ops (remaining %f -> %f) in %f secs (%f -> %f)",
 456       key, sg_host_name(vm), computed, dp->prev_remaining, remaining, duration, dp->prev_clock, clock);
 457
 458   return computed;
 459 }
 460
 461 static double lookup_computed_flop_counts(msg_vm_t vm, int stage_for_fancy_debug, int stage2_round_for_fancy_debug)
 462 {
 463   msg_host_priv_t priv = msg_host_resource_priv(vm);
 464   double total = 0;
 465
 466   char *key = NULL;
 467   xbt_dict_cursor_t cursor = NULL;
 468   dirty_page_t dp = NULL;
 469   xbt_dict_foreach(priv->dp_objs, cursor, key, dp) {
 470     double remaining = MSG_task_get_remaining_computation(dp->task);
 471
 472          double clock = MSG_get_clock();
 473
 474     // total += calc_updated_pages(key, vm, dp, remaining, clock);
 475     total += get_computed(key, vm, dp, remaining, clock);
 476
 477     dp->prev_remaining = remaining;
 478     dp->prev_clock = clock;
 479   }
 480
 481   total += priv->dp_updated_by_deleted_tasks;
 482
 483   XBT_DEBUG("mig-stage%d.%d: computed %f flop_counts (including %f by deleted tasks)",
 484       stage_for_fancy_debug,
 485       stage2_round_for_fancy_debug,
 486       total, priv->dp_updated_by_deleted_tasks);
 487
 488
 489
 490   priv->dp_updated_by_deleted_tasks = 0;
 491
 492
 493   return total;
 494 }
 495
 496 // TODO Is this code redundant with the information provided by
 497 // msg_process_t MSG_process_create(const char *name, xbt_main_func_t code, void *data, msg_host_t host)
 498 void MSG_host_add_task(msg_host_t host, msg_task_t task)
 499 {
 500   msg_host_priv_t priv = msg_host_resource_priv(host);
 501   double remaining = MSG_task_get_remaining_computation(task);
 502   char *key = bprintf("%s-%lld", task->name, task->counter);
 503
 504   dirty_page_t dp = xbt_new0(s_dirty_page, 1);
 505   dp->task = task;
 506
 507   /* It should be okay that we add a task onto a migrating VM. */
 508   if (priv->dp_enabled) {
 509     dp->prev_clock = MSG_get_clock();
 510     dp->prev_remaining = remaining;
 511   }
 512
 513   xbt_assert(xbt_dict_get_or_null(priv->dp_objs, key) == NULL);
 514   xbt_dict_set(priv->dp_objs, key, dp, NULL);
 515   XBT_DEBUG("add %s on %s (remaining %f, dp_enabled %d)", key, sg_host_name(host), remaining, priv->dp_enabled);
 516
 517   xbt_free(key);
 518 }
 519
 520 void MSG_host_del_task(msg_host_t host, msg_task_t task)
 521 {
 522   msg_host_priv_t priv = msg_host_resource_priv(host);
 523
 524   char *key = bprintf("%s-%lld", task->name, task->counter);
 525
 526   dirty_page_t dp = xbt_dict_get_or_null(priv->dp_objs, key);
 527   xbt_assert(dp->task == task);
 528
 529   /* If we are in the middle of dirty page tracking, we record how much
 530    * computaion has been done until now, and keep the information for the
 531    * lookup_() function that will called soon. */
 532   if (priv->dp_enabled) {
 533     double remaining = MSG_task_get_remaining_computation(task);
 534     double clock = MSG_get_clock();
 535     // double updated = calc_updated_pages(key, host, dp, remaining, clock);
 536     double updated = get_computed(key, host, dp, remaining, clock);
 537
 538     priv->dp_updated_by_deleted_tasks += updated;
 539   }
 540
 541   xbt_dict_remove(priv->dp_objs, key);
 542   xbt_free(dp);
 543
 544   XBT_DEBUG("del %s on %s", key, sg_host_name(host));
 545
 546   xbt_free(key);
 547 }
 548
 549
 550 static int deferred_exec_fun(int argc, char *argv[])
 551 {
 552   xbt_assert(argc == 3);
 553   const char *comp_str = argv[1];
 554   double computaion = atof(comp_str);
 555   const char *prio_str = argv[2];
 556   double prio = atof(prio_str);
 557
 558   msg_task_t task = MSG_task_create("__task_deferred", computaion, 0, NULL);
 559   // XBT_INFO("exec deferred %f", computaion);
 560
 561   /* dpt is the results of the VM activity */
 562   MSG_task_set_priority(task, prio);
 563   MSG_task_execute(task);
 564
 565
 566
 567   MSG_task_destroy(task);
 568
 569   return 0;
 570 }
 571
 572 static void launch_deferred_exec_process(msg_host_t host, double computation, double prio)
 573 {
 574   char *pr_name = bprintf("__pr_deferred_exec_%s", MSG_host_get_name(host));
 575
 576   int nargvs = 4;
 577   char **argv = xbt_new(char *, nargvs);
 578   argv[0] = xbt_strdup(pr_name);
 579   argv[1] = bprintf("%lf", computation);
 580   argv[2] = bprintf("%lf", prio);
 581   argv[3] = NULL;
 582
 583   MSG_process_create_with_arguments(pr_name, deferred_exec_fun, NULL, host, nargvs - 1, argv);
 584
 585   xbt_free(pr_name);
 586 }
 587
 588
 589 static int task_tx_overhead_fun(int argc, char *argv[])
 590 {
 591   xbt_assert(argc == 2);
 592   const char *mbox = argv[1];
 593
 594   int need_exit = 0;
 595
 596   // XBT_INFO("start %s", mbox);
 597
 598   for (;;) {
 599     msg_task_t task = NULL;
 600     MSG_task_recv(&task, mbox);
 601
 602     // XBT_INFO("task->name %s", task->name);
 603
 604     if (strcmp(task->name, "finalize_making_overhead") == 0)
 605       need_exit = 1;
 606
 607     // XBT_INFO("exec");
 608     // MSG_task_set_priority(task, 1000000);
 609     MSG_task_execute(task);
 610     MSG_task_destroy(task);
 611
 612     if (need_exit)
 613       break;
 614   }
 615
 616   // XBT_INFO("bye");
 617
 618   return 0;
 619 }
 620
 621 static void start_overhead_process(msg_task_t comm_task)
 622 {
 623   char *pr_name = bprintf("__pr_task_tx_overhead_%s", MSG_task_get_name(comm_task));
 624   char *mbox    = bprintf("__mb_task_tx_overhead_%s", MSG_task_get_name(comm_task));
 625
 626   int nargvs = 3;
 627   char **argv = xbt_new(char *, nargvs);
 628   argv[0] = xbt_strdup(pr_name);
 629   argv[1] = xbt_strdup(mbox);
 630   argv[2] = NULL;
 631
 632   // XBT_INFO("micro start: mbox %s", mbox);
 633   MSG_process_create_with_arguments(pr_name, task_tx_overhead_fun, NULL, MSG_host_self(), nargvs - 1, argv);
 634
 635   xbt_free(pr_name);
 636   xbt_free(mbox);
 637 }
 638
 639 static void shutdown_overhead_process(msg_task_t comm_task)
 640 {
 641   char *mbox = bprintf("__mb_task_tx_overhead_%s", MSG_task_get_name(comm_task));
 642
 643   msg_task_t task = MSG_task_create("finalize_making_overhead", 0, 0, NULL);
 644
 645   // XBT_INFO("micro shutdown: mbox %s", mbox);
 646   msg_error_t ret = MSG_task_send(task, mbox);
 647   xbt_assert(ret == MSG_OK);
 648
 649   xbt_free(mbox);
 650   // XBT_INFO("shutdown done");
 651 }
 652
 653 static void request_overhead(msg_task_t comm_task, double computation)
 654 {
 655   char *mbox = bprintf("__mb_task_tx_overhead_%s", MSG_task_get_name(comm_task));
 656
 657   msg_task_t task = MSG_task_create("micro", computation, 0, NULL);
 658
 659   // XBT_INFO("req overhead");
 660   msg_error_t ret = MSG_task_send(task, mbox);
 661   xbt_assert(ret == MSG_OK);
 662
 663   xbt_free(mbox);
 664 }
 665
 666 /* alpha is (floating_operations / bytes).
 667  *
 668  * When actual migration traffic was 32 mbytes/s, we observed the CPU
 669  * utilization of the main thread of the Qemu process was 10 %.
 670  *   alpha = 0.1 * C / (32 * 1024 * 1024)
 671  * where the CPU capacity of the PM is C flops/s.
 672  *
 673  * */
 674 static void task_send_bounded_with_cpu_overhead(msg_task_t comm_task, char *mbox, double mig_speed, double alpha)
 675 {
 676   const double chunk_size = 1024 * 1024 * 10;
 677   double remaining = MSG_task_get_data_size(comm_task);
 678
 679   start_overhead_process(comm_task);
 680
 681
 682   while (remaining > 0) {
 683     double data_size = chunk_size;
 684     if (remaining < chunk_size)
 685       data_size = remaining;
 686
 687     remaining -= data_size;
 688
 689     // XBT_INFO("remaining %f bytes", remaining);
 690
 691
 692     double clock_sta = MSG_get_clock();
 693
 694     /* create a micro task */
 695     {
 696       char *mtask_name = bprintf("__micro_%s", MSG_task_get_name(comm_task));
 697       msg_task_t mtask = MSG_task_create(mtask_name, 0, data_size, NULL);
 698
 699       request_overhead(comm_task, data_size * alpha);
 700
 701       msg_error_t ret = MSG_task_send(mtask, mbox);
 702       xbt_assert(ret == MSG_OK);
 703
 704       xbt_free(mtask_name);
 705     }
 706
 707 #if 0
 708     {
 709       /* In the real world, sending data involves small CPU computation. */
 710       char *mtask_name = bprintf("__micro_%s", MSG_task_get_name(comm_task));
 711       msg_task_t mtask = MSG_task_create(mtask_name, data_size * alpha, data_size, NULL);
 712       MSG_task_execute(mtask);
 713       MSG_task_destroy(mtask);
 714       xbt_free(mtask_name);
 715     }
 716 #endif
 717
 718     /* TODO */
 719
 720     double clock_end = MSG_get_clock();
 721
 722
 723     if (mig_speed > 0) {
 724       /*
 725        * (max bandwidth) > data_size / ((elapsed time) + time_to_sleep)
 726        *
 727        * Thus, we get
 728        *   time_to_sleep > data_size / (max bandwidth) - (elapsed time)
 729        *
 730        * If time_to_sleep is smaller than zero, the elapsed time was too big. We
 731        * do not need a micro sleep.
 732        **/
 733       double time_to_sleep = data_size / mig_speed - (clock_end - clock_sta);
 734       if (time_to_sleep > 0)
 735         MSG_process_sleep(time_to_sleep);
 736
 737
 738       //XBT_INFO("duration %f", clock_end - clock_sta);
 739       //XBT_INFO("time_to_sleep %f", time_to_sleep);
 740     }
 741   }
 742
 743   // XBT_INFO("%s", MSG_task_get_name(comm_task));
 744   shutdown_overhead_process(comm_task);
 745
 746 }
 747
 748
 749 #if 0
 750 static void make_cpu_overhead_of_data_transfer(msg_task_t comm_task, double init_comm_size)
 751 {
 752   double prev_remaining = init_comm_size;
 753
 754   for (;;) {
 755     double remaining = MSG_task_get_remaining_communication(comm_task);
 756     if (remaining == 0)
 757       need_exit = 1;
 758
 759     double sent = prev_remaining - remaining;
 760     double comp_size = sent * overhead;
 761
 762
 763     char *comp_task_name = bprintf("__sender_overhead%s", MSG_task_get_name(comm_task));
 764     msg_task_t comp_task = MSG_task_create(comp_task_name, comp_size, 0, NULL);
 765     MSG_task_execute(comp_task);
 766     MSG_task_destroy(comp_task);
 767
 768     if (need_exit)
 769       break;
 770
 771     prev_remaining = remaining;
 772
 773   }
 774
 775   xbt_free(comp_task_name);
 776 }
 777 #endif
 778
 779 // #define USE_MICRO_TASK 1
 780
 781 #if 0
 782 // const double alpha = 0.1L * 1.0E8 / (32L * 1024 * 1024);
 783 // const double alpha = 0.25L * 1.0E8 / (85L * 1024 * 1024);
 784 // const double alpha = 0.20L * 1.0E8 / (85L * 1024 * 1024);
 785 // const double alpha = 0.25L * 1.0E8 / (85L * 1024 * 1024);
 786 // const double alpha = 0.32L * 1.0E8 / (24L * 1024 * 1024);   // makes super good values for 32 mbytes/s
 787 //const double alpha = 0.32L * 1.0E8 / (32L * 1024 * 1024);
 788 // const double alpha = 0.56L * 1.0E8 / (80L * 1024 * 1024);
 789 ////const double alpha = 0.20L * 1.0E8 / (80L * 1024 * 1024);
 790 // const double alpha = 0.56L * 1.0E8 / (90L * 1024 * 1024);
 791 // const double alpha = 0.66L * 1.0E8 / (90L * 1024 * 1024);
 792 // const double alpha = 0.20L * 1.0E8 / (80L * 1024 * 1024);
 793
 794 /* CPU 22% when 80Mbyte/s */
 795 const double alpha = 0.22L * 1.0E8 / (80L * 1024 * 1024);
 796 #endif
 797
 798
 799 static void send_migration_data(const char *vm_name, const char *src_pm_name, const char *dst_pm_name,
 800     double size, char *mbox, int stage, int stage2_round, double mig_speed, double xfer_cpu_overhead)
 801 {
 802   char *task_name = get_mig_task_name(vm_name, src_pm_name, dst_pm_name, stage);
 803   msg_task_t task = MSG_task_create(task_name, 0, size, NULL);
 804
 805   /* TODO: clean up */
 806
 807   double clock_sta = MSG_get_clock();
 808
 809 #ifdef USE_MICRO_TASK
 810
 811   task_send_bounded_with_cpu_overhead(task, mbox, mig_speed, xfer_cpu_overhead);
 812
 813 #else
 814   msg_error_t ret;
 815   if (mig_speed > 0)
 816     ret = MSG_task_send_bounded(task, mbox, mig_speed);
 817   else
 818     ret = MSG_task_send(task, mbox);
 819   xbt_assert(ret == MSG_OK);
 820 #endif
 821
 822   double clock_end = MSG_get_clock();
 823   double duration = clock_end - clock_sta;
 824   double actual_speed = size / duration;
 825 #ifdef USE_MICRO_TASK
 826   double cpu_utilization = size * xfer_cpu_overhead / duration / 1.0E8;
 827 #else
 828   double cpu_utilization = 0;
 829 #endif
 830
 831
 832
 833
 834   if (stage == 2){
 835     XBT_DEBUG("mig-stage%d.%d: sent %f duration %f actual_speed %f (target %f) cpu %f", stage, stage2_round, size, duration, actual_speed, mig_speed, cpu_utilization);}
 836   else{
 837     XBT_DEBUG("mig-stage%d: sent %f duration %f actual_speed %f (target %f) cpu %f", stage, size, duration, actual_speed, mig_speed, cpu_utilization);
 838   }
 839
 840   xbt_free(task_name);
 841
 842
 843
 844 #ifdef USE_MICRO_TASK
 845   /* The name of a micro task starts with __micro, which does not match the
 846    * special name that finalizes the receiver loop. Thus, we send the special task.
 847    **/
 848   {
 849     if (stage == 3) {
 850       char *task_name = get_mig_task_name(vm_name, src_pm_name, dst_pm_name, stage);
 851       msg_task_t task = MSG_task_create(task_name, 0, 0, NULL);
 852       msg_error_t ret = MSG_task_send(task, mbox);
 853       xbt_assert(ret == MSG_OK);
 854       xbt_free(task_name);
 855     }
 856   }
 857 #endif
 858 }
 859
 860 static double get_updated_size(double computed, double dp_rate, double dp_cap)
 861 {
 862   double updated_size = computed * dp_rate;
 863   XBT_DEBUG("updated_size %f dp_rate %f", updated_size, dp_rate);
 864   if (updated_size > dp_cap) {
 865     // XBT_INFO("mig-stage2.%d: %f bytes updated, but cap it with the working set size %f", stage2_round, updated_size, dp_cap);
 866     updated_size = dp_cap;
 867   }
 868
 869   return updated_size;
 870 }
 871
 872 static double send_stage1(msg_host_t vm, const char *src_pm_name, const char *dst_pm_name,
 873     long ramsize, double mig_speed, double xfer_cpu_overhead, double dp_rate, double dp_cap, double dpt_cpu_overhead)
 874 {
 875   const char *vm_name = MSG_host_get_name(vm);
 876   char *mbox = get_mig_mbox_src_dst(vm_name, src_pm_name, dst_pm_name);
 877
 878   // const long chunksize = 1024 * 1024 * 100;
 879   const long chunksize = 1024L * 1024 * 100000;
 880   long remaining = ramsize;
 881   double computed_total = 0;
 882
 883   while (remaining > 0) {
 884     long datasize = chunksize;
 885     if (remaining < chunksize)
 886       datasize = remaining;
 887
 888     remaining -= datasize;
 889
 890     send_migration_data(vm_name, src_pm_name, dst_pm_name, datasize, mbox, 1, 0, mig_speed, xfer_cpu_overhead);
 891
 892     double computed = lookup_computed_flop_counts(vm, 1, 0);
 893     computed_total += computed;
 894
 895     // {
 896     //   double updated_size = get_updated_size(computed, dp_rate, dp_cap);
 897
 898     //   double overhead = dpt_cpu_overhead * updated_size;
 899     //   launch_deferred_exec_process(vm, overhead, 10000);
 900     // }
 901   }
 902
 903   return computed_total;
 904 }
 905
 906
 907
 908 static double get_threshold_value(double bandwidth, double max_downtime)
 909 {
 910   /* This value assumes the network link is 1Gbps. */
 911   // double threshold = max_downtime * 125 * 1024 * 1024;
 912   double threshold = max_downtime * bandwidth;
 913
 914   return threshold;
 915 }
 916
 917 static int migration_tx_fun(int argc, char *argv[])
 918 {
 919   XBT_DEBUG("mig: tx_start");
 920
 921   xbt_assert(argc == 4);
 922   const char *vm_name = argv[1];
 923   const char *src_pm_name  = argv[2];
 924   const char *dst_pm_name  = argv[3];
 925   msg_vm_t vm = MSG_get_host_by_name(vm_name);
 926
 927
 928   s_ws_params_t params;
 929   simcall_host_get_params(vm, &params);
 930   const long ramsize        = params.ramsize;
 931   const long devsize        = params.devsize;
 932   const int skip_stage1     = params.skip_stage1;
 933   const int skip_stage2     = params.skip_stage2;
 934   const double dp_rate      = params.dp_rate;
 935   const double dp_cap       = params.dp_cap;
 936   const double mig_speed    = params.mig_speed;
 937   const double xfer_cpu_overhead = params.xfer_cpu_overhead;
 938   const double dpt_cpu_overhead = params.dpt_cpu_overhead;
 939
 940   double remaining_size = ramsize + devsize;
 941
 942   double max_downtime = params.max_downtime;
 943   if (max_downtime == 0) {
 944     XBT_WARN("use the default max_downtime value 30ms");
 945     max_downtime = 0.03;
 946   }
 947
 948   double threshold = 0.00001; /* TODO: cleanup */
 949
 950   /* setting up parameters has done */
 951
 952
 953   if (ramsize == 0)
 954     XBT_WARN("migrate a VM, but ramsize is zero");
 955
 956   char *mbox = get_mig_mbox_src_dst(vm_name, src_pm_name, dst_pm_name);
 957
 958   XBT_INFO("mig-stage1: remaining_size %f", remaining_size);
 959
 960   /* Stage1: send all memory pages to the destination. */
 961   start_dirty_page_tracking(vm);
 962
 963   double computed_during_stage1 = 0;
 964   if (!skip_stage1) {
 965     // send_migration_data(vm_name, src_pm_name, dst_pm_name, ramsize, mbox, 1, 0, mig_speed, xfer_cpu_overhead);
 966
 967     /* send ramsize, but split it */
 968     double clock_prev_send = MSG_get_clock();
 969
 970     computed_during_stage1 = send_stage1(vm, src_pm_name, dst_pm_name, ramsize, mig_speed, xfer_cpu_overhead, dp_rate, dp_cap, dpt_cpu_overhead);
 971     remaining_size -= ramsize;
 972
 973     double clock_post_send = MSG_get_clock();
 974     double bandwidth = ramsize / (clock_post_send - clock_prev_send);
 975     threshold = get_threshold_value(bandwidth, max_downtime);
 976     XBT_INFO("actual banwdidth %f, threshold %f", bandwidth / 1024 / 1024, threshold);
 977   }
 978
 979
 980   /* Stage2: send update pages iteratively until the size of remaining states
 981    * becomes smaller than the threshold value. */
 982   if (skip_stage2)
 983     goto stage3;
 984   if (max_downtime == 0) {
 985     XBT_WARN("no max_downtime parameter, skip stage2");
 986     goto stage3;
 987   }
 988
 989
 990   int stage2_round = 0;
 991   for (;;) {
 992
 993     double updated_size = 0;
 994     if (stage2_round == 0)  {
 995       /* just after stage1, nothing has been updated. But, we have to send the data updated during stage1 */
 996       updated_size = get_updated_size(computed_during_stage1, dp_rate, dp_cap);
 997     } else {
 998       double computed = lookup_computed_flop_counts(vm, 2, stage2_round);
 999       updated_size = get_updated_size(computed, dp_rate, dp_cap);
1000     }
1001
1002     XBT_INFO("mig-stage 2:%d updated_size %f computed_during_stage1 %f dp_rate %f dp_cap %f",
1003         stage2_round, updated_size, computed_during_stage1, dp_rate, dp_cap);
1004
1005
1006     // if (stage2_round != 0) {
1007     //   /* during stage1, we have already created overhead tasks */
1008     //   double overhead = dpt_cpu_overhead * updated_size;
1009     //   XBT_DEBUG("updated %f overhead %f", updated_size, overhead);
1010     //   launch_deferred_exec_process(vm, overhead, 10000);
1011     // }
1012
1013
1014     {
1015       remaining_size += updated_size;
1016
1017       XBT_INFO("mig-stage2.%d: remaining_size %f (%s threshold %f)", stage2_round,
1018           remaining_size, (remaining_size < threshold) ? "<" : ">", threshold);
1019
1020       if (remaining_size < threshold)
1021         break;
1022     }
1023
1024     double clock_prev_send = MSG_get_clock();
1025
1026     send_migration_data(vm_name, src_pm_name, dst_pm_name, updated_size, mbox, 2, stage2_round, mig_speed, xfer_cpu_overhead);
1027
1028     double clock_post_send = MSG_get_clock();
1029
1030     double bandwidth = updated_size / (clock_post_send - clock_prev_send);
1031     threshold = get_threshold_value(bandwidth, max_downtime);
1032     XBT_INFO("actual banwdidth %f, threshold %f", bandwidth / 1024 / 1024, threshold);
1033
1034
1035
1036
1037
1038
1039
1040     remaining_size -= updated_size;
1041     stage2_round += 1;
1042   }
1043
1044
1045 stage3:
1046   /* Stage3: stop the VM and copy the rest of states. */
1047   XBT_INFO("mig-stage3: remaining_size %f", remaining_size);
1048   simcall_vm_suspend(vm);
1049   stop_dirty_page_tracking(vm);
1050
1051   send_migration_data(vm_name, src_pm_name, dst_pm_name, remaining_size, mbox, 3, 0, mig_speed, xfer_cpu_overhead);
1052
1053   xbt_free(mbox);
1054
1055   XBT_DEBUG("mig: tx_done");
1056
1057   return 0;
1058 }
1059
1060
1061
1062 static void do_migration(msg_vm_t vm, msg_host_t src_pm, msg_host_t dst_pm)
1063 {
1064   char *mbox_ctl = get_mig_mbox_ctl(sg_host_name(vm), sg_host_name(src_pm), sg_host_name(dst_pm));
1065
1066   {
1067     char *pr_name = get_mig_process_rx_name(sg_host_name(vm), sg_host_name(src_pm), sg_host_name(dst_pm));
1068     int nargvs = 5;
1069     char **argv = xbt_new(char *, nargvs);
1070     argv[0] = xbt_strdup(pr_name);
1071     argv[1] = xbt_strdup(sg_host_name(vm));
1072     argv[2] = xbt_strdup(sg_host_name(src_pm));
1073     argv[3] = xbt_strdup(sg_host_name(dst_pm));
1074     argv[4] = NULL;
1075
1076     MSG_process_create_with_arguments(pr_name, migration_rx_fun, NULL, dst_pm, nargvs - 1, argv);
1077
1078     xbt_free(pr_name);
1079   }
1080
1081   {
1082     char *pr_name = get_mig_process_tx_name(sg_host_name(vm), sg_host_name(src_pm), sg_host_name(dst_pm));
1083     int nargvs = 5;
1084     char **argv = xbt_new(char *, nargvs);
1085     argv[0] = xbt_strdup(pr_name);
1086     argv[1] = xbt_strdup(sg_host_name(vm));
1087     argv[2] = xbt_strdup(sg_host_name(src_pm));
1088     argv[3] = xbt_strdup(sg_host_name(dst_pm));
1089     argv[4] = NULL;
1090     MSG_process_create_with_arguments(pr_name, migration_tx_fun, NULL, src_pm, nargvs - 1, argv);
1091
1092     xbt_free(pr_name);
1093   }
1094
1095   /* wait until the migration have finished */
1096   {
1097     msg_task_t task = NULL;
1098     msg_error_t ret = MSG_task_recv(&task, mbox_ctl);
1099     xbt_assert(ret == MSG_OK);
1100
1101     char *expected_task_name = get_mig_task_name(sg_host_name(vm), sg_host_name(src_pm), sg_host_name(dst_pm), 4);
1102     xbt_assert(strcmp(task->name, expected_task_name) == 0);
1103     xbt_free(expected_task_name);
1104   }
1105
1106   xbt_free(mbox_ctl);
1107 }
1108
1109
1110 /** @brief Migrate the VM to the given host.
1111  *  @ingroup msg_VMs
1112  *
1113  * FIXME: No migration cost occurs. If you want to simulate this too, you want to use a
1114  * MSG_task_send() before or after, depending on whether you want to do cold or hot
1115  * migration.
1116  */
1117 void MSG_vm_migrate(msg_vm_t vm, msg_host_t new_pm)
1118 {
1119   /* some thoughts:
1120    * - One approach is ...
1121    *   We first create a new VM (i.e., destination VM) on the destination
1122    *   physical host. The destination VM will receive the state of the source
1123    *   VM over network. We will finally destroy the source VM.
1124    *   - This behavior is similar to the way of migration in the real world.
1125    *     Even before a migration is completed, we will see a destination VM,
1126    *     consuming resources.
1127    *   - We have to relocate all processes. The existing process migraion code
1128    *     will work for this?
1129    *   - The name of the VM is a somewhat unique ID in the code. It is tricky
1130    *     for the destination VM?
1131    *
1132    * - Another one is ...
1133    *   We update the information of the given VM to place it to the destination
1134    *   physical host.
1135    *
1136    * The second one would be easier.
1137    *
1138    */
1139
1140   msg_host_t old_pm = simcall_vm_get_pm(vm);
1141
1142   if (simcall_vm_get_state(vm) != SURF_VM_STATE_RUNNING)
1143     THROWF(vm_error, 0, "VM(%s) is not running", sg_host_name(vm));
1144
1145   do_migration(vm, old_pm, new_pm);
1146
1147
1148
1149   XBT_DEBUG("VM(%s) moved from PM(%s) to PM(%s)", vm->key, old_pm->key, new_pm->key);
1150
1151   #ifdef HAVE_TRACING
1152   TRACE_msg_vm_change_host(vm, old_pm, new_pm);
1153   #endif
1154 }
1155
1156
1157 /** @brief Immediately suspend the execution of all processes within the given VM.
1158  *  @ingroup msg_VMs
1159  *
1160  * This function stops the exection of the VM. All the processes on this VM
1161  * will pause. The state of the VM is perserved. We can later resume it again.
1162  *
1163  * No suspension cost occurs.
1164  */
1165 void MSG_vm_suspend(msg_vm_t vm)
1166 {
1167   simcall_vm_suspend(vm);
1168
1169   XBT_DEBUG("vm_suspend done");
1170
1171   #ifdef HAVE_TRACING
1172   TRACE_msg_vm_suspend(vm);
1173   #endif
1174 }
1175
1176
1177 /** @brief Resume the execution of the VM. All processes on the VM run again.
1178  *  @ingroup msg_VMs
1179  *
1180  * No resume cost occurs.
1181  */
1182 void MSG_vm_resume(msg_vm_t vm)
1183 {
1184   simcall_vm_resume(vm);
1185
1186   #ifdef HAVE_TRACING
1187   TRACE_msg_vm_resume(vm);
1188   #endif
1189 }
1190
1191
1192 /** @brief Immediately save the execution of all processes within the given VM.
1193  *  @ingroup msg_VMs
1194  *
1195  * This function stops the exection of the VM. All the processes on this VM
1196  * will pause. The state of the VM is perserved. We can later resume it again.
1197  *
1198  * FIXME: No suspension cost occurs. If you want to simulate this too, you want to
1199  * use a \ref MSG_file_write() before or after, depending on the exact semantic
1200  * of VM save to you.
1201  */
1202 void MSG_vm_save(msg_vm_t vm)
1203 {
1204   simcall_vm_save(vm);
1205   #ifdef HAVE_TRACING
1206   TRACE_msg_vm_save(vm);
1207   #endif
1208 }
1209
1210 /** @brief Restore the execution of the VM. All processes on the VM run again.
1211  *  @ingroup msg_VMs
1212  *
1213  * FIXME: No restore cost occurs. If you want to simulate this too, you want to
1214  * use a \ref MSG_file_read() before or after, depending on the exact semantic
1215  * of VM restore to you.
1216  */
1217 void MSG_vm_restore(msg_vm_t vm)
1218 {
1219   simcall_vm_restore(vm);
1220
1221   #ifdef HAVE_TRACING
1222   TRACE_msg_vm_restore(vm);
1223   #endif
1224 }
1225
1226
1227 /** @brief Get the physical host of a given VM.
1228  *  @ingroup msg_VMs
1229  */
1230 msg_host_t MSG_vm_get_pm(msg_vm_t vm)
1231 {
1232   return simcall_vm_get_pm(vm);
1233 }
1234
1235
1236 /** @brief Set a CPU bound for a given VM.
1237  *  @ingroup msg_VMs
1238  *
1239  * 1.
1240  * Note that in some cases MSG_task_set_bound() may not intuitively work for VMs.
1241  *
1242  * For example,
1243  *  On PM0, there are Task1 and VM0.
1244  *  On VM0, there is Task2.
1245  * Now we bound 75% to Task1@PM0 and bound 25% to Task2@VM0.
1246  * Then,
1247  *  Task1@PM0 gets 50%.
1248  *  Task2@VM0 gets 25%.
1249  * This is NOT 75% for Task1@PM0 and 25% for Task2@VM0, respectively.
1250  *
1251  * This is because a VM has the dummy CPU action in the PM layer. Putting a
1252  * task on the VM does not affect the bound of the dummy CPU action. The bound
1253  * of the dummy CPU action is unlimited.
1254  *
1255  * There are some solutions for this problem. One option is to update the bound
1256  * of the dummy CPU action automatically. It should be the sum of all tasks on
1257  * the VM. But, this solution might be costy, because we have to scan all tasks
1258  * on the VM in share_resource() or we have to trap both the start and end of
1259  * task execution.
1260  *
1261  * The current solution is to use MSG_vm_set_bound(), which allows us to
1262  * directly set the bound of the dummy CPU action.
1263  *
1264  *
1265  * 2.
1266  * Note that bound == 0 means no bound (i.e., unlimited). But, if a host has
1267  * multiple CPU cores, the CPU share of a computation task (or a VM) never
1268  * exceeds the capacity of a CPU core.
1269  */
1270 void MSG_vm_set_bound(msg_vm_t vm, double bound)
1271 {
1272         return simcall_vm_set_bound(vm, bound);
1273 }
1274
1275
1276 /** @brief Set the CPU affinity of a given VM.
1277  *  @ingroup msg_VMs
1278  *
1279  * This function changes the CPU affinity of a given VM. Usage is the same as
1280  * MSG_task_set_affinity(). See the MSG_task_set_affinity() for details.
1281  */
1282 void MSG_vm_set_affinity(msg_vm_t vm, msg_host_t pm, unsigned long mask)
1283 {
1284   msg_host_priv_t priv = msg_host_resource_priv(vm);
1285
1286   if (mask == 0)
1287     xbt_dict_remove_ext(priv->affinity_mask_db, (char *) pm, sizeof(pm));
1288   else
1289     xbt_dict_set_ext(priv->affinity_mask_db, (char *) pm, sizeof(pm), (void *) mask, NULL);
1290
1291   msg_host_t pm_now = MSG_vm_get_pm(vm);
1292   if (pm_now == pm) {
1293     XBT_INFO("set affinity(0x%04lx@%s) for %s", mask, MSG_host_get_name(pm), MSG_host_get_name(vm));
1294     simcall_vm_set_affinity(vm, pm, mask);
1295   } else
1296     XBT_INFO("set affinity(0x%04lx@%s) for %s (not active now)", mask, MSG_host_get_name(pm), MSG_host_get_name(vm));
1297 }