Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
32194f9ef8121457ffb43bcd304cbdd5c20003cf
[simgrid.git] / src / simix / libsmx.cpp
1 /* libsmx.c - public interface to simix                                       */
2 /* --------                                                                   */
3 /* These functions are the only ones that are visible from the higher levels  */
4 /* (most of them simply add some documentation to the generated simcall body) */
5 /*                                                                            */
6 /* This is somehow the "libc" of SimGrid                                      */
7
8 /* Copyright (c) 2010-2015. The SimGrid Team.
9  * All rights reserved.                                                     */
10
11 /* This program is free software; you can redistribute it and/or modify it
12  * under the terms of the license (GNU LGPL) which comes with this package. */
13
14 #include <cmath>         /* std::isfinite() */
15
16 #include <functional>
17
18 #include "src/mc/mc_replay.h"
19 #include "smx_private.h"
20 #include "src/mc/mc_forward.h"
21 #include "xbt/ex.h"
22 #include "mc/mc.h"
23 #include "src/simix/smx_host_private.h"
24 #include "src/simix/smx_private.hpp"
25
26 #include <simgrid/simix.hpp>
27
28 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix);
29
30 #include "popping_bodies.cpp"
31
32 void simcall_call(smx_process_t process)
33 {
34   if (process != simix_global->maestro_process) {
35     XBT_DEBUG("Yield process '%s' on simcall %s (%d)", process->name,
36               SIMIX_simcall_name(process->simcall.call), (int)process->simcall.call);
37     SIMIX_process_yield(process);
38   } else {
39     SIMIX_simcall_handle(&process->simcall, 0);
40   }
41 }
42
43 // ***** Host simcalls
44 // Those functions are replaced by methods on the Host object.
45
46 /** \ingroup simix_host_management
47  * \deprecated */
48 xbt_swag_t simcall_host_get_process_list(sg_host_t host)
49 {
50   return host->getProcessList();
51 }
52
53 /** \ingroup simix_host_management
54  * \deprecated */
55 double simcall_host_get_current_power_peak(sg_host_t host)
56 {
57   return host->getCurrentPowerPeak();
58 }
59
60 /** \ingroup simix_host_management
61  * \deprecated */
62 double simcall_host_get_power_peak_at(sg_host_t host, int pstate_index)
63 {
64   return host->getPowerPeakAt(pstate_index);
65 }
66
67 /** \deprecated */
68 void simcall_host_get_params(sg_host_t vm, vm_params_t params)
69 {
70   vm->getParams(params);
71 }
72
73 /** \deprecated */
74 void simcall_host_set_params(sg_host_t vm, vm_params_t params)
75 {
76   vm->setParams(params);
77 }
78
79 /** \ingroup simix_storage_management
80  *  \deprecated */
81 xbt_dict_t simcall_host_get_mounted_storage_list(sg_host_t host)
82 {
83   return host->getMountedStorageList();
84 }
85
86 /** \ingroup simix_storage_management
87  *  \deprecated */
88 xbt_dynar_t simcall_host_get_attached_storage_list(sg_host_t host)
89 {
90   return host->getAttachedStorageList();
91 }
92
93 // ***** Other simcalls
94
95 /**
96  * \ingroup simix_host_management
97  * \brief Returns a dict of the properties assigned to a router or AS.
98  *
99  * \param name The name of the router or AS
100  * \return The properties
101  */
102 xbt_dict_t simcall_asr_get_properties(const char *name)
103 {
104   return simcall_BODY_asr_get_properties(name);
105 }
106
107 /**
108  * \ingroup simix_process_management
109  * \brief Creates a synchro that executes some computation of an host.
110  *
111  * This function creates a SURF action and allocates the data necessary
112  * to create the SIMIX synchro. It can raise a host_error exception if the host crashed.
113  *
114  * \param name Name of the execution synchro to create
115  * \param flops_amount amount Computation amount (in flops)
116  * \param priority computation priority
117  * \param bound
118  * \param affinity_mask
119  * \return A new SIMIX execution synchronization
120  */
121 smx_synchro_t simcall_process_execute(const char *name,
122                                     double flops_amount,
123                                     double priority, double bound, unsigned long affinity_mask)
124 {
125   /* checking for infinite values */
126   xbt_assert(std::isfinite(flops_amount), "flops_amount is not finite!");
127   xbt_assert(std::isfinite(priority), "priority is not finite!");
128
129   return simcall_BODY_process_execute(name, flops_amount, priority, bound, affinity_mask);
130 }
131
132 /**
133  * \ingroup simix_process_management
134  * \brief Creates a synchro that may involve parallel computation on
135  * several hosts and communication between them.
136  *
137  * \param name Name of the execution synchro to create
138  * \param host_nb Number of hosts where the synchro will be executed
139  * \param host_list Array (of size host_nb) of hosts where the synchro will be executed
140  * \param flops_amount Array (of size host_nb) of computation amount of hosts (in bytes)
141  * \param bytes_amount Array (of size host_nb * host_nb) representing the communication
142  * amount between each pair of hosts
143  * \param amount the SURF action amount
144  * \param rate the SURF action rate
145  * \return A new SIMIX execution synchronization
146  */
147 smx_synchro_t simcall_process_parallel_execute(const char *name,
148                                          int host_nb,
149                                          sg_host_t *host_list,
150                                          double *flops_amount,
151                                          double *bytes_amount,
152                                          double amount,
153                                          double rate)
154 {
155   int i,j;
156   /* checking for infinite values */
157   for (i = 0 ; i < host_nb ; ++i) {
158      xbt_assert(std::isfinite(flops_amount[i]), "flops_amount[%d] is not finite!", i);
159      for (j = 0 ; j < host_nb ; ++j) {
160         xbt_assert(std::isfinite(bytes_amount[i + host_nb * j]),
161              "bytes_amount[%d+%d*%d] is not finite!", i, host_nb, j);
162      }
163   }
164
165   xbt_assert(std::isfinite(amount), "amount is not finite!");
166   xbt_assert(std::isfinite(rate), "rate is not finite!");
167
168   return simcall_BODY_process_parallel_execute(name, host_nb, host_list,
169                                             flops_amount,
170                                             bytes_amount,
171                                             amount, rate);
172
173 }
174
175 /**
176  * \ingroup simix_process_management
177  * \brief Destroys an execution synchro.
178  *
179  * Destroys a synchro, freeing its memory. This function cannot be called if there are a conditional waiting for it.
180  * \param execution The execution synchro to destroy
181  */
182 void simcall_process_execution_destroy(smx_synchro_t execution)
183 {
184   simcall_BODY_process_execution_destroy(execution);
185 }
186
187 /**
188  * \ingroup simix_process_management
189  * \brief Cancels an execution synchro.
190  *
191  * This functions stops the execution. It calls a surf function.
192  * \param execution The execution synchro to cancel
193  */
194 void simcall_process_execution_cancel(smx_synchro_t execution)
195 {
196   simcall_BODY_process_execution_cancel(execution);
197 }
198
199 /**
200  * \ingroup simix_process_management
201  * \brief Returns how much of an execution synchro remains to be done.
202  *
203  * \param execution The execution synchro
204  * \return The remaining amount
205  */
206 double simcall_process_execution_get_remains(smx_synchro_t execution)
207 {
208   return simcall_BODY_process_execution_get_remains(execution);
209 }
210
211 /**
212  * \ingroup simix_process_management
213  * \brief Returns the state of an execution synchro.
214  *
215  * \param execution The execution synchro
216  * \return The state
217  */
218 e_smx_state_t simcall_process_execution_get_state(smx_synchro_t execution)
219 {
220   return simcall_BODY_process_execution_get_state(execution);
221 }
222
223 /**
224  * \ingroup simix_process_management
225  * \brief Changes the priority of an execution synchro.
226  *
227  * This functions changes the priority only. It calls a surf function.
228  * \param execution The execution synchro
229  * \param priority The new priority
230  */
231 void simcall_process_execution_set_priority(smx_synchro_t execution, double priority)
232 {
233   /* checking for infinite values */
234   xbt_assert(std::isfinite(priority), "priority is not finite!");
235
236   simcall_BODY_process_execution_set_priority(execution, priority);
237 }
238
239 /**
240  * \ingroup simix_process_management
241  * \brief Changes the capping (the maximum CPU utilization) of an execution synchro.
242  *
243  * This functions changes the capping only. It calls a surf function.
244  * \param execution The execution synchro
245  * \param bound The new bound
246  */
247 void simcall_process_execution_set_bound(smx_synchro_t execution, double bound)
248 {
249   simcall_BODY_process_execution_set_bound(execution, bound);
250 }
251
252 /**
253  * \ingroup simix_process_management
254  * \brief Changes the CPU affinity of an execution synchro.
255  *
256  * This functions changes the CPU affinity of an execution synchro. See taskset(1) on Linux.
257  * \param execution The execution synchro
258  * \param host Host
259  * \param mask Affinity mask
260  */
261 void simcall_process_execution_set_affinity(smx_synchro_t execution, sg_host_t host, unsigned long mask)
262 {
263   simcall_BODY_process_execution_set_affinity(execution, host, mask);
264 }
265
266 /**
267  * \ingroup simix_host_management
268  * \brief Waits for the completion of an execution synchro and destroy it.
269  *
270  * \param execution The execution synchro
271  */
272 e_smx_state_t simcall_process_execution_wait(smx_synchro_t execution)
273 {
274   return (e_smx_state_t) simcall_BODY_process_execution_wait(execution);
275 }
276
277
278 /**
279  * \ingroup simix_vm_management
280  * \brief Create a VM on the given physical host.
281  *
282  * \param name VM name
283  * \param host Physical host
284  *
285  * \return The host object of the VM
286  */
287 void* simcall_vm_create(const char *name, sg_host_t phys_host)
288 {
289   return simgrid::simix::kernel(std::bind(SIMIX_vm_create, name, phys_host));
290 }
291
292 /**
293  * \ingroup simix_vm_management
294  * \brief Start the given VM to the given physical host
295  *
296  * \param vm VM
297  */
298 void simcall_vm_start(sg_host_t vm)
299 {
300   return simgrid::simix::kernel(std::bind(SIMIX_vm_start, vm));
301 }
302
303 /**
304  * \ingroup simix_vm_management
305  * \brief Get the state of the given VM
306  *
307  * \param vm VM
308  * \return The state of the VM
309  */
310 int simcall_vm_get_state(sg_host_t vm)
311 {
312   return simgrid::simix::kernel(std::bind(SIMIX_vm_get_state, vm));
313 }
314
315 /**
316  * \ingroup simix_vm_management
317  * \brief Get the name of the physical host on which the given VM runs.
318  *
319  * \param vm VM
320  * \return The name of the physical host
321  */
322 void *simcall_vm_get_pm(sg_host_t vm)
323 {
324   return simgrid::simix::kernel(std::bind(SIMIX_vm_get_pm, vm));
325 }
326
327 void simcall_vm_set_bound(sg_host_t vm, double bound)
328 {
329   simgrid::simix::kernel(std::bind(SIMIX_vm_set_bound, vm, bound));
330 }
331
332 void simcall_vm_set_affinity(sg_host_t vm, sg_host_t pm, unsigned long mask)
333 {
334   simgrid::simix::kernel(std::bind(SIMIX_vm_set_affinity, vm, pm, mask));
335 }
336
337 /**
338  * \ingroup simix_vm_management
339  * \brief Migrate the given VM to the given physical host
340  *
341  * \param vm VM
342  * \param host Destination physical host
343  */
344 void simcall_vm_migrate(sg_host_t vm, sg_host_t host)
345 {
346   return simgrid::simix::kernel(std::bind(SIMIX_vm_migrate, vm, host));
347 }
348
349 /**
350  * \ingroup simix_vm_management
351  * \brief Suspend the given VM
352  *
353  * \param vm VM
354  */
355 void simcall_vm_suspend(sg_host_t vm)
356 {
357   simcall_BODY_vm_suspend(vm);
358 }
359
360 /**
361  * \ingroup simix_vm_management
362  * \brief Resume the given VM
363  *
364  * \param vm VM
365  */
366 void simcall_vm_resume(sg_host_t vm)
367 {
368   simcall_BODY_vm_resume(vm);
369 }
370
371 /**
372  * \ingroup simix_vm_management
373  * \brief Save the given VM
374  *
375  * \param vm VM
376  */
377 void simcall_vm_save(sg_host_t vm)
378 {
379   simcall_BODY_vm_save(vm);
380 }
381
382 /**
383  * \ingroup simix_vm_management
384  * \brief Restore the given VM
385  *
386  * \param vm VM
387  */
388 void simcall_vm_restore(sg_host_t vm)
389 {
390   simcall_BODY_vm_restore(vm);
391 }
392
393 /**
394  * \ingroup simix_vm_management
395  * \brief Shutdown the given VM
396  *
397  * \param vm VM
398  */
399 void simcall_vm_shutdown(sg_host_t vm)
400 {
401   simcall_BODY_vm_shutdown(vm);
402 }
403
404 /**
405  * \ingroup simix_vm_management
406  * \brief Destroy the given VM
407  *
408  * \param vm VM
409  */
410 void simcall_vm_destroy(sg_host_t vm)
411 {
412   simgrid::simix::kernel(std::bind(SIMIX_vm_destroy, vm));
413 }
414
415 /**
416  * \ingroup simix_vm_management
417  * \brief Encompassing simcall to prevent the removal of the src or the dst node at the end of a VM migration
418  *  The simcall actually invokes the following calls: 
419  *     simcall_vm_set_affinity(vm, src_pm, 0); 
420  *     simcall_vm_migrate(vm, dst_pm); 
421  *     simcall_vm_resume(vm);
422  *
423  * It is called at the end of the migration_rx_fun function from msg/msg_vm.c
424  *
425  * \param vm VM to migrate
426  * \param src_pm  Source physical host
427  * \param dst_pmt Destination physical host
428  */
429 void simcall_vm_migratefrom_resumeto(sg_host_t vm, sg_host_t src_pm, sg_host_t dst_pm)
430 {
431   simgrid::simix::kernel(std::bind(
432     SIMIX_vm_migratefrom_resumeto, vm, src_pm, dst_pm));
433 }
434
435 /**
436  * \ingroup simix_process_management
437  * \brief Creates and runs a new SIMIX process.
438  *
439  * The structure and the corresponding thread are created and put in the list of ready processes.
440  *
441  * \param name a name for the process. It is for user-level information and can be NULL.
442  * \param code the main function of the process
443  * \param data a pointer to any data one may want to attach to the new object. It is for user-level information and can be NULL.
444  * It can be retrieved with the function \ref simcall_process_get_data.
445  * \param hostname name of the host where the new agent is executed.
446  * \param kill_time time when the process is killed
447  * \param argc first argument passed to \a code
448  * \param argv second argument passed to \a code
449  * \param properties the properties of the process
450  * \param auto_restart either it is autorestarting or not.
451  */
452 smx_process_t simcall_process_create(const char *name,
453                               xbt_main_func_t code,
454                               void *data,
455                               const char *hostname,
456                               double kill_time,
457                               int argc, char **argv,
458                               xbt_dict_t properties,
459                               int auto_restart)
460 {
461   return (smx_process_t) simcall_BODY_process_create(name, code, data, hostname,
462                               kill_time, argc, argv, properties,
463                               auto_restart);
464 }
465
466 /**
467  * \ingroup simix_process_management
468  * \brief Kills a SIMIX process.
469  *
470  * This function simply kills a  process.
471  *
472  * \param process poor victim
473  */
474 void simcall_process_kill(smx_process_t process)
475 {
476   simcall_BODY_process_kill(process);
477 }
478
479 /**
480  * \ingroup simix_process_management
481  * \brief Kills all SIMIX processes.
482  */
483 void simcall_process_killall(int reset_pid)
484 {
485   simcall_BODY_process_killall(reset_pid);
486 }
487
488 /**
489  * \ingroup simix_process_management
490  * \brief Cleans up a SIMIX process.
491  * \param process poor victim (must have already been killed)
492  */
493 void simcall_process_cleanup(smx_process_t process)
494 {
495   simcall_BODY_process_cleanup(process);
496 }
497
498 /**
499  * \ingroup simix_process_management
500  * \brief Migrates an agent to another location.
501  *
502  * This function changes the value of the host on which \a process is running.
503  *
504  * \param process the process to migrate
505  * \param dest name of the new host
506  */
507 void simcall_process_set_host(smx_process_t process, sg_host_t dest)
508 {
509   simcall_BODY_process_set_host(process, dest);
510 }
511
512 void simcall_process_join(smx_process_t process, double timeout)
513 {
514   simcall_BODY_process_join(process, timeout);
515 }
516
517 /**
518  * \ingroup simix_process_management
519  * \brief Suspends a process.
520  *
521  * This function suspends the process by suspending the synchro
522  * it was waiting for completion.
523  *
524  * \param process a SIMIX process
525  */
526 void simcall_process_suspend(smx_process_t process)
527 {
528   xbt_assert(process, "Invalid parameters");
529
530   simcall_BODY_process_suspend(process);
531 }
532
533 /**
534  * \ingroup simix_process_management
535  * \brief Resumes a suspended process.
536  *
537  * This function resumes a suspended process by resuming the synchro
538  * it was waiting for completion.
539  *
540  * \param process a SIMIX process
541  */
542 void simcall_process_resume(smx_process_t process)
543 {
544   simcall_BODY_process_resume(process);
545 }
546
547 /**
548  * \ingroup simix_process_management
549  * \brief Returns the amount of SIMIX processes in the system
550  *
551  * Maestro internal process is not counted, only user code processes are
552  */
553 int simcall_process_count(void)
554 {
555   return simgrid::simix::kernel(SIMIX_process_count);
556 }
557
558 /**
559  * \ingroup simix_process_management
560  * \brief Return the PID of a #smx_process_t.
561  * \param process a SIMIX process
562  * \return the PID of this process
563  */
564 int simcall_process_get_PID(smx_process_t process)
565 {
566   return SIMIX_process_get_PID(process);
567 }
568
569 /**
570  * \ingroup simix_process_management
571  * \brief Return the parent PID of a #smx_process_t.
572  * \param process a SIMIX process
573  * \return the PID of this process parenrt
574  */
575 int simcall_process_get_PPID(smx_process_t process)
576 {
577   return SIMIX_process_get_PPID(process);
578 }
579
580 /**
581  * \ingroup simix_process_management
582  * \brief Return the user data of a #smx_process_t.
583  * \param process a SIMIX process
584  * \return the user data of this process
585  */
586 void* simcall_process_get_data(smx_process_t process)
587 {
588   return SIMIX_process_get_data(process);
589 }
590
591 /**
592  * \ingroup simix_process_management
593  * \brief Set the user data of a #smx_process_t.
594  *
595  * This functions sets the user data associated to \a process.
596  * \param process SIMIX process
597  * \param data User data
598  */
599 void simcall_process_set_data(smx_process_t process, void *data)
600 {
601   simgrid::simix::kernel(std::bind(SIMIX_process_set_data, process, data));
602 }
603
604 static void kill_process(void* arg)
605 {
606   simix_global->kill_process_function((smx_process_t) arg);
607 }
608
609 /**
610  * \ingroup simix_process_management
611  * \brief Set the kill time of a process.
612  */
613 void simcall_process_set_kill_time(smx_process_t process, double kill_time)
614 {
615
616   if (kill_time > SIMIX_get_clock()) {
617     if (simix_global->kill_process_function) {
618       XBT_DEBUG("Set kill time %f for process %s(%s)",kill_time, process->name,
619           sg_host_get_name(process->host));
620       process->kill_timer = SIMIX_timer_set(kill_time, kill_process, process);
621     }
622   }
623 }
624 /**
625  * \ingroup simix_process_management
626  * \brief Get the kill time of a process (or 0 if unset).
627  */
628 double simcall_process_get_kill_time(smx_process_t process) {
629         return SIMIX_timer_get_date(process->kill_timer);
630 }
631
632 /**
633  * \ingroup simix_process_management
634  * \brief Return the location on which an agent is running.
635  *
636  * This functions returns the sg_host_t corresponding to the location on which
637  * \a process is running.
638  * \param process SIMIX process
639  * \return SIMIX host
640  */
641 sg_host_t simcall_process_get_host(smx_process_t process)
642 {
643   return SIMIX_process_get_host(process);
644 }
645
646 /**
647  * \ingroup simix_process_management
648  * \brief Return the name of an agent.
649  *
650  * This functions checks whether \a process is a valid pointer or not and return its name.
651  * \param process SIMIX process
652  * \return The process name
653  */
654 const char* simcall_process_get_name(smx_process_t process)
655 {
656   return SIMIX_process_get_name(process);
657 }
658
659 /**
660  * \ingroup simix_process_management
661  * \brief Returns true if the process is suspended .
662  *
663  * This checks whether a process is suspended or not by inspecting the task on which it was waiting for the completion.
664  * \param process SIMIX process
665  * \return 1, if the process is suspended, else 0.
666  */
667 int simcall_process_is_suspended(smx_process_t process)
668 {
669   return simcall_BODY_process_is_suspended(process);
670 }
671
672 /**
673  * \ingroup simix_process_management
674  * \brief Return the properties
675  *
676  * This functions returns the properties associated with this process
677  */
678 xbt_dict_t simcall_process_get_properties(smx_process_t process)
679 {
680   return SIMIX_process_get_properties(process);
681 }
682 /**
683  * \ingroup simix_process_management
684  * \brief Add an on_exit function
685  * Add an on_exit function which will be executed when the process exits/is killed.
686  */
687 XBT_PUBLIC(void) simcall_process_on_exit(smx_process_t process, int_f_pvoid_pvoid_t fun, void *data)
688 {
689   simcall_BODY_process_on_exit(process, fun, data);
690 }
691 /**
692  * \ingroup simix_process_management
693  * \brief Sets the process to be auto-restarted or not by SIMIX when its host comes back up.
694  * Will restart the process when the host comes back up if auto_restart is set to 1.
695  */
696
697 XBT_PUBLIC(void) simcall_process_auto_restart_set(smx_process_t process, int auto_restart)
698 {
699   simcall_BODY_process_auto_restart_set(process, auto_restart);
700 }
701
702 /**
703  * \ingroup simix_process_management
704  * \brief Restarts the process, killing it and starting it again from scratch.
705  */
706 XBT_PUBLIC(smx_process_t) simcall_process_restart(smx_process_t process)
707 {
708   return (smx_process_t) simcall_BODY_process_restart(process);
709 }
710 /**
711  * \ingroup simix_process_management
712  * \brief Creates a new sleep SIMIX synchro.
713  *
714  * This function creates a SURF action and allocates the data necessary
715  * to create the SIMIX synchro. It can raise a host_error exception if the
716  * host crashed. The default SIMIX name of the synchro is "sleep".
717  *
718  *   \param duration Time duration of the sleep.
719  *   \return A result telling whether the sleep was successful
720  */
721 e_smx_state_t simcall_process_sleep(double duration)
722 {
723   /* checking for infinite values */
724   xbt_assert(std::isfinite(duration), "duration is not finite!");
725   return (e_smx_state_t) simcall_BODY_process_sleep(duration);
726 }
727
728 /**
729  *  \ingroup simix_rdv_management
730  *  \brief Creates a new rendez-vous point
731  *  \param name The name of the rendez-vous point
732  *  \return The created rendez-vous point
733  */
734 smx_rdv_t simcall_rdv_create(const char *name)
735 {
736   return simcall_BODY_rdv_create(name);
737 }
738
739
740 /**
741  *  \ingroup simix_rdv_management
742  *  \brief Destroy a rendez-vous point
743  *  \param rdv The rendez-vous point to destroy
744  */
745 void simcall_rdv_destroy(smx_rdv_t rdv)
746 {
747   simcall_BODY_rdv_destroy(rdv);
748 }
749 /**
750  *  \ingroup simix_rdv_management
751  *  \brief Returns a rendez-vous point knowing its name
752  */
753 smx_rdv_t simcall_rdv_get_by_name(const char *name)
754 {
755   xbt_assert(name != NULL, "Invalid parameter for simcall_rdv_get_by_name (name is NULL)");
756
757   /* FIXME: this is a horrible loss of performance, so we hack it out by
758    * skipping the simcall (for now). It works in parallel, it won't work on
759    * distributed but probably we will change MSG for that. */
760
761   return SIMIX_rdv_get_by_name(name);
762 }
763
764 /**
765  *  \ingroup simix_rdv_management
766  *  \brief Counts the number of communication synchros of a given host pending
767  *         on a rendez-vous point.
768  *  \param rdv The rendez-vous point
769  *  \param host The host to be counted
770  *  \return The number of comm synchros pending in the rdv
771  */
772 int simcall_rdv_comm_count_by_host(smx_rdv_t rdv, sg_host_t host)
773 {
774   return simcall_BODY_rdv_comm_count_by_host(rdv, host);
775 }
776
777 /**
778  *  \ingroup simix_rdv_management
779  *  \brief returns the communication at the head of the rendez-vous
780  *  \param rdv The rendez-vous point
781  *  \return The communication or NULL if empty
782  */
783 smx_synchro_t simcall_rdv_get_head(smx_rdv_t rdv)
784 {
785   return simcall_BODY_rdv_get_head(rdv);
786 }
787
788 void simcall_rdv_set_receiver(smx_rdv_t rdv, smx_process_t process)
789 {
790   simcall_BODY_rdv_set_receiver(rdv, process);
791 }
792
793 smx_process_t simcall_rdv_get_receiver(smx_rdv_t rdv)
794 {
795   return simcall_BODY_rdv_get_receiver(rdv);
796 }
797
798 /**
799  * \ingroup simix_comm_management
800  */
801 void simcall_comm_send(smx_process_t sender, smx_rdv_t rdv, double task_size, double rate,
802                          void *src_buff, size_t src_buff_size,
803                          int (*match_fun)(void *, void *, smx_synchro_t),
804                          void (*copy_data_fun)(smx_synchro_t, void*, size_t), void *data,
805                          double timeout)
806 {
807   /* checking for infinite values */
808   xbt_assert(std::isfinite(task_size), "task_size is not finite!");
809   xbt_assert(std::isfinite(rate), "rate is not finite!");
810   xbt_assert(std::isfinite(timeout), "timeout is not finite!");
811
812   xbt_assert(rdv, "No rendez-vous point defined for send");
813
814   if (MC_is_active() || MC_record_replay_is_active()) {
815     /* the model-checker wants two separate simcalls */
816     smx_synchro_t comm = NULL; /* MC needs the comm to be set to NULL during the simcall */
817     comm = simcall_comm_isend(sender, rdv, task_size, rate,
818         src_buff, src_buff_size, match_fun, NULL, copy_data_fun, data, 0);
819     simcall_comm_wait(comm, timeout);
820     comm = NULL;
821   }
822   else {
823     simcall_BODY_comm_send(sender, rdv, task_size, rate, src_buff, src_buff_size,
824                          match_fun, copy_data_fun, data, timeout);
825   }
826 }
827
828 /**
829  * \ingroup simix_comm_management
830  */
831 smx_synchro_t simcall_comm_isend(smx_process_t sender, smx_rdv_t rdv, double task_size, double rate,
832                               void *src_buff, size_t src_buff_size,
833                               int (*match_fun)(void *, void *, smx_synchro_t),
834                               void (*clean_fun)(void *),
835                               void (*copy_data_fun)(smx_synchro_t, void*, size_t),
836                               void *data,
837                               int detached)
838 {
839   /* checking for infinite values */
840   xbt_assert(std::isfinite(task_size), "task_size is not finite!");
841   xbt_assert(std::isfinite(rate), "rate is not finite!");
842
843   xbt_assert(rdv, "No rendez-vous point defined for isend");
844
845   return simcall_BODY_comm_isend(sender, rdv, task_size, rate, src_buff,
846                                  src_buff_size, match_fun,
847                                  clean_fun, copy_data_fun, data, detached);
848 }
849
850 /**
851  * \ingroup simix_comm_management
852  */
853 void simcall_comm_recv(smx_process_t receiver, smx_rdv_t rdv, void *dst_buff, size_t * dst_buff_size,
854                        int (*match_fun)(void *, void *, smx_synchro_t),
855                        void (*copy_data_fun)(smx_synchro_t, void*, size_t),
856                        void *data, double timeout, double rate)
857 {
858   xbt_assert(std::isfinite(timeout), "timeout is not finite!");
859   xbt_assert(rdv, "No rendez-vous point defined for recv");
860
861   if (MC_is_active() || MC_record_replay_is_active()) {
862     /* the model-checker wants two separate simcalls */
863     smx_synchro_t comm = NULL; /* MC needs the comm to be set to NULL during the simcall */
864     comm = simcall_comm_irecv(receiver, rdv, dst_buff, dst_buff_size,
865                               match_fun, copy_data_fun, data, rate);
866     simcall_comm_wait(comm, timeout);
867     comm = NULL;
868   }
869   else {
870     simcall_BODY_comm_recv(receiver, rdv, dst_buff, dst_buff_size,
871                            match_fun, copy_data_fun, data, timeout, rate);
872   }
873 }
874 /**
875  * \ingroup simix_comm_management
876  */
877 smx_synchro_t simcall_comm_irecv(smx_process_t receiver, smx_rdv_t rdv, void *dst_buff, size_t *dst_buff_size,
878                                 int (*match_fun)(void *, void *, smx_synchro_t),
879                                 void (*copy_data_fun)(smx_synchro_t, void*, size_t),
880                                 void *data, double rate)
881 {
882   xbt_assert(rdv, "No rendez-vous point defined for irecv");
883
884   return simcall_BODY_comm_irecv(receiver, rdv, dst_buff, dst_buff_size,
885                                  match_fun, copy_data_fun, data, rate);
886 }
887
888 /**
889  * \ingroup simix_comm_management
890  */
891 smx_synchro_t simcall_comm_iprobe(smx_rdv_t rdv, int type, int src, int tag,
892                                 int (*match_fun)(void *, void *, smx_synchro_t), void *data)
893 {
894   xbt_assert(rdv, "No rendez-vous point defined for iprobe");
895
896   return simcall_BODY_comm_iprobe(rdv, type, src, tag, match_fun, data);
897 }
898
899 /**
900  * \ingroup simix_comm_management
901  */
902 void simcall_comm_cancel(smx_synchro_t comm)
903 {
904   simcall_BODY_comm_cancel(comm);
905 }
906
907 /**
908  * \ingroup simix_comm_management
909  */
910 unsigned int simcall_comm_waitany(xbt_dynar_t comms)
911 {
912   return simcall_BODY_comm_waitany(comms);
913 }
914
915 /**
916  * \ingroup simix_comm_management
917  */
918 int simcall_comm_testany(xbt_dynar_t comms)
919 {
920   if (xbt_dynar_is_empty(comms))
921     return -1;
922   return simcall_BODY_comm_testany(comms);
923 }
924
925 /**
926  * \ingroup simix_comm_management
927  */
928 void simcall_comm_wait(smx_synchro_t comm, double timeout)
929 {
930   xbt_assert(std::isfinite(timeout), "timeout is not finite!");
931   simcall_BODY_comm_wait(comm, timeout);
932 }
933
934 /**
935  * \brief Set the category of an synchro.
936  *
937  * This functions changes the category only. It calls a surf function.
938  * \param execution The execution synchro
939  * \param category The tracing category
940  */
941 void simcall_set_category(smx_synchro_t synchro, const char *category)
942 {
943   if (category == NULL) {
944     return;
945   }
946   simcall_BODY_set_category(synchro, category);
947 }
948
949 /**
950  * \ingroup simix_comm_management
951  *
952  */
953 int simcall_comm_test(smx_synchro_t comm)
954 {
955   return simcall_BODY_comm_test(comm);
956 }
957
958 /**
959  * \ingroup simix_comm_management
960  *
961  */
962 double simcall_comm_get_remains(smx_synchro_t comm)
963 {
964   return simcall_BODY_comm_get_remains(comm);
965 }
966
967 /**
968  * \ingroup simix_comm_management
969  *
970  */
971 e_smx_state_t simcall_comm_get_state(smx_synchro_t comm)
972 {
973   return simcall_BODY_comm_get_state(comm);
974 }
975
976 /**
977  * \ingroup simix_comm_management
978  *
979  */
980 void *simcall_comm_get_src_data(smx_synchro_t comm)
981 {
982   return simcall_BODY_comm_get_src_data(comm);
983 }
984
985 /**
986  * \ingroup simix_comm_management
987  *
988  */
989 void *simcall_comm_get_dst_data(smx_synchro_t comm)
990 {
991   return simcall_BODY_comm_get_dst_data(comm);
992 }
993
994 /**
995  * \ingroup simix_comm_management
996  *
997  */
998 smx_process_t simcall_comm_get_src_proc(smx_synchro_t comm)
999 {
1000   return simcall_BODY_comm_get_src_proc(comm);
1001 }
1002
1003 /**
1004  * \ingroup simix_comm_management
1005  *
1006  */
1007 smx_process_t simcall_comm_get_dst_proc(smx_synchro_t comm)
1008 {
1009   return simcall_BODY_comm_get_dst_proc(comm);
1010 }
1011
1012 #ifdef HAVE_LATENCY_BOUND_TRACKING
1013 int simcall_comm_is_latency_bounded(smx_synchro_t comm)
1014 {
1015   return simcall_BODY_comm_is_latency_bounded(comm);
1016 }
1017 #endif
1018
1019 /**
1020  * \ingroup simix_synchro_management
1021  *
1022  */
1023 smx_mutex_t simcall_mutex_init(void)
1024 {
1025   if(!simix_global) {
1026     fprintf(stderr,"You must run MSG_init before using MSG\n"); // We can't use xbt_die since we may get there before the initialization
1027     xbt_abort();
1028   }
1029   return simcall_BODY_mutex_init();
1030 }
1031
1032 /**
1033  * \ingroup simix_synchro_management
1034  *
1035  */
1036 void simcall_mutex_destroy(smx_mutex_t mutex)
1037 {
1038   simcall_BODY_mutex_destroy(mutex);
1039 }
1040
1041 /**
1042  * \ingroup simix_synchro_management
1043  *
1044  */
1045 void simcall_mutex_lock(smx_mutex_t mutex)
1046 {
1047   simcall_BODY_mutex_lock(mutex);
1048 }
1049
1050 /**
1051  * \ingroup simix_synchro_management
1052  *
1053  */
1054 int simcall_mutex_trylock(smx_mutex_t mutex)
1055 {
1056   return simcall_BODY_mutex_trylock(mutex);
1057 }
1058
1059 /**
1060  * \ingroup simix_synchro_management
1061  *
1062  */
1063 void simcall_mutex_unlock(smx_mutex_t mutex)
1064 {
1065   simcall_BODY_mutex_unlock(mutex);
1066 }
1067
1068 /**
1069  * \ingroup simix_synchro_management
1070  *
1071  */
1072 smx_cond_t simcall_cond_init(void)
1073 {
1074   return simcall_BODY_cond_init();
1075 }
1076
1077 /**
1078  * \ingroup simix_synchro_management
1079  *
1080  */
1081 void simcall_cond_destroy(smx_cond_t cond)
1082 {
1083   simcall_BODY_cond_destroy(cond);
1084 }
1085
1086 /**
1087  * \ingroup simix_synchro_management
1088  *
1089  */
1090 void simcall_cond_signal(smx_cond_t cond)
1091 {
1092   simcall_BODY_cond_signal(cond);
1093 }
1094
1095 /**
1096  * \ingroup simix_synchro_management
1097  *
1098  */
1099 void simcall_cond_wait(smx_cond_t cond, smx_mutex_t mutex)
1100 {
1101   simcall_BODY_cond_wait(cond, mutex);
1102 }
1103
1104 /**
1105  * \ingroup simix_synchro_management
1106  *
1107  */
1108 void simcall_cond_wait_timeout(smx_cond_t cond,
1109                                  smx_mutex_t mutex,
1110                                  double timeout)
1111 {
1112   xbt_assert(std::isfinite(timeout), "timeout is not finite!");
1113   simcall_BODY_cond_wait_timeout(cond, mutex, timeout);
1114 }
1115
1116 /**
1117  * \ingroup simix_synchro_management
1118  *
1119  */
1120 void simcall_cond_broadcast(smx_cond_t cond)
1121 {
1122   simcall_BODY_cond_broadcast(cond);
1123 }
1124
1125 /**
1126  * \ingroup simix_synchro_management
1127  *
1128  */
1129 smx_sem_t simcall_sem_init(int capacity)
1130 {
1131   return simcall_BODY_sem_init(capacity);
1132 }
1133
1134 /**
1135  * \ingroup simix_synchro_management
1136  *
1137  */
1138 void simcall_sem_destroy(smx_sem_t sem)
1139 {
1140   simcall_BODY_sem_destroy(sem);
1141 }
1142
1143 /**
1144  * \ingroup simix_synchro_management
1145  *
1146  */
1147 void simcall_sem_release(smx_sem_t sem)
1148 {
1149   simcall_BODY_sem_release(sem);
1150 }
1151
1152 /**
1153  * \ingroup simix_synchro_management
1154  *
1155  */
1156 int simcall_sem_would_block(smx_sem_t sem)
1157 {
1158   return simcall_BODY_sem_would_block(sem);
1159 }
1160
1161 /**
1162  * \ingroup simix_synchro_management
1163  *
1164  */
1165 void simcall_sem_acquire(smx_sem_t sem)
1166 {
1167   simcall_BODY_sem_acquire(sem);
1168 }
1169
1170 /**
1171  * \ingroup simix_synchro_management
1172  *
1173  */
1174 void simcall_sem_acquire_timeout(smx_sem_t sem, double timeout)
1175 {
1176   xbt_assert(std::isfinite(timeout), "timeout is not finite!");
1177   simcall_BODY_sem_acquire_timeout(sem, timeout);
1178 }
1179
1180 /**
1181  * \ingroup simix_synchro_management
1182  *
1183  */
1184 int simcall_sem_get_capacity(smx_sem_t sem)
1185 {
1186   return simcall_BODY_sem_get_capacity(sem);
1187 }
1188
1189 /**
1190  * \ingroup simix_file_management
1191  *
1192  */
1193 sg_size_t simcall_file_read(smx_file_t fd, sg_size_t size, sg_host_t host)
1194 {
1195   return simcall_BODY_file_read(fd, size, host);
1196 }
1197
1198 /**
1199  * \ingroup simix_file_management
1200  *
1201  */
1202 sg_size_t simcall_file_write(smx_file_t fd, sg_size_t size, sg_host_t host)
1203 {
1204   return simcall_BODY_file_write(fd, size, host);
1205 }
1206
1207 /**
1208  * \ingroup simix_file_management
1209  * \brief
1210  */
1211 smx_file_t simcall_file_open(const char* fullpath, sg_host_t host)
1212 {
1213   return simcall_BODY_file_open(fullpath, host);
1214 }
1215
1216 /**
1217  * \ingroup simix_file_management
1218  *
1219  */
1220 int simcall_file_close(smx_file_t fd, sg_host_t host)
1221 {
1222   return simcall_BODY_file_close(fd, host);
1223 }
1224
1225 /**
1226  * \ingroup simix_file_management
1227  *
1228  */
1229 int simcall_file_unlink(smx_file_t fd, sg_host_t host)
1230 {
1231   return simcall_BODY_file_unlink(fd, host);
1232 }
1233
1234 /**
1235  * \ingroup simix_file_management
1236  *
1237  */
1238 sg_size_t simcall_file_get_size(smx_file_t fd){
1239   return simcall_BODY_file_get_size(fd);
1240 }
1241
1242 /**
1243  * \ingroup simix_file_management
1244  *
1245  */
1246 sg_size_t simcall_file_tell(smx_file_t fd){
1247   return simcall_BODY_file_tell(fd);
1248 }
1249
1250 /**
1251  * \ingroup simix_file_management
1252  *
1253  */
1254 xbt_dynar_t simcall_file_get_info(smx_file_t fd)
1255 {
1256   return simcall_BODY_file_get_info(fd);
1257 }
1258
1259 /**
1260  * \ingroup simix_file_management
1261  *
1262  */
1263 int simcall_file_seek(smx_file_t fd, sg_offset_t offset, int origin){
1264   return simcall_BODY_file_seek(fd, offset, origin);
1265 }
1266
1267 /**
1268  * \ingroup simix_file_management
1269  * \brief Move a file to another location on the *same mount point*.
1270  *
1271  */
1272 int simcall_file_move(smx_file_t fd, const char* fullpath)
1273 {
1274   return simcall_BODY_file_move(fd, fullpath);
1275 }
1276
1277 /**
1278  * \ingroup simix_storage_management
1279  * \brief Returns the free space size on a given storage element.
1280  * \param storage a storage
1281  * \return Return the free space size on a given storage element (as sg_size_t)
1282  */
1283 sg_size_t simcall_storage_get_free_size (smx_storage_t storage){
1284   return simcall_BODY_storage_get_free_size(storage);
1285 }
1286
1287 /**
1288  * \ingroup simix_storage_management
1289  * \brief Returns the used space size on a given storage element.
1290  * \param storage a storage
1291  * \return Return the used space size on a given storage element (as sg_size_t)
1292  */
1293 sg_size_t simcall_storage_get_used_size (smx_storage_t storage){
1294   return simcall_BODY_storage_get_used_size(storage);
1295 }
1296
1297 /**
1298  * \ingroup simix_storage_management
1299  * \brief Returns a dict of the properties assigned to a storage element.
1300  *
1301  * \param storage A storage element
1302  * \return The properties of this storage element
1303  */
1304 xbt_dict_t simcall_storage_get_properties(smx_storage_t storage)
1305 {
1306   return simcall_BODY_storage_get_properties(storage);
1307 }
1308
1309 /**
1310  * \ingroup simix_storage_management
1311  * \brief Returns a dict containing the content of a storage element.
1312  *
1313  * \param storage A storage element
1314  * \return The content of this storage element as a dict (full path file => size)
1315  */
1316 xbt_dict_t simcall_storage_get_content(smx_storage_t storage)
1317 {
1318   return simcall_BODY_storage_get_content(storage);
1319 }
1320
1321 void simcall_run_kernel(std::function<void()> const& code)
1322 {
1323   return simcall_BODY_run_kernel((void*) &code);
1324 }
1325
1326 #ifdef HAVE_MC
1327
1328 void *simcall_mc_snapshot(void) {
1329   return simcall_BODY_mc_snapshot();
1330 }
1331
1332 int simcall_mc_compare_snapshots(void *s1, void *s2) {
1333   return simcall_BODY_mc_compare_snapshots((simgrid::mc::Snapshot*)s1, (simgrid::mc::Snapshot*)s2);
1334 }
1335
1336 #endif /* HAVE_MC */
1337
1338 int simcall_mc_random(int min, int max) {
1339   return simcall_BODY_mc_random(min, max);
1340 }
1341
1342 /* ************************************************************************** */
1343
1344 /** @brief returns a printable string representing a simcall */
1345 const char *SIMIX_simcall_name(e_smx_simcall_t kind) {
1346   return simcall_names[kind];
1347 }