Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Fix initialization order.
[simgrid.git] / src / simix / smx_vm.c
1 /* Copyright (c) 2007-2012. The SimGrid Team.
2  * All rights reserved.                                                     */
3
4 /* This program is free software; you can redistribute it and/or modify it
5  * under the terms of the license (GNU LGPL) which comes with this package. */
6
7 #include "smx_private.h"
8 #include "xbt/sysdep.h"
9 #include "xbt/log.h"
10 #include "xbt/dict.h"
11 #include "mc/mc.h"
12
13 //If you need to log some stuffs, just uncomment these two lines and uses XBT_DEBUG for instance
14 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_vm, simix, "Logging specific to SIMIX (vms)");
15
16 /* **** create a VM **** */
17
18 /**
19  * \brief Internal function to create a SIMIX host.
20  * \param name name of the host to create
21  * \param data some user data (may be NULL)
22  */
23 smx_host_t SIMIX_vm_create(const char *name, smx_host_t ind_phys_host)
24 {
25   /* Create surf associated resource */
26   surf_vm_workstation_model_create(name, ind_phys_host);
27
28   smx_host_t smx_host = SIMIX_host_create(name, ind_phys_host, NULL);
29
30   /* We will be able to register the VM to its physical host, so that we can promptly
31    * retrieve the list VMs on the physical host. */
32
33   return smx_host;
34 }
35
36
37 smx_host_t SIMIX_pre_vm_create(smx_simcall_t simcall, const char *name, smx_host_t ind_phys_host)
38 {
39   return SIMIX_vm_create(name, ind_phys_host);
40 }
41
42
43 /* works for VMs and PMs */
44 static long host_get_ramsize(smx_host_t vm, int *overcommit)
45 {
46   s_ws_params_t params;
47   surf_workstation_get_params(vm, &params);
48
49   if (overcommit)
50     *overcommit = params.overcommit;
51
52   return params.ramsize;
53 }
54
55 /* **** start a VM **** */
56 static int __can_be_started(smx_host_t vm)
57 {
58   smx_host_t pm = surf_vm_workstation_get_pm(vm);
59
60   int pm_overcommit = 0;
61   long pm_ramsize = host_get_ramsize(pm, &pm_overcommit);
62   long vm_ramsize = host_get_ramsize(vm, NULL);
63
64   if (!pm_ramsize) {
65     /* We assume users do not want to care about ramsize. */
66     return 1;
67   }
68
69   if (pm_overcommit) {
70     XBT_INFO("%s allows memory overcommit.", pm->key);
71     return 1;
72   }
73
74   long total_ramsize_of_vms = 0;
75   xbt_dynar_t dyn_vms = surf_workstation_get_vms(pm);
76   {
77     unsigned int cursor = 0;
78     smx_host_t another_vm;
79     xbt_dynar_foreach(dyn_vms, cursor, another_vm) {
80       long another_vm_ramsize = host_get_ramsize(vm, NULL);
81       total_ramsize_of_vms += another_vm_ramsize;
82     }
83   }
84
85   if (vm_ramsize > pm_ramsize - total_ramsize_of_vms) {
86     XBT_WARN("cannnot start %s@%s due to memory shortage: vm_ramsize %ld, free %ld, pm_ramsize %ld (bytes).",
87         vm->key, pm->key, vm_ramsize, pm_ramsize - total_ramsize_of_vms, pm_ramsize);
88     xbt_dynar_free(&dyn_vms);
89     return 0;
90   }
91
92   xbt_dynar_free(&dyn_vms);
93         return 1;
94 }
95
96 void SIMIX_vm_start(smx_host_t ind_vm)
97 {
98   if (__can_be_started(ind_vm))
99     SIMIX_vm_set_state(ind_vm, SURF_VM_STATE_RUNNING);
100   else
101     THROWF(vm_error, 0, "The VM %s cannot be started", SIMIX_host_get_name(ind_vm));
102 }
103
104
105
106 void SIMIX_pre_vm_start(smx_simcall_t simcall, smx_host_t ind_vm)
107 {
108   SIMIX_vm_start(ind_vm);
109 }
110
111 /* ***** set/get state of a VM ***** */
112 void SIMIX_vm_set_state(smx_host_t ind_vm, int state)
113 {
114   /* jump to vm_ws_set_state */
115  surf_resource_set_state(surf_workstation_resource_priv(ind_vm), state);
116 }
117
118 void SIMIX_pre_vm_set_state(smx_simcall_t simcall, smx_host_t ind_vm, int state)
119 {
120   SIMIX_vm_set_state(ind_vm, state);
121 }
122
123 int SIMIX_vm_get_state(smx_host_t ind_vm)
124 {
125   return surf_resource_get_state(surf_workstation_resource_priv(ind_vm));
126 }
127
128 int SIMIX_pre_vm_get_state(smx_simcall_t simcall, smx_host_t ind_vm)
129 {
130   return SIMIX_vm_get_state(ind_vm);
131 }
132
133
134 /**
135  * \brief Function to migrate a SIMIX VM host. 
136  *
137  * \param host the vm host to migrate (a smx_host_t)
138  */
139 void SIMIX_vm_migrate(smx_host_t ind_vm, smx_host_t ind_dst_pm)
140 {
141   /* precopy migration makes the VM temporally paused */
142   e_surf_vm_state_t state = SIMIX_vm_get_state(ind_vm);
143   xbt_assert(state == SURF_VM_STATE_SUSPENDED);
144
145   /* jump to vm_ws_migrate(). this will update the vm location. */
146   surf_vm_workstation_migrate(ind_vm, ind_dst_pm);
147 }
148
149 void SIMIX_pre_vm_migrate(smx_simcall_t simcall, smx_host_t ind_vm, smx_host_t ind_dst_pm)
150 {
151   SIMIX_vm_migrate(ind_vm, ind_dst_pm);
152 }
153
154
155 /**
156  * \brief Function to get the physical host of the given SIMIX VM host.
157  *
158  * \param host the vm host to get_phys_host (a smx_host_t)
159  */
160 void *SIMIX_vm_get_pm(smx_host_t ind_vm)
161 {
162   /* jump to vm_ws_get_pm(). this will return the vm name. */
163   return surf_vm_workstation_get_pm(ind_vm);
164 }
165
166 void *SIMIX_pre_vm_get_pm(smx_simcall_t simcall, smx_host_t ind_vm)
167 {
168   return SIMIX_vm_get_pm(ind_vm);
169 }
170
171
172 /**
173  * \brief Function to set the CPU bound of the given SIMIX VM host.
174  *
175  * \param host the vm host (a smx_host_t)
176  * \param bound bound (a double)
177  */
178 void SIMIX_vm_set_bound(smx_host_t ind_vm, double bound)
179 {
180   /* jump to vm_ws_set_vm_bound(). */
181   surf_vm_workstation_set_bound(ind_vm, bound);
182 }
183
184 void SIMIX_pre_vm_set_bound(smx_simcall_t simcall, smx_host_t ind_vm, double bound)
185 {
186   SIMIX_vm_set_bound(ind_vm, bound);
187 }
188
189
190 /**
191  * \brief Function to set the CPU affinity of the given SIMIX VM host.
192  *
193  * \param host the vm host (a smx_host_t)
194  * \param host the pm host (a smx_host_t)
195  * \param mask affinity mask (a unsigned long)
196  */
197 void SIMIX_vm_set_affinity(smx_host_t ind_vm, smx_host_t ind_pm, unsigned long mask)
198 {
199   /* make sure this at the MSG layer. */
200   xbt_assert(SIMIX_vm_get_pm(ind_vm) == ind_pm);
201
202   /* jump to vm_ws_set_vm_affinity(). */
203   surf_vm_workstation_set_affinity(ind_vm, ind_pm, mask);
204 }
205
206 void SIMIX_pre_vm_set_affinity(smx_simcall_t simcall, smx_host_t ind_vm, smx_host_t ind_pm, unsigned long mask)
207 {
208   SIMIX_vm_set_affinity(ind_vm, ind_pm, mask);
209 }
210
211
212 /**
213  * \brief Function to suspend a SIMIX VM host. This function stops the exection of the
214  * VM. All the processes on this VM will pause. The state of the VM is
215  * preserved on memory. We can later resume it again.
216  *
217  * \param host the vm host to suspend (a smx_host_t)
218  */
219 void SIMIX_vm_suspend(smx_host_t ind_vm, smx_process_t issuer)
220 {
221   const char *name = SIMIX_host_get_name(ind_vm);
222
223   if (SIMIX_vm_get_state(ind_vm) != SURF_VM_STATE_RUNNING)
224     THROWF(vm_error, 0, "VM(%s) is not running", name);
225
226   XBT_DEBUG("suspend VM(%s), where %d processes exist", name, xbt_swag_size(SIMIX_host_priv(ind_vm)->process_list));
227
228   /* jump to vm_ws_suspend. The state will be set. */
229   surf_vm_workstation_suspend(ind_vm);
230
231   smx_process_t smx_process, smx_process_safe;
232   xbt_swag_foreach_safe(smx_process, smx_process_safe, SIMIX_host_priv(ind_vm)->process_list) {
233     XBT_DEBUG("suspend %s", smx_process->name);
234     SIMIX_process_suspend(smx_process, issuer);
235   }
236
237   XBT_DEBUG("suspend all processes on the VM done done");
238 }
239
240 void SIMIX_pre_vm_suspend(smx_simcall_t simcall, smx_host_t ind_vm)
241 {
242   if (simcall->issuer->smx_host == ind_vm) {
243     XBT_ERROR("cannot suspend the VM where I run");
244     DIE_IMPOSSIBLE;
245   }
246
247   SIMIX_vm_suspend(ind_vm, simcall->issuer);
248
249   XBT_DEBUG("SIMIX_pre_vm_suspend done");
250 }
251
252
253 /**
254  * \brief Function to resume a SIMIX VM host. This function restart the execution of the
255  * VM. All the processes on this VM will run again. 
256  *
257  * \param host the vm host to resume (a smx_host_t)
258  */
259 void SIMIX_vm_resume(smx_host_t ind_vm, smx_process_t issuer)
260 {
261   const char *name = SIMIX_host_get_name(ind_vm);
262
263   if (SIMIX_vm_get_state(ind_vm) != SURF_VM_STATE_SUSPENDED)
264     THROWF(vm_error, 0, "VM(%s) was not suspended", name);
265
266   XBT_DEBUG("resume VM(%s), where %d processes exist", name, xbt_swag_size(SIMIX_host_priv(ind_vm)->process_list));
267
268   /* jump to vm_ws_resume() */
269   surf_vm_workstation_resume(ind_vm);
270
271   smx_process_t smx_process, smx_process_safe;
272   xbt_swag_foreach_safe(smx_process, smx_process_safe, SIMIX_host_priv(ind_vm)->process_list) {
273     XBT_DEBUG("resume %s", smx_process->name);
274     SIMIX_process_resume(smx_process, issuer);
275   }
276 }
277
278 void SIMIX_pre_vm_resume(smx_simcall_t simcall, smx_host_t ind_vm)
279 {
280   SIMIX_vm_resume(ind_vm, simcall->issuer);
281 }
282
283
284 /**
285  * \brief Function to save a SIMIX VM host.
286  * This function is the same as vm_suspend, but the state of the VM is saved to the disk, and not preserved on memory.
287  * We can later restore it again.
288  *
289  * \param host the vm host to save (a smx_host_t)
290  */
291 void SIMIX_vm_save(smx_host_t ind_vm, smx_process_t issuer)
292 {
293   const char *name = SIMIX_host_get_name(ind_vm);
294
295   if (SIMIX_vm_get_state(ind_vm) != SURF_VM_STATE_RUNNING)
296     THROWF(vm_error, 0, "VM(%s) is not running", name);
297
298
299   XBT_DEBUG("save VM(%s), where %d processes exist", name, xbt_swag_size(SIMIX_host_priv(ind_vm)->process_list));
300
301   /* jump to vm_ws_save() */
302   surf_vm_workstation_save(ind_vm);
303
304   smx_process_t smx_process, smx_process_safe;
305   xbt_swag_foreach_safe(smx_process, smx_process_safe, SIMIX_host_priv(ind_vm)->process_list) {
306     XBT_DEBUG("suspend %s", smx_process->name);
307     SIMIX_process_suspend(smx_process, issuer);
308   }
309 }
310
311 void SIMIX_pre_vm_save(smx_simcall_t simcall, smx_host_t ind_vm)
312 {
313   SIMIX_vm_save(ind_vm, simcall->issuer);
314 }
315
316
317 /**
318  * \brief Function to restore a SIMIX VM host. This function restart the execution of the
319  * VM. All the processes on this VM will run again. 
320  *
321  * \param host the vm host to restore (a smx_host_t)
322  */
323 void SIMIX_vm_restore(smx_host_t ind_vm, smx_process_t issuer)
324 {
325   const char *name = SIMIX_host_get_name(ind_vm);
326
327   if (SIMIX_vm_get_state(ind_vm) != SURF_VM_STATE_SAVED)
328     THROWF(vm_error, 0, "VM(%s) was not saved", name);
329
330   XBT_DEBUG("restore VM(%s), where %d processes exist", name, xbt_swag_size(SIMIX_host_priv(ind_vm)->process_list));
331
332   /* jump to vm_ws_restore() */
333   surf_vm_workstation_resume(ind_vm);
334
335   smx_process_t smx_process, smx_process_safe;
336   xbt_swag_foreach_safe(smx_process, smx_process_safe, SIMIX_host_priv(ind_vm)->process_list) {
337     XBT_DEBUG("resume %s", smx_process->name);
338     SIMIX_process_resume(smx_process, issuer);
339   }
340 }
341
342 void SIMIX_pre_vm_restore(smx_simcall_t simcall, smx_host_t ind_vm)
343 {
344   SIMIX_vm_restore(ind_vm, simcall->issuer);
345 }
346
347
348 /**
349  * \brief Function to shutdown a SIMIX VM host. This function powers off the
350  * VM. All the processes on this VM will be killed. But, the state of the VM is
351  * preserved on memory. We can later start it again.
352  *
353  * \param host the vm host to shutdown (a smx_host_t)
354  */
355 void SIMIX_vm_shutdown(smx_host_t ind_vm, smx_process_t issuer)
356 {
357   const char *name = SIMIX_host_get_name(ind_vm);
358
359   if (SIMIX_vm_get_state(ind_vm) != SURF_VM_STATE_RUNNING)
360     THROWF(vm_error, 0, "VM(%s) is not running", name);
361
362   XBT_DEBUG("%d processes in the VM", xbt_swag_size(SIMIX_host_priv(ind_vm)->process_list));
363
364   smx_process_t smx_process, smx_process_safe;
365   xbt_swag_foreach_safe(smx_process, smx_process_safe, SIMIX_host_priv(ind_vm)->process_list) {
366     XBT_DEBUG("shutdown %s", name);
367     SIMIX_process_kill(smx_process, issuer);
368   }
369
370   /* FIXME: we may have to do something at the surf layer, e.g., vcpu action */
371   SIMIX_vm_set_state(ind_vm, SURF_VM_STATE_CREATED);
372 }
373
374 void SIMIX_pre_vm_shutdown(smx_simcall_t simcall, smx_host_t ind_vm)
375 {
376   SIMIX_vm_shutdown(ind_vm, simcall->issuer);
377 }
378
379
380 /**
381  * \brief Function to destroy a SIMIX VM host.
382  *
383  * \param host the vm host to destroy (a smx_host_t)
384  */
385 void SIMIX_vm_destroy(smx_host_t ind_vm)
386 {
387   /* this code basically performs a similar thing like SIMIX_host_destroy() */
388
389   xbt_assert((ind_vm != NULL), "Invalid parameters");
390   const char *hostname = SIMIX_host_get_name(ind_vm);
391
392   /* this will call the registered callback function, i.e., SIMIX_host_destroy().  */
393   xbt_lib_unset(host_lib, hostname, SIMIX_HOST_LEVEL, 1);
394
395   /* jump to vm_ws_destroy(). The surf level resource will be freed. */
396   surf_vm_workstation_destroy(ind_vm);
397 }
398
399 void SIMIX_pre_vm_destroy(smx_simcall_t simcall, smx_host_t ind_vm)
400 {
401   SIMIX_vm_destroy(ind_vm);
402 }