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         return MSG_get_host_by_name(name);
  82 }
  83
  84 /** \ingroup m_vm_management
  85  *
  86  * \brief Return the name of the #msg_host_t.
  87  *
  88  * This functions checks whether \a host is a valid pointer or not and return
  89    its name.
  90  */
  91 const char *MSG_vm_get_name(msg_vm_t vm) {
  92   return MSG_host_get_name(vm);
  93 }
  94
  95 /* **** ******** MSG vm actions ********* **** */
  96
  97 /** @brief Create a new VM (the VM is just attached to the location but it is not started yet).
  98  *  @ingroup msg_VMs*
  99  *
 100  * Please note that a VM is a specific host. Hence, you should give a different name
 101  * for each VM/PM.
 102  */
 103 msg_vm_t MSG_vm_create(msg_host_t ind_host, const char *name,
 104                                              int core_nb, int mem_cap, int net_cap){
 105
 106   // Note new and vm_workstation refer to the same area (due to the lib/dict appraoch)
 107   msg_vm_t new = NULL;
 108   void *ind_vm_workstation =  NULL;
 109   // Ask simix to create the surf vm resource
 110   ind_vm_workstation = simcall_vm_create(name,ind_host);
 111   new = (msg_vm_t) __MSG_host_create(ind_vm_workstation);
 112
 113   MSG_vm_set_property_value(new, "CORE_NB", bprintf("%d", core_nb), free);
 114   MSG_vm_set_property_value(new, "MEM_CAP", bprintf("%d", mem_cap), free);
 115   MSG_vm_set_property_value(new, "NET_CAP", bprintf("%d", net_cap), free);
 116
 117   XBT_DEBUG("A new VM has been created");
 118   // TODO check whether the vm (i.e the virtual host) has been correctly added into the list of all hosts.
 119
 120   #ifdef HAVE_TRACING
 121   TRACE_msg_vm_create(name, ind_host);
 122   #endif
 123
 124   return new;
 125 }
 126
 127 /** @brief Start a vm (ie. boot)
 128  *  @ingroup msg_VMs
 129  *
 130  *  If the VM cannot be started, an exception is generated.
 131  *
 132  */
 133 void MSG_vm_start(msg_vm_t vm) {
 134
 135   //Please note that vm start can raise an exception if the VM cannot be started.
 136   simcall_vm_start(vm);
 137
 138   #ifdef HAVE_TRACING
 139   TRACE_msg_vm_start(vm);
 140   #endif
 141 }
 142
 143 /* **** Check state of a VM **** */
 144 int __MSG_vm_is_state(msg_vm_t vm, e_msg_vm_state_t state) {
 145         return simcall_vm_get_state(vm) == state ;
 146 }
 147
 148 /** @brief Returns whether the given VM is currently suspended
 149  *  @ingroup msg_VMs
 150  */
 151 int MSG_vm_is_suspended(msg_vm_t vm) {
 152         return __MSG_vm_is_state(vm, msg_vm_state_suspended);
 153 }
 154 /** @brief Returns whether the given VM is currently running
 155  *  @ingroup msg_VMs
 156  */
 157 int MSG_vm_is_running(msg_vm_t vm) {
 158   return __MSG_vm_is_state(vm, msg_vm_state_running);
 159 }
 160
 161 // TODO Implement the functions for the different state
 162
 163
 164 /** @brief Immediately kills all processes within the given VM. Any memory that they allocated will be leaked.
 165  *  @ingroup msg_VMs
 166  *
 167  * FIXME: No extra delay occurs. If you want to simulate this too, you want to
 168  * use a #MSG_process_sleep() or something. I'm not quite sure.
 169  */
 170 void MSG_vm_shutdown(msg_vm_t vm)
 171 {
 172   /* msg_vm_t equals to msg_host_t */
 173   simcall_vm_shutdown(vm);
 174
 175   // #ifdef HAVE_TRACING
 176   // TRACE_msg_vm_(vm);
 177   // #endif
 178 }
 179
 180
 181 /** @brief Migrate the VM to the given host.
 182  *  @ingroup msg_VMs
 183  *
 184  * FIXME: No migration cost occurs. If you want to simulate this too, you want to use a
 185  * MSG_task_send() before or after, depending on whether you want to do cold or hot
 186  * migration.
 187  */
 188 void MSG_vm_migrate(msg_vm_t vm, msg_host_t destination)
 189 {
 190   /* some thoughts:
 191    * - One approach is ...
 192    *   We first create a new VM (i.e., destination VM) on the destination
 193    *   physical host. The destination VM will receive the state of the source
 194    *   VM over network. We will finally destroy the source VM.
 195    *   - This behavior is similar to the way of migration in the real world.
 196    *     Even before a migration is completed, we will see a destination VM,
 197    *     consuming resources.
 198    *   - We have to relocate all processes. The existing process migraion code
 199    *     will work for this?
 200    *   - The name of the VM is a somewhat unique ID in the code. It is tricky
 201    *     for the destination VM?
 202    *
 203    * - Another one is ...
 204    *   We update the information of the given VM to place it to the destination
 205    *   physical host.
 206    *
 207    * The second one would be easier.
 208    *
 209    */
 210
 211   #ifdef HAVE_TRACING
 212   const char *old_pm_name = simcall_vm_get_phys_host(vm);
 213   msg_host_t old_pm_ind  = xbt_lib_get_elm_or_null(host_lib, old_pm_name);
 214   #endif
 215
 216   simcall_vm_migrate(vm, destination);
 217
 218
 219   #ifdef HAVE_TRACING
 220   TRACE_msg_vm_change_host(vm, old_pm_ind, destination);
 221   #endif
 222 }
 223
 224
 225 /** @brief Immediately suspend the execution of all processes within the given VM.
 226  *  @ingroup msg_VMs
 227  *
 228  * This function stops the exection of the VM. All the processes on this VM
 229  * will pause. The state of the VM is perserved. We can later resume it again.
 230  *
 231  * FIXME: No suspension cost occurs. If you want to simulate this too, you want to
 232  * use a \ref MSG_file_write() before or after, depending on the exact semantic
 233  * of VM suspend to you.
 234  */
 235 void MSG_vm_suspend(msg_vm_t vm)
 236 {
 237   simcall_vm_suspend(vm);
 238
 239   #ifdef HAVE_TRACING
 240   TRACE_msg_vm_suspend(vm);
 241   #endif
 242 }
 243
 244
 245 /** @brief Resume the execution of the VM. All processes on the VM run again.
 246  *  @ingroup msg_VMs
 247  *
 248  * FIXME: No resume cost occurs. If you want to simulate this too, you want to
 249  * use a \ref MSG_file_read() before or after, depending on the exact semantic
 250  * of VM resume to you.
 251  */
 252 void MSG_vm_resume(msg_vm_t vm)
 253 {
 254   simcall_vm_resume(vm);
 255
 256   #ifdef HAVE_TRACING
 257   TRACE_msg_vm_resume(vm);
 258   #endif
 259 }
 260
 261
 262 /** @brief Immediately save the execution of all processes within the given VM.
 263  *  @ingroup msg_VMs
 264  *
 265  * This function stops the exection of the VM. All the processes on this VM
 266  * will pause. The state of the VM is perserved. We can later resume it again.
 267  *
 268  * FIXME: No suspension cost occurs. If you want to simulate this too, you want to
 269  * use a \ref MSG_file_write() before or after, depending on the exact semantic
 270  * of VM save to you.
 271  */
 272 void MSG_vm_save(msg_vm_t vm)
 273 {
 274   simcall_vm_save(vm);
 275
 276   #ifdef HAVE_TRACING
 277   TRACE_msg_vm_save(vm);
 278   #endif
 279 }
 280
 281
 282 /** @brief Restore the execution of the VM. All processes on the VM run again.
 283  *  @ingroup msg_VMs
 284  *
 285  * FIXME: No restore cost occurs. If you want to simulate this too, you want to
 286  * use a \ref MSG_file_read() before or after, depending on the exact semantic
 287  * of VM restore to you.
 288  */
 289 void MSG_vm_restore(msg_vm_t vm)
 290 {
 291   simcall_vm_restore(vm);
 292
 293   #ifdef HAVE_TRACING
 294   TRACE_msg_vm_restore(vm);
 295   #endif
 296 }
 297
 298
 299 /** @brief Destroy a VM. Destroy the VM object from the simulation.
 300  *  @ingroup msg_VMs
 301  */
 302 void MSG_vm_destroy(msg_vm_t vm)
 303 {
 304   /* First, terminate all processes on the VM */
 305   simcall_vm_shutdown(vm);
 306
 307   /* Then, destroy the VM object */
 308   simcall_vm_destroy(vm);
 309
 310   #ifdef HAVE_TRACING
 311   TRACE_msg_vm_end(vm);
 312   #endif
 313 }