X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/0586543235cb7550a5952d01af0d4f656670c622..1915318b8c2435908c6471242a7de6e034710355:/src/msg/msg_vm.cpp

diff --git a/src/msg/msg_vm.cpp b/src/msg/msg_vm.cpp
index c70ff31bd4..5c268ac091 100644
--- a/src/msg/msg_vm.cpp
+++ b/src/msg/msg_vm.cpp
@@ -125,7 +125,7 @@ int MSG_vm_is_restoring(msg_vm_t vm)
  *  @param mig_netspeed Amount of Mbyte/s allocated to the migration (cannot be larger than net_cap). Use 0 if unsure.
  *  @param dp_intensity Dirty page percentage according to migNetSpeed, [0-100]. Use 0 if unsure.
  */
-msg_vm_t MSG_vm_create(msg_host_t pm, const char *name, int ncpus, int ramsize, int net_cap, char *disk_path,
+msg_vm_t MSG_vm_create(msg_host_t pm, const char* name, int ncpus, int ramsize, int net_cap, char* disk_path,
                        int disksize, int mig_netspeed, int dp_intensity)
 {
   simgrid::vm::VmHostExt::ensureVmExtInstalled();
@@ -158,28 +158,12 @@ msg_vm_t MSG_vm_create(msg_host_t pm, const char *name, int ncpus, int ramsize,
  *
  * A VM is treated as a host. The name of the VM must be unique among all hosts.
  */
-msg_vm_t MSG_vm_create_core(msg_host_t ind_pm, const char *name)
+msg_vm_t MSG_vm_create_core(msg_host_t pm, const char* name)
 {
-  /* make sure the VM of the same name does not exit */
-  {
-    simgrid::s4u::Host* ind_host_tmp = sg_host_by_name(name);
-    if (ind_host_tmp != nullptr && sg_host_simix(ind_host_tmp) != nullptr) {
-      XBT_ERROR("host %s already exits", name);
-      return nullptr;
-    }
-  }
-
-  /* Note: ind_vm and vm_workstation point to the same elm object. */
-  /* Ask the SIMIX layer to create the surf vm resource */
-  sg_host_t ind_vm_workstation = simcall_vm_create(name, ind_pm);
-
-  msg_vm_t ind_vm = (msg_vm_t) __MSG_host_create(ind_vm_workstation);
-
-  XBT_DEBUG("A new VM (%s) has been created", name);
+  xbt_assert(sg_host_by_name(name) == nullptr,
+             "Cannot create a VM named %s: this name is already used by an host or a VM", name);
 
-  TRACE_msg_vm_create(name, ind_pm);
-
-  return ind_vm;
+  return new simgrid::s4u::VirtualMachine(name, pm);
 }
 
 /** @brief Destroy a VM. Destroy the VM object from the simulation.
@@ -188,21 +172,24 @@ msg_vm_t MSG_vm_create_core(msg_host_t ind_pm, const char *name)
 void MSG_vm_destroy(msg_vm_t vm)
 {
   if (MSG_vm_is_migrating(vm))
-    THROWF(vm_error, 0, "VM(%s) is migrating", sg_host_get_name(vm));
+    THROWF(vm_error, 0, "Cannot destroy VM '%s', which is migrating.", vm->cname());
 
   /* First, terminate all processes on the VM if necessary */
   if (MSG_vm_is_running(vm))
-      simcall_vm_shutdown(vm);
+    MSG_vm_shutdown(vm);
 
-  if (!MSG_vm_is_created(vm)) {
-    XBT_CRITICAL("shutdown the given VM before destroying it");
-    DIE_IMPOSSIBLE;
-  }
+  xbt_assert(MSG_vm_is_created(vm), "shutdown the given VM before destroying it");
 
   /* Then, destroy the VM object */
-  simcall_vm_destroy(vm);
+  simgrid::simix::kernelImmediate([vm]() {
+    vm->destroy();
+  });
 
-  TRACE_msg_vm_end(vm);
+  if (TRACE_msg_vm_is_enabled()) {
+    container_t container = PJ_container_get(vm->name().c_str());
+    PJ_container_remove_from_parent(container);
+    PJ_container_free(container);
+  }
 }
 
 /** @brief Start a vm (i.e., boot the guest operating system)
@@ -214,7 +201,12 @@ void MSG_vm_start(msg_vm_t vm)
 {
   simcall_vm_start(vm);
 
-  TRACE_msg_vm_start(vm);
+  if (TRACE_msg_vm_is_enabled()) {
+    container_t vm_container = PJ_container_get(vm->name().c_str());
+    type_t type              = PJ_type_get("MSG_VM_STATE", vm_container->type);
+    val_t value              = PJ_value_get_or_new("start", "0 0 1", type); // start is blue
+    new_pajePushState(MSG_get_clock(), vm_container, type, value);
+  }
 }
 
 /** @brief Immediately kills all processes within the given VM. Any memory that they allocated will be leaked.
@@ -225,58 +217,26 @@ void MSG_vm_start(msg_vm_t vm)
  */
 void MSG_vm_shutdown(msg_vm_t vm)
 {
-  /* msg_vm_t equals to msg_host_t */
   simcall_vm_shutdown(vm);
-  MSG_process_sleep(0.); // Make sure that the processes in the VM are killed in this scheduling round before processing
-                         // (eg with the VM destroy)
-  // TRACE_msg_vm_(vm);
-}
 
-/* We have two mailboxes. mbox is used to transfer migration data between source and destination PMs. mbox_ctl is used
- * to detect the completion of a migration. The names of these mailboxes must not conflict with others. */
-static inline char *get_mig_mbox_src_dst(msg_vm_t vm, msg_host_t src_pm, msg_host_t dst_pm)
-{
-  const char *vm_name = sg_host_get_name(vm);
-  const char *src_pm_name = sg_host_get_name(src_pm);
-  const char *dst_pm_name = sg_host_get_name(dst_pm);
-
-  return bprintf("__mbox_mig_src_dst:%s(%s-%s)", vm_name, src_pm_name, dst_pm_name);
-}
-
-static inline char *get_mig_mbox_ctl(msg_vm_t vm, msg_host_t src_pm, msg_host_t dst_pm)
-{
-  const char *vm_name = sg_host_get_name(vm);
-  const char *src_pm_name = sg_host_get_name(src_pm);
-  const char *dst_pm_name = sg_host_get_name(dst_pm);
-
-  return bprintf("__mbox_mig_ctl:%s(%s-%s)", vm_name, src_pm_name, dst_pm_name);
+  // Make sure that the processes in the VM are killed in this scheduling round before processing
+  // (eg with the VM destroy)
+  MSG_process_sleep(0.);
 }
 
 static inline char *get_mig_process_tx_name(msg_vm_t vm, msg_host_t src_pm, msg_host_t dst_pm)
 {
-  const char *vm_name = sg_host_get_name(vm);
-  const char *src_pm_name = sg_host_get_name(src_pm);
-  const char *dst_pm_name = sg_host_get_name(dst_pm);
-
-  return bprintf("__pr_mig_tx:%s(%s-%s)", vm_name, src_pm_name, dst_pm_name);
+  return bprintf("__pr_mig_tx:%s(%s-%s)", vm->cname(), src_pm->cname(), dst_pm->cname());
 }
 
 static inline char *get_mig_process_rx_name(msg_vm_t vm, msg_host_t src_pm, msg_host_t dst_pm)
 {
-  const char *vm_name = sg_host_get_name(vm);
-  const char *src_pm_name = sg_host_get_name(src_pm);
-  const char *dst_pm_name = sg_host_get_name(dst_pm);
-
-  return bprintf("__pr_mig_rx:%s(%s-%s)", vm_name, src_pm_name, dst_pm_name);
+  return bprintf("__pr_mig_rx:%s(%s-%s)", vm->cname(), src_pm->cname(), dst_pm->cname());
 }
 
 static inline char *get_mig_task_name(msg_vm_t vm, msg_host_t src_pm, msg_host_t dst_pm, int stage)
 {
-  const char *vm_name = sg_host_get_name(vm);
-  const char *src_pm_name = sg_host_get_name(src_pm);
-  const char *dst_pm_name = sg_host_get_name(dst_pm);
-
-  return bprintf("__task_mig_stage%d:%s(%s-%s)", stage, vm_name, src_pm_name, dst_pm_name);
+  return bprintf("__task_mig_stage%d:%s(%s-%s)", stage, vm->cname(), src_pm->cname(), dst_pm->cname());
 }
 
 struct migration_session {
@@ -298,34 +258,26 @@ static int migration_rx_fun(int argc, char *argv[])
   // The structure has been created in the do_migration function and should only be freed in the same place ;)
   struct migration_session *ms = (migration_session *) MSG_process_get_data(MSG_process_self());
 
-  s_vm_params_t params;
-  static_cast<simgrid::s4u::VirtualMachine*>(ms->vm)->parameters(&params);
-
-  int need_exit = 0;
+  bool received_finalize = false;
 
   char *finalize_task_name = get_mig_task_name(ms->vm, ms->src_pm, ms->dst_pm, 3);
-
-  int ret = 0;
-  for (;;) {
+  while (!received_finalize) {
     msg_task_t task = nullptr;
-    ret = MSG_task_recv(&task, ms->mbox);
-    {
-      if (ret != MSG_OK) {
-        // An error occurred, clean the code and return
-        // The owner did not change, hence the task should be only destroyed on the other side
-        xbt_free(finalize_task_name);
-        return 0;
-      }
+    int ret         = MSG_task_recv(&task, ms->mbox);
+
+    if (ret != MSG_OK) {
+      // An error occurred, clean the code and return
+      // The owner did not change, hence the task should be only destroyed on the other side
+      xbt_free(finalize_task_name);
+      return 0;
     }
 
     if (strcmp(task->name, finalize_task_name) == 0)
-      need_exit = 1;
+      received_finalize = 1;
 
     MSG_task_destroy(task);
-
-    if (need_exit)
-      break;
   }
+  xbt_free(finalize_task_name);
 
   // Here Stage 1, 2  and 3 have been performed.
   // Hence complete the migration
@@ -351,11 +303,33 @@ static int migration_rx_fun(int argc, char *argv[])
   });
 
   {
-   // Now the VM is running on the new host (the migration is completed) (even if the SRC crash)
-   vm->pimpl_vm_->isMigrating = false;
-   XBT_DEBUG("VM(%s) moved from PM(%s) to PM(%s)", sg_host_get_name(ms->vm), sg_host_get_name(ms->src_pm),
-             sg_host_get_name(ms->dst_pm));
-   TRACE_msg_vm_change_host(ms->vm, ms->src_pm, ms->dst_pm);
+    // Now the VM is running on the new host (the migration is completed) (even if the SRC crash)
+    vm->pimpl_vm_->isMigrating = false;
+    XBT_DEBUG("VM(%s) moved from PM(%s) to PM(%s)", ms->vm->cname(), ms->src_pm->cname(), ms->dst_pm->cname());
+
+    if (TRACE_msg_vm_is_enabled()) {
+      static long long int counter = 0;
+      char key[INSTR_DEFAULT_STR_SIZE];
+      snprintf(key, INSTR_DEFAULT_STR_SIZE, "%lld", counter++);
+
+      // start link
+      container_t msg = PJ_container_get(vm->name().c_str());
+      type_t type     = PJ_type_get("MSG_VM_LINK", PJ_type_get_root());
+      new_pajeStartLink(MSG_get_clock(), PJ_container_get_root(), type, msg, "M", key);
+
+      // destroy existing container of this vm
+      container_t existing_container = PJ_container_get(vm->name().c_str());
+      PJ_container_remove_from_parent(existing_container);
+      PJ_container_free(existing_container);
+
+      // create new container on the new_host location
+      PJ_container_new(vm->cname(), INSTR_MSG_VM, PJ_container_get(sg_host_get_name(ms->dst_pm)));
+
+      // end link
+      msg  = PJ_container_get(vm->name().c_str());
+      type = PJ_type_get("MSG_VM_LINK", PJ_type_get_root());
+      new_pajeEndLink(MSG_get_clock(), PJ_container_get_root(), type, msg, "M", key);
+    }
   }
   // Inform the SRC that the migration has been correctly performed
   {
@@ -375,21 +349,21 @@ static int migration_rx_fun(int argc, char *argv[])
     xbt_free(task_name);
   }
 
-  xbt_free(finalize_task_name);
-
   XBT_DEBUG("mig: rx_done");
   return 0;
 }
 
-static void reset_dirty_pages(msg_vm_t vm)
+static void start_dirty_page_tracking(msg_vm_t vm)
 {
-  simgrid::surf::VirtualMachineImpl* pimpl = static_cast<simgrid::surf::VirtualMachineImpl*>(vm->pimpl_);
+  simgrid::surf::VirtualMachineImpl* pimpl = static_cast<simgrid::s4u::VirtualMachine*>(vm)->pimpl_vm_;
+
+  pimpl->dp_enabled = 1;
+  if (!pimpl->dp_objs)
+    return;
 
   char *key = nullptr;
   xbt_dict_cursor_t cursor = nullptr;
   dirty_page_t dp = nullptr;
-  if (!pimpl->dp_objs)
-    return;
   xbt_dict_foreach (pimpl->dp_objs, cursor, key, dp) {
     double remaining = MSG_task_get_flops_amount(dp->task);
     dp->prev_clock = MSG_get_clock();
@@ -399,13 +373,6 @@ static void reset_dirty_pages(msg_vm_t vm)
   }
 }
 
-static void start_dirty_page_tracking(msg_vm_t vm)
-{
-  static_cast<simgrid::s4u::VirtualMachine*>(vm)->pimpl_vm_->dp_enabled = 1;
-
-  reset_dirty_pages(vm);
-}
-
 static void stop_dirty_page_tracking(msg_vm_t vm)
 {
   static_cast<simgrid::s4u::VirtualMachine*>(vm)->pimpl_vm_->dp_enabled = 0;
@@ -460,7 +427,7 @@ void MSG_host_add_task(msg_host_t host, msg_task_t task)
   simgrid::s4u::VirtualMachine* vm = dynamic_cast<simgrid::s4u::VirtualMachine*>(host);
   if (vm == nullptr)
     return;
-  simgrid::surf::VirtualMachineImpl* pimpl = static_cast<simgrid::surf::VirtualMachineImpl*>(vm->pimpl_);
+  simgrid::surf::VirtualMachineImpl* pimpl = static_cast<simgrid::s4u::VirtualMachine*>(vm)->pimpl_vm_;
 
   double remaining = MSG_task_get_flops_amount(task);
   char *key = bprintf("%s-%p", task->name, task);
@@ -485,7 +452,7 @@ void MSG_host_del_task(msg_host_t host, msg_task_t task)
   simgrid::s4u::VirtualMachine* vm = dynamic_cast<simgrid::s4u::VirtualMachine*>(host);
   if (vm == nullptr)
     return;
-  simgrid::surf::VirtualMachineImpl* pimpl = static_cast<simgrid::surf::VirtualMachineImpl*>(vm->pimpl_);
+  simgrid::surf::VirtualMachineImpl* pimpl = static_cast<simgrid::s4u::VirtualMachine*>(vm)->pimpl_vm_;
 
   char *key = bprintf("%s-%p", task->name, task);
   dirty_page_t dp = (dirty_page_t)(pimpl->dp_objs ? xbt_dict_get_or_null(pimpl->dp_objs, key) : NULL);
@@ -509,7 +476,7 @@ void MSG_host_del_task(msg_host_t host, msg_task_t task)
   xbt_free(key);
 }
 
-static sg_size_t send_migration_data(msg_vm_t vm, msg_host_t src_pm, msg_host_t dst_pm, sg_size_t size, char *mbox,
+static sg_size_t send_migration_data(msg_vm_t vm, msg_host_t src_pm, msg_host_t dst_pm, sg_size_t size, char* mbox,
                                      int stage, int stage2_round, double mig_speed, double timeout)
 {
   sg_size_t sent = 0;
@@ -552,11 +519,11 @@ static sg_size_t send_migration_data(msg_vm_t vm, msg_host_t src_pm, msg_host_t
   double actual_speed = size / duration;
 
   if (stage == 2)
-    XBT_DEBUG("mig-stage%d.%d: sent %llu duration %f actual_speed %f (target %f)",
-              stage, stage2_round, size, duration, actual_speed, mig_speed);
+    XBT_DEBUG("mig-stage%d.%d: sent %llu duration %f actual_speed %f (target %f)", stage, stage2_round, size, duration,
+              actual_speed, mig_speed);
   else
-    XBT_DEBUG("mig-stage%d: sent %llu duration %f actual_speed %f (target %f)",
-              stage, size, duration, actual_speed, mig_speed);
+    XBT_DEBUG("mig-stage%d: sent %llu duration %f actual_speed %f (target %f)", stage, size, duration, actual_speed,
+              mig_speed);
 
   return sent;
 }
@@ -574,7 +541,7 @@ static sg_size_t get_updated_size(double computed, double dp_rate, double dp_cap
   return (sg_size_t) updated_size;
 }
 
-static double send_stage1(struct migration_session *ms, sg_size_t ramsize, double mig_speed, double dp_rate,
+static double send_stage1(struct migration_session* ms, sg_size_t ramsize, double mig_speed, double dp_rate,
                           double dp_cap)
 {
   // const long chunksize = (sg_size_t)1024 * 1024 * 100;
@@ -681,70 +648,70 @@ static int migration_tx_fun(int argc, char *argv[])
 
 
   /* Stage2: send update pages iteratively until the size of remaining states becomes smaller than threshold value. */
- if (! skip_stage2) {
-
-  int stage2_round = 0;
-  for (;;) {
-
-    sg_size_t updated_size = 0;
-    if (stage2_round == 0) {
-      /* just after stage1, nothing has been updated. But, we have to send the data updated during stage1 */
-      updated_size = get_updated_size(computed_during_stage1, dp_rate, dp_cap);
-    } else {
-      double computed = lookup_computed_flop_counts(ms->vm, 2, stage2_round);
-      updated_size = get_updated_size(computed, dp_rate, dp_cap);
-    }
-
-    XBT_DEBUG("mig-stage 2:%d updated_size %llu computed_during_stage1 %f dp_rate %f dp_cap %f",
-        stage2_round, updated_size, computed_during_stage1, dp_rate, dp_cap);
-
-    /* Check whether the remaining size is below the threshold value. If so, move to stage 3. */
-    remaining_size += updated_size;
-    XBT_DEBUG("mig-stage2.%d: remaining_size %f (%s threshold %f)", stage2_round,
-        remaining_size, (remaining_size < threshold) ? "<" : ">", threshold);
-    if (remaining_size < threshold)
-      break;
-
-    sg_size_t sent = 0;
-    double clock_prev_send = MSG_get_clock();
-    try {
-      XBT_DEBUG("Stage 2, gonna send %llu", updated_size);
-      sent = send_migration_data(ms->vm, ms->src_pm, ms->dst_pm, updated_size, ms->mbox, 2, stage2_round, mig_speed,
-                                 mig_timeout);
-    }
-    catch (xbt_ex& e) {
-      //hostfailure (if you want to know whether this is the SRC or the DST check directly in send_migration_data code)
-      // Stop the dirty page tracking an return (there is no memory space to release)
-      stop_dirty_page_tracking(ms->vm);
-      return 0;
-    }
-    double clock_post_send = MSG_get_clock();
+  if (!skip_stage2) {
+
+    int stage2_round = 0;
+    for (;;) {
+
+      sg_size_t updated_size = 0;
+      if (stage2_round == 0) {
+        /* just after stage1, nothing has been updated. But, we have to send the data updated during stage1 */
+        updated_size = get_updated_size(computed_during_stage1, dp_rate, dp_cap);
+      } else {
+        double computed = lookup_computed_flop_counts(ms->vm, 2, stage2_round);
+        updated_size    = get_updated_size(computed, dp_rate, dp_cap);
+      }
 
-    if (sent == updated_size) {
-      /* timeout did not happen */
-      double bandwidth = updated_size / (clock_post_send - clock_prev_send);
-      threshold = get_threshold_value(bandwidth, max_downtime);
-      XBT_DEBUG("actual bandwidth %f, threshold %f", bandwidth / 1024 / 1024, threshold);
-      remaining_size -= sent;
-      stage2_round += 1;
-      mig_timeout -= (clock_post_send - clock_prev_send);
-      xbt_assert(mig_timeout > 0);
-
-    } else if (sent < updated_size) {
-      /* When timeout happens, we move to stage 3. The size of memory pages
-       * updated before timeout must be added to the remaining size. */
-      XBT_VERB("mig-stage2.%d: timeout, force moving to stage 3. sent %llu / %llu, eta %lf",
-          stage2_round, sent, updated_size, (clock_post_send - clock_prev_send));
-      remaining_size -= sent;
+      XBT_DEBUG("mig-stage 2:%d updated_size %llu computed_during_stage1 %f dp_rate %f dp_cap %f", stage2_round,
+                updated_size, computed_during_stage1, dp_rate, dp_cap);
 
-      double computed = lookup_computed_flop_counts(ms->vm, 2, stage2_round);
-      updated_size = get_updated_size(computed, dp_rate, dp_cap);
+      /* Check whether the remaining size is below the threshold value. If so, move to stage 3. */
       remaining_size += updated_size;
-      break;
-    } else
-      XBT_CRITICAL("bug");
+      XBT_DEBUG("mig-stage2.%d: remaining_size %f (%s threshold %f)", stage2_round, remaining_size,
+                (remaining_size < threshold) ? "<" : ">", threshold);
+      if (remaining_size < threshold)
+        break;
+
+      sg_size_t sent         = 0;
+      double clock_prev_send = MSG_get_clock();
+      try {
+        XBT_DEBUG("Stage 2, gonna send %llu", updated_size);
+        sent = send_migration_data(ms->vm, ms->src_pm, ms->dst_pm, updated_size, ms->mbox, 2, stage2_round, mig_speed,
+                                   mig_timeout);
+      } catch (xbt_ex& e) {
+        // hostfailure (if you want to know whether this is the SRC or the DST check directly in send_migration_data
+        // code)
+        // Stop the dirty page tracking an return (there is no memory space to release)
+        stop_dirty_page_tracking(ms->vm);
+        return 0;
+      }
+      double clock_post_send = MSG_get_clock();
+
+      if (sent == updated_size) {
+        /* timeout did not happen */
+        double bandwidth = updated_size / (clock_post_send - clock_prev_send);
+        threshold        = get_threshold_value(bandwidth, max_downtime);
+        XBT_DEBUG("actual bandwidth %f, threshold %f", bandwidth / 1024 / 1024, threshold);
+        remaining_size -= sent;
+        stage2_round += 1;
+        mig_timeout -= (clock_post_send - clock_prev_send);
+        xbt_assert(mig_timeout > 0);
+
+      } else if (sent < updated_size) {
+        /* When timeout happens, we move to stage 3. The size of memory pages
+         * updated before timeout must be added to the remaining size. */
+        XBT_VERB("mig-stage2.%d: timeout, force moving to stage 3. sent %llu / %llu, eta %lf", stage2_round, sent,
+                 updated_size, (clock_post_send - clock_prev_send));
+        remaining_size -= sent;
+
+        double computed = lookup_computed_flop_counts(ms->vm, 2, stage2_round);
+        updated_size    = get_updated_size(computed, dp_rate, dp_cap);
+        remaining_size += updated_size;
+        break;
+      } else
+        XBT_CRITICAL("bug");
+    }
   }
- }
 
   /* Stage3: stop the VM and copy the rest of states. */
   XBT_DEBUG("mig-stage3: remaining_size %f", remaining_size);
@@ -775,63 +742,54 @@ static int do_migration(msg_vm_t vm, msg_host_t src_pm, msg_host_t dst_pm)
   ms->vm = vm;
   ms->src_pm = src_pm;
   ms->dst_pm = dst_pm;
-  ms->mbox_ctl = get_mig_mbox_ctl(vm, src_pm, dst_pm);
-  ms->mbox = get_mig_mbox_src_dst(vm, src_pm, dst_pm);
+
+  /* We have two mailboxes. mbox is used to transfer migration data between source and destination PMs. mbox_ctl is used
+   * to detect the completion of a migration. The names of these mailboxes must not conflict with others. */
+  ms->mbox_ctl = bprintf("__mbox_mig_ctl:%s(%s-%s)", vm->cname(), src_pm->cname(), dst_pm->cname());
+  ms->mbox     = bprintf("__mbox_mig_src_dst:%s(%s-%s)", vm->cname(), src_pm->cname(), dst_pm->cname());
 
   char *pr_rx_name = get_mig_process_rx_name(vm, src_pm, dst_pm);
   char *pr_tx_name = get_mig_process_tx_name(vm, src_pm, dst_pm);
 
-//  msg_process_t tx_process, rx_process; 
-//  MSG_process_create(pr_rx_name, migration_rx_fun, ms, dst_pm);
-//  MSG_process_create(pr_tx_name, migration_tx_fun, ms, src_pm);
-#if 1
- {
- char **argv = xbt_new(char *, 2);
- argv[0] = pr_rx_name;
- argv[1] = nullptr;
-/*rx_process = */ MSG_process_create_with_arguments(pr_rx_name, migration_rx_fun, ms, dst_pm, 1, argv);
- }
- {
- char **argv = xbt_new(char *, 2);
- argv[0] = pr_tx_name;
- argv[1] = nullptr;
-/* tx_process = */MSG_process_create_with_arguments(pr_tx_name, migration_tx_fun, ms, src_pm, 1, argv);
- }
-#endif
-
-  /* wait until the migration have finished or on error has occurred */
-  {
-    XBT_DEBUG("wait for reception of the final ACK (i.e. migration has been correctly performed");
-    msg_task_t task = nullptr;
-    msg_error_t ret = MSG_TIMEOUT;
-    while (ret == MSG_TIMEOUT && MSG_host_is_on(dst_pm)) //Wait while you receive the message o
-     ret = MSG_task_receive_with_timeout(&task, ms->mbox_ctl, 4);
-
-    xbt_free(ms->mbox_ctl);
-    xbt_free(ms->mbox);
-    xbt_free(ms);
+  char** argv = xbt_new(char*, 2);
+  argv[0]     = pr_rx_name;
+  argv[1]     = nullptr;
+  MSG_process_create_with_arguments(pr_rx_name, migration_rx_fun, ms, dst_pm, 1, argv);
 
-    //xbt_assert(ret == MSG_OK);
-    if(ret == MSG_HOST_FAILURE){
-        // Note that since the communication failed, the owner did not change and the task should be destroyed on the
-        // other side. Hence, just throw the execption
-        XBT_ERROR("SRC crashes, throw an exception (m-control)");
-        //MSG_process_kill(tx_process); // Adrien, I made a merge on Nov 28th 2014, I'm not sure whether this line is
-                                        // required or not
-        return -1; 
-    } 
-    else if((ret == MSG_TRANSFER_FAILURE) || (ret == MSG_TIMEOUT)){
-        // MSG_TIMEOUT here means that MSG_host_is_avail() returned false.
-        XBT_ERROR("DST crashes, throw an exception (m-control)");
-        return -2;  
-    }
+  argv        = xbt_new(char*, 2);
+  argv[0]     = pr_tx_name;
+  argv[1]     = nullptr;
+  MSG_process_create_with_arguments(pr_tx_name, migration_tx_fun, ms, src_pm, 1, argv);
 
-    char *expected_task_name = get_mig_task_name(vm, src_pm, dst_pm, 4);
-    xbt_assert(strcmp(task->name, expected_task_name) == 0);
-    xbt_free(expected_task_name);
-    MSG_task_destroy(task);
-    return 0;
+  /* wait until the migration have finished or on error has occurred */
+  XBT_DEBUG("wait for reception of the final ACK (i.e. migration has been correctly performed");
+  msg_task_t task = nullptr;
+  msg_error_t ret = MSG_TIMEOUT;
+  while (ret == MSG_TIMEOUT && MSG_host_is_on(dst_pm)) // Wait while you receive the message o
+    ret = MSG_task_receive_with_timeout(&task, ms->mbox_ctl, 4);
+
+  xbt_free(ms->mbox_ctl);
+  xbt_free(ms->mbox);
+  xbt_free(ms);
+
+  if (ret == MSG_HOST_FAILURE) {
+    // Note that since the communication failed, the owner did not change and the task should be destroyed on the
+    // other side. Hence, just throw the execption
+    XBT_ERROR("SRC crashes, throw an exception (m-control)");
+    // MSG_process_kill(tx_process); // Adrien, I made a merge on Nov 28th 2014, I'm not sure whether this line is
+    // required or not
+    return -1;
+  } else if ((ret == MSG_TRANSFER_FAILURE) || (ret == MSG_TIMEOUT)) {
+    // MSG_TIMEOUT here means that MSG_host_is_avail() returned false.
+    XBT_ERROR("DST crashes, throw an exception (m-control)");
+    return -2;
   }
+
+  char* expected_task_name = get_mig_task_name(vm, src_pm, dst_pm, 4);
+  xbt_assert(strcmp(task->name, expected_task_name) == 0);
+  xbt_free(expected_task_name);
+  MSG_task_destroy(task);
+  return 0;
 }
 
 /** @brief Migrate the VM to the given host.
@@ -858,39 +816,33 @@ void MSG_vm_migrate(msg_vm_t vm, msg_host_t new_pm)
    * The second one would be easier.
    */
 
-  msg_host_t old_pm = (msg_host_t) simcall_vm_get_pm(vm);
+  simgrid::s4u::VirtualMachine* typedVm    = static_cast<simgrid::s4u::VirtualMachine*>(vm);
+  simgrid::surf::VirtualMachineImpl* pimpl = typedVm->pimpl_vm_;
+  msg_host_t old_pm                        = pimpl->getPm();
 
-  if(MSG_host_is_off(old_pm))
-    THROWF(vm_error, 0, "SRC host(%s) seems off, cannot start a migration", sg_host_get_name(old_pm));
+  if (old_pm->isOff())
+    THROWF(vm_error, 0, "Cannot migrate VM '%s' from host '%s', which is offline.", vm->cname(), old_pm->cname());
 
-  if(MSG_host_is_off(new_pm))
-    THROWF(vm_error, 0, "DST host(%s) seems off, cannot start a migration", sg_host_get_name(new_pm));
+  if (new_pm->isOff())
+    THROWF(vm_error, 0, "Cannot migrate VM '%s' to host '%s', which is offline.", vm->cname(), new_pm->cname());
 
   if (!MSG_vm_is_running(vm))
-    THROWF(vm_error, 0, "VM(%s) is not running", sg_host_get_name(vm));
+    THROWF(vm_error, 0, "Cannot migrate VM '%s' that is not running yet.", vm->cname());
 
-  if (MSG_vm_is_migrating(vm))
-    THROWF(vm_error, 0, "VM(%s) is already migrating", sg_host_get_name(vm));
+  if (typedVm->isMigrating())
+    THROWF(vm_error, 0, "Cannot migrate VM '%s' that is already migrating.", vm->cname());
 
-  simgrid::surf::VirtualMachineImpl* pimpl = static_cast<simgrid::surf::VirtualMachineImpl*>(vm->pimpl_);
-  pimpl->isMigrating                       = 1;
+  pimpl->isMigrating = true;
 
-  {
-    int ret = do_migration(vm, old_pm, new_pm);
-    if (ret == -1){
-      pimpl->isMigrating = 0;
-      THROWF(host_error, 0, "SRC host failed during migration");
-    }
-    else if(ret == -2){
-      pimpl->isMigrating = 0;
-      THROWF(host_error, 0, "DST host failed during migration");
-    }
+  int ret = do_migration(vm, old_pm, new_pm);
+  if (ret == -1) {
+    pimpl->isMigrating = false;
+    THROWF(host_error, 0, "Source host '%s' failed during the migration of VM '%s'.", old_pm->cname(), vm->cname());
+  } else if (ret == -2) {
+    pimpl->isMigrating = false;
+    THROWF(host_error, 0, "Destination host '%s' failed during the migration of VM '%s'.", new_pm->cname(),
+           vm->cname());
   }
-
-  // This part is done in the RX code, to handle the corner case where SRC can crash just at the end of the migration
-  // process. In that case, the VM has been already assigned to the DST node.
-  //XBT_DEBUG("VM(%s) moved from PM(%s) to PM(%s)", vm->key, old_pm->key, new_pm->key);
-  //TRACE_msg_vm_change_host(vm, old_pm, new_pm);
 }
 
 /** @brief Immediately suspend the execution of all processes within the given VM.
@@ -904,13 +856,18 @@ void MSG_vm_migrate(msg_vm_t vm, msg_host_t new_pm)
 void MSG_vm_suspend(msg_vm_t vm)
 {
   if (MSG_vm_is_migrating(vm))
-    THROWF(vm_error, 0, "VM(%s) is migrating", sg_host_get_name(vm));
+    THROWF(vm_error, 0, "Cannot suspend VM '%s', which is migrating", vm->cname());
 
   simcall_vm_suspend(vm);
 
   XBT_DEBUG("vm_suspend done");
 
-  TRACE_msg_vm_suspend(vm);
+  if (TRACE_msg_vm_is_enabled()) {
+    container_t vm_container = PJ_container_get(vm->cname());
+    type_t type              = PJ_type_get("MSG_VM_STATE", vm_container->type);
+    val_t value              = PJ_value_get_or_new("suspend", "1 0 0", type); // suspend is red
+    new_pajePushState(MSG_get_clock(), vm_container, type, value);
+  }
 }
 
 /** @brief Resume the execution of the VM. All processes on the VM run again.
@@ -922,7 +879,11 @@ void MSG_vm_resume(msg_vm_t vm)
 {
   simcall_vm_resume(vm);
 
-  TRACE_msg_vm_resume(vm);
+  if (TRACE_msg_vm_is_enabled()) {
+    container_t vm_container = PJ_container_get(vm->cname());
+    type_t type              = PJ_type_get("MSG_VM_STATE", vm_container->type);
+    new_pajePopState(MSG_get_clock(), vm_container, type);
+  }
 }
 
 
@@ -938,10 +899,16 @@ void MSG_vm_resume(msg_vm_t vm)
 void MSG_vm_save(msg_vm_t vm)
 {
   if (MSG_vm_is_migrating(vm))
-    THROWF(vm_error, 0, "VM(%s) is migrating", sg_host_get_name(vm));
+    THROWF(vm_error, 0, "Cannot save VM '%s', which is migrating.", vm->cname());
 
   simcall_vm_save(vm);
-  TRACE_msg_vm_save(vm);
+
+  if (TRACE_msg_vm_is_enabled()) {
+    container_t vm_container = PJ_container_get(vm->cname());
+    type_t type              = PJ_type_get("MSG_VM_STATE", vm_container->type);
+    val_t value              = PJ_value_get_or_new("save", "0 1 0", type); // save is green
+    new_pajePushState(MSG_get_clock(), vm_container, type, value);
+  }
 }
 
 /** @brief Restore the execution of the VM. All processes on the VM run again.
@@ -954,7 +921,11 @@ void MSG_vm_restore(msg_vm_t vm)
 {
   simcall_vm_restore(vm);
 
-  TRACE_msg_vm_restore(vm);
+  if (TRACE_msg_vm_is_enabled()) {
+    container_t vm_container = PJ_container_get(vm->cname());
+    type_t type              = PJ_type_get("MSG_VM_STATE", vm_container->type);
+    new_pajePopState(MSG_get_clock(), vm_container, type);
+  }
 }
 
 /** @brief Get the physical host of a given VM.
@@ -962,7 +933,7 @@ void MSG_vm_restore(msg_vm_t vm)
  */
 msg_host_t MSG_vm_get_pm(msg_vm_t vm)
 {
-  return (msg_host_t) simcall_vm_get_pm(vm);
+  return static_cast<simgrid::s4u::VirtualMachine*>(vm)->pimpl_vm_->getPm();
 }
 
 /** @brief Set a CPU bound for a given VM.