src/simix/smx_vm.cpp

   1 /* Copyright (c) 2007-2015. The SimGrid Team. All rights reserved.          */
   2
   3 /* This program is free software; you can redistribute it and/or modify it
   4  * under the terms of the license (GNU LGPL) which comes with this package. */
   5
   6 #include "mc/mc.h"
   7 #include "simgrid/s4u/VirtualMachine.hpp"
   8 #include "smx_private.h"
   9 #include "src/plugins/vm/VirtualMachineImpl.hpp"
  10 #include "src/plugins/vm/VmHostExt.hpp"
  11 #include "src/surf/HostImpl.hpp"
  12
  13 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_vm, simix, "Logging specific to SIMIX Virtual Machines");
  14
  15 /* works for VMs and PMs */
  16 static long host_get_ramsize(sg_host_t vm, int *overcommit)
  17 {
  18   s_vm_params_t params;
  19   static_cast<simgrid::s4u::VirtualMachine*>(vm)->parameters(&params);
  20
  21   if (overcommit)
  22     *overcommit = params.overcommit;
  23
  24   return params.ramsize;
  25 }
  26
  27 /* **** start a VM **** */
  28 void SIMIX_vm_start(sg_host_t vm)
  29 {
  30   sg_host_t pm = static_cast<simgrid::s4u::VirtualMachine*>(vm)->pimpl_vm_->getPm();
  31
  32   simgrid::vm::VmHostExt::ensureVmExtInstalled();
  33   if (pm->extension<simgrid::vm::VmHostExt>() == nullptr)
  34     pm->extension_set(new simgrid::vm::VmHostExt());
  35
  36   long pm_ramsize = pm->extension<simgrid::vm::VmHostExt>()->ramsize;
  37   int pm_overcommit = pm->extension<simgrid::vm::VmHostExt>()->overcommit;
  38   long vm_ramsize = host_get_ramsize(vm, nullptr);
  39
  40   if (pm_ramsize && !pm_overcommit) { /* Only verify that we don't overcommit on need */
  41     /* Retrieve the memory occupied by the VMs on that host. Yep, we have to traverse all VMs of all hosts for that */
  42     long total_ramsize_of_vms = 0;
  43     for (simgrid::surf::VirtualMachineImpl* ws_vm : simgrid::surf::VirtualMachineImpl::allVms_)
  44       if (pm == ws_vm->getPm())
  45         total_ramsize_of_vms += ws_vm->getRamsize();
  46
  47     if (vm_ramsize > pm_ramsize - total_ramsize_of_vms) {
  48       XBT_WARN("cannnot start %s@%s due to memory shortage: vm_ramsize %ld, free %ld, pm_ramsize %ld (bytes).",
  49                sg_host_get_name(vm), sg_host_get_name(pm), vm_ramsize, pm_ramsize - total_ramsize_of_vms, pm_ramsize);
  50       THROWF(vm_error, 0, "The VM %s cannot be started", vm->name().c_str());
  51     }
  52   }
  53
  54   static_cast<simgrid::s4u::VirtualMachine*>(vm)->pimpl_vm_->setState(SURF_VM_STATE_RUNNING);
  55 }
  56
  57 /**
  58  * @brief Function to migrate a SIMIX VM host.
  59  *
  60  * @param host the vm host to migrate (a sg_host_t)
  61  */
  62 void SIMIX_vm_migrate(sg_host_t vm, sg_host_t dst_pm)
  63 {
  64   /* precopy migration makes the VM temporally paused */
  65   xbt_assert(static_cast<simgrid::s4u::VirtualMachine*>(vm)->pimpl_vm_->getState() == SURF_VM_STATE_SUSPENDED);
  66
  67   /* jump to vm_ws_xigrate(). this will update the vm location. */
  68   static_cast<simgrid::s4u::VirtualMachine*>(vm)->pimpl_vm_->migrate(dst_pm);
  69 }
  70
  71 /**
  72  * @brief Function to suspend a SIMIX VM host. This function stops the execution of the
  73  * VM. All the processes on this VM will pause. The state of the VM is
  74  * preserved on memory. We can later resume it again.
  75  *
  76  * @param vm the vm host to suspend (a sg_host_t)
  77  */
  78 void SIMIX_vm_suspend(sg_host_t vm, smx_actor_t issuer)
  79 {
  80   if (static_cast<simgrid::s4u::VirtualMachine*>(vm)->pimpl_vm_->getState() != SURF_VM_STATE_RUNNING)
  81     THROWF(vm_error, 0, "VM(%s) is not running", vm->name().c_str());
  82
  83   XBT_DEBUG("suspend VM(%s), where %d processes exist", vm->name().c_str(), xbt_swag_size(sg_host_simix(vm)->process_list));
  84
  85   /* jump to vm_ws_suspend. The state will be set. */
  86   static_cast<simgrid::s4u::VirtualMachine*>(vm)->pimpl_vm_->suspend();
  87
  88   smx_actor_t smx_process, smx_process_safe;
  89   xbt_swag_foreach_safe(smx_process, smx_process_safe, sg_host_simix(vm)->process_list) {
  90     XBT_DEBUG("suspend %s", smx_process->name.c_str());
  91     SIMIX_process_suspend(smx_process, issuer);
  92   }
  93
  94   XBT_DEBUG("suspend all processes on the VM done done");
  95 }
  96
  97 void simcall_HANDLER_vm_suspend(smx_simcall_t simcall, sg_host_t vm)
  98 {
  99   xbt_assert(simcall->issuer->host != vm, "cannot suspend the VM where I run");
 100
 101   SIMIX_vm_suspend(vm, simcall->issuer);
 102
 103   XBT_DEBUG("simcall_HANDLER_vm_suspend done");
 104 }
 105
 106
 107 /**
 108  * @brief Function to resume a SIMIX VM host. This function restart the execution of the
 109  * VM. All the processes on this VM will run again.
 110  *
 111  * @param vm the vm host to resume (a sg_host_t)
 112  */
 113 void SIMIX_vm_resume(sg_host_t vm)
 114 {
 115   if (static_cast<simgrid::s4u::VirtualMachine*>(vm)->pimpl_vm_->getState() != SURF_VM_STATE_SUSPENDED)
 116     THROWF(vm_error, 0, "VM(%s) was not suspended", vm->name().c_str());
 117
 118   XBT_DEBUG("resume VM(%s), where %d processes exist",
 119       vm->name().c_str(), xbt_swag_size(sg_host_simix(vm)->process_list));
 120
 121   /* jump to vm_ws_resume() */
 122   static_cast<simgrid::s4u::VirtualMachine*>(vm)->pimpl_vm_->resume();
 123
 124   smx_actor_t smx_process, smx_process_safe;
 125   xbt_swag_foreach_safe(smx_process, smx_process_safe, sg_host_simix(vm)->process_list) {
 126     XBT_DEBUG("resume %s", smx_process->name.c_str());
 127     SIMIX_process_resume(smx_process);
 128   }
 129 }
 130
 131 /**
 132  * @brief Function to save a SIMIX VM host.
 133  * This function is the same as vm_suspend, but the state of the VM is saved to the disk, and not preserved on memory.
 134  * We can later restore it again.
 135  *
 136  * @param vm the vm host to save (a sg_host_t)
 137  */
 138 void SIMIX_vm_save(sg_host_t vm, smx_actor_t issuer)
 139 {
 140   const char *name = sg_host_get_name(vm);
 141
 142   if (static_cast<simgrid::s4u::VirtualMachine*>(vm)->pimpl_vm_->getState() != SURF_VM_STATE_RUNNING)
 143     THROWF(vm_error, 0, "VM(%s) is not running", name);
 144
 145   XBT_DEBUG("save VM(%s), where %d processes exist", name, xbt_swag_size(sg_host_simix(vm)->process_list));
 146
 147   /* jump to vm_ws_save() */
 148   static_cast<simgrid::s4u::VirtualMachine*>(vm)->pimpl_vm_->save();
 149
 150   smx_actor_t smx_process, smx_process_safe;
 151   xbt_swag_foreach_safe(smx_process, smx_process_safe, sg_host_simix(vm)->process_list) {
 152     XBT_DEBUG("suspend %s", smx_process->name.c_str());
 153     SIMIX_process_suspend(smx_process, issuer);
 154   }
 155 }
 156
 157 void simcall_HANDLER_vm_save(smx_simcall_t simcall, sg_host_t vm)
 158 {
 159   SIMIX_vm_save(vm, simcall->issuer);
 160 }
 161
 162 /**
 163  * @brief Function to shutdown a SIMIX VM host. This function powers off the
 164  * VM. All the processes on this VM will be killed. But, the state of the VM is
 165  * preserved on memory. We can later start it again.
 166  *
 167  * @param vm the VM to shutdown (a sg_host_t)
 168  */
 169 void SIMIX_vm_shutdown(sg_host_t vm, smx_actor_t issuer)
 170 {
 171   if (static_cast<simgrid::s4u::VirtualMachine*>(vm)->pimpl_vm_->getState() != SURF_VM_STATE_RUNNING)
 172     THROWF(vm_error, 0, "VM(%s) is not running", vm->name().c_str());
 173
 174   XBT_DEBUG("shutdown VM %s, that contains %d processes",
 175       vm->name().c_str(),xbt_swag_size(sg_host_simix(vm)->process_list));
 176
 177   smx_actor_t smx_process, smx_process_safe;
 178   xbt_swag_foreach_safe(smx_process, smx_process_safe, sg_host_simix(vm)->process_list) {
 179     XBT_DEBUG("kill %s", smx_process->name.c_str());
 180     SIMIX_process_kill(smx_process, issuer);
 181   }
 182
 183   /* FIXME: we may have to do something at the surf layer, e.g., vcpu action */
 184   static_cast<simgrid::s4u::VirtualMachine*>(vm)->pimpl_vm_->setState(SURF_VM_STATE_CREATED);
 185 }
 186
 187 void simcall_HANDLER_vm_shutdown(smx_simcall_t simcall, sg_host_t vm)
 188 {
 189   SIMIX_vm_shutdown(vm, simcall->issuer);
 190 }