Logo AND Algorithmique Numérique Distribuée

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