Logo AND Algorithmique Numérique Distribuée

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