Logo AND Algorithmique Numérique Distribuée

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