Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Typo.
[simgrid.git] / src / simix / smx_user.c
1 /* smx_user.c - public interface to simix                                   */
2
3 /* Copyright (c) 2010-2012. Da SimGrid team. All rights reserved.          */
4
5 /* This program is free software; you can redistribute it and/or modify it
6  * under the terms of the license (GNU LGPL) which comes with this package. */
7
8 #include "smx_private.h"
9 #include "mc/mc.h"
10 #include "xbt/ex.h"
11 #include <math.h>         /* isfinite() */
12
13 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix);
14
15 /* generate strings from the enumeration values */
16 static const char* simcall_names[] = {
17 SIMCALL_LIST(SIMCALL_STRING_TYPE, SIMCALL_SEP_COMMA)
18 [SIMCALL_NONE] = "NONE"
19 };
20
21 SIMCALL_LIST(SIMCALL_FUNC, SIMCALL_SEP_NOTHING)
22
23 /**
24  * \ingroup simix_host_management
25  * \brief Returns a host given its name.
26  *
27  * \param name The name of the host to get
28  * \return The corresponding host
29  */
30 smx_host_t simcall_host_get_by_name(const char *name)
31 {
32   return simcall_BODY_host_get_by_name(name);
33 }
34
35 /**
36  * \ingroup simix_host_management
37  * \brief Returns the name of a host.
38  *
39  * \param host A SIMIX host
40  * \return The name of this host
41  */
42 const char* simcall_host_get_name(smx_host_t host)
43 {
44   return simcall_BODY_host_get_name(host);
45 }
46
47 /**
48  * \ingroup simix_host_management
49  * \brief Returns a dict of the properties assigned to a host.
50  *
51  * \param host A host
52  * \return The properties of this host
53  */
54 xbt_dict_t simcall_host_get_properties(smx_host_t host)
55 {
56   return simcall_BODY_host_get_properties(host);
57 }
58
59 /**
60  * \ingroup simix_host_management
61  * \brief Returns a dict of the properties assigned to a router or AS.
62  *
63  * \param name The name of the router or AS
64  * \return The properties
65  */
66 xbt_dict_t simcall_asr_get_properties(const char *name)
67 {
68   return simcall_BODY_asr_get_properties(name);
69 }
70
71
72 /**
73  * \ingroup simix_host_management
74  * \brief Returns the speed of the processor.
75  *
76  * The speed returned does not take into account the current load on the machine.
77  * \param host A SIMIX host
78  * \return The speed of this host (in Mflop/s)
79  */
80 double simcall_host_get_speed(smx_host_t host)
81 {
82   return simcall_BODY_host_get_speed(host);
83 }
84
85 /**
86  * \ingroup simix_host_management
87  * \brief Returns the available speed of the processor.
88  *
89  * \return Speed currently available (in Mflop/s)
90  */
91 double simcall_host_get_available_speed(smx_host_t host)
92 {
93   return simcall_BODY_host_get_available_speed(host);
94 }
95
96 /**
97  * \ingroup simix_host_management
98  * \brief Returns the state of a host.
99  *
100  * Two states are possible: 1 if the host is active or 0 if it has crashed.
101  * \param host A SIMIX host
102  * \return 1 if the host is available, 0 otherwise
103  */
104 int simcall_host_get_state(smx_host_t host)
105 {
106   return simcall_BODY_host_get_state(host);
107 }
108
109 /**
110  * \ingroup simix_host_management
111  * \brief Returns the user data associated to a host.
112  *
113  * \param host SIMIX host
114  * \return the user data of this host
115  */
116 void* simcall_host_get_data(smx_host_t host)
117 {
118   return simcall_BODY_host_get_data(host);
119 }
120
121 /**
122  * \ingroup simix_host_management
123  * \brief Sets the user data associated to a host.
124  *
125  * The host must not have previous user data associated to it.
126  * \param host A SIMIX host
127  * \param data The user data to set
128  */
129 void simcall_host_set_data(smx_host_t host, void *data)
130 {
131   simcall_host_set_data(host, data);
132 }
133
134 /**
135  * \ingroup simix_host_management
136  * \brief Creates an action that executes some computation of an host.
137  *
138  * This function creates a SURF action and allocates the data necessary
139  * to create the SIMIX action. It can raise a host_error exception if the host crashed.
140  *
141  * \param name Name of the execution action to create
142  * \param host SIMIX host where the action will be executed
143  * \param computation_amount amount Computation amount (in bytes)
144  * \param priority computation priority
145  * \return A new SIMIX execution action
146  */
147
148 smx_action_t simcall_host_execute(const char *name, smx_host_t host,
149                                     double computation_amount,
150                                     double priority)
151 {
152   /* checking for infinite values */
153   xbt_assert(isfinite(computation_amount), "computation_amount is not finite!");
154   xbt_assert(isfinite(priority), "priority is not finite!");
155   
156   return simcall_BODY_host_execute(name, host, computation_amount, priority);
157 }
158
159 /**
160  * \ingroup simix_host_management
161  * \brief Creates an action that may involve parallel computation on
162  * several hosts and communication between them.
163  *
164  * \param name Name of the execution action to create
165  * \param host_nb Number of hosts where the action will be executed
166  * \param host_list Array (of size host_nb) of hosts where the action will be executed
167  * \param computation_amount Array (of size host_nb) of computation amount of hosts (in bytes)
168  * \param communication_amount Array (of size host_nb * host_nb) representing the communication
169  * amount between each pair of hosts
170  * \param amount the SURF action amount
171  * \param rate the SURF action rate
172  * \return A new SIMIX execution action
173  */
174 smx_action_t simcall_host_parallel_execute(const char *name,
175                                          int host_nb,
176                                          smx_host_t *host_list,
177                                          double *computation_amount,
178                                          double *communication_amount,
179                                          double amount,
180                                          double rate)
181 {
182   int i,j;
183   /* checking for infinite values */
184   for (i = 0 ; i < host_nb ; ++i) {
185      xbt_assert(isfinite(computation_amount[i]), "computation_amount[%d] is not finite!", i);
186      for (j = 0 ; j < host_nb ; ++j) {
187         xbt_assert(isfinite(communication_amount[i + host_nb * j]), 
188              "communication_amount[%d+%d*%d] is not finite!", i, host_nb, j);
189      }   
190   }   
191  
192   xbt_assert(isfinite(amount), "amount is not finite!");
193   xbt_assert(isfinite(rate), "rate is not finite!");
194   
195   return simcall_BODY_host_parallel_execute(name, host_nb, host_list,
196                                             computation_amount,
197                                             communication_amount,
198                                             amount, rate);
199
200 }
201
202 /**
203  * \ingroup simix_host_management
204  * \brief Destroys an execution action.
205  *
206  * Destroys an action, freing its memory. This function cannot be called if there are a conditional waiting for it.
207  * \param execution The execution action to destroy
208  */
209 void simcall_host_execution_destroy(smx_action_t execution)
210 {
211   simcall_BODY_host_execution_destroy(execution);
212 }
213
214 /**
215  * \ingroup simix_host_management
216  * \brief Cancels an execution action.
217  *
218  * This functions stops the execution. It calls a surf function.
219  * \param execution The execution action to cancel
220  */
221 void simcall_host_execution_cancel(smx_action_t execution)
222 {
223   simcall_BODY_host_execution_cancel(execution);
224 }
225
226 /**
227  * \ingroup simix_host_management
228  * \brief Returns how much of an execution action remains to be done.
229  *
230  * \param execution The execution action
231  * \return The remaining amount
232  */
233 double simcall_host_execution_get_remains(smx_action_t execution)
234 {
235   return simcall_BODY_host_execution_get_remains(execution);
236 }
237
238 /**
239  * \ingroup simix_host_management
240  * \brief Returns the state of an execution action.
241  *
242  * \param execution The execution action
243  * \return The state
244  */
245 e_smx_state_t simcall_host_execution_get_state(smx_action_t execution)
246 {
247   return simcall_BODY_host_execution_get_state(execution);
248 }
249
250 /**
251  * \ingroup simix_host_management
252  * \brief Changes the priority of an execution action.
253  *
254  * This functions changes the priority only. It calls a surf function.
255  * \param execution The execution action
256  * \param priority The new priority
257  */
258 void simcall_host_execution_set_priority(smx_action_t execution, double priority)
259 {
260   /* checking for infinite values */
261   xbt_assert(isfinite(priority), "priority is not finite!");
262   
263   simcall_BODY_host_execution_set_priority(execution, priority);
264 }
265
266 /**
267  * \ingroup simix_host_management
268  * \brief Waits for the completion of an execution action and destroy it.
269  *
270  * \param execution The execution action
271  */
272 e_smx_state_t simcall_host_execution_wait(smx_action_t execution)
273 {
274   return simcall_BODY_host_execution_wait(execution);
275 }
276
277 /**
278  * \ingroup simix_process_management
279  * \brief Creates and runs a new SIMIX process.
280  *
281  * The structure and the corresponding thread are created and put in the list of ready processes.
282  *
283  * \param process the process created will be stored in this pointer
284  * \param name a name for the process. It is for user-level information and can be NULL.
285  * \param code the main function of the process
286  * \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.
287  * It can be retrieved with the function \ref simcall_process_get_data.
288  * \param hostname name of the host where the new agent is executed.
289  * \param kill_time time when the process is killed
290  * \param argc first argument passed to \a code
291  * \param argv second argument passed to \a code
292  * \param properties the properties of the process
293  * \param auto_restart either it is autorestarting or not.
294  */
295 void simcall_process_create(smx_process_t *process, const char *name,
296                               xbt_main_func_t code,
297                               void *data,
298                               const char *hostname,
299                               double kill_time,
300                               int argc, char **argv,
301                               xbt_dict_t properties,
302                               int auto_restart)
303 {
304   simcall_BODY_process_create(process, name, code, data, hostname,
305                               kill_time, argc, argv, properties,
306                               auto_restart);
307 }
308
309 /**
310  * \ingroup simix_process_management
311  * \brief Kills a SIMIX process.
312  *
313  * This function simply kills a  process.
314  *
315  * \param process poor victim
316  */
317 void simcall_process_kill(smx_process_t process)
318 {
319   simcall_BODY_process_kill(process);
320 }
321
322 /**
323  * \ingroup simix_process_management
324  * \brief Kills all SIMIX processes.
325  */
326 void simcall_process_killall(int reset_pid)
327 {
328   simcall_BODY_process_killall(reset_pid);
329 }
330
331 /**
332  * \ingroup simix_process_management
333  * \brief Cleans up a SIMIX process.
334  * \param process poor victim (must have already been killed)
335  */
336 void simcall_process_cleanup(smx_process_t process)
337 {
338   simcall_BODY_process_cleanup(process);
339 }
340
341 /**
342  * \ingroup simix_process_management
343  * \brief Migrates an agent to another location.
344  *
345  * This function changes the value of the host on which \a process is running.
346  *
347  * \param process the process to migrate
348  * \param dest name of the new host
349  */
350 void simcall_process_change_host(smx_process_t process, smx_host_t dest)
351 {
352   simcall_BODY_process_change_host(process, dest);
353 }
354
355 /**
356  * \ingroup simix_process_management
357  * \brief Suspends a process.
358  *
359  * This function suspends the process by suspending the action
360  * it was waiting for completion.
361  *
362  * \param process a SIMIX process
363  */
364 void simcall_process_suspend(smx_process_t process)
365 {
366   xbt_assert(process, "Invalid parameters");
367
368   simcall_BODY_process_suspend(process);
369 }
370
371 /**
372  * \ingroup simix_process_management
373  * \brief Resumes a suspended process.
374  *
375  * This function resumes a suspended process by resuming the action
376  * it was waiting for completion.
377  *
378  * \param process a SIMIX process
379  */
380 void simcall_process_resume(smx_process_t process)
381 {
382   simcall_BODY_process_resume(process);
383 }
384
385 /**
386  * \ingroup simix_process_management
387  * \brief Returns the amount of SIMIX processes in the system
388  *
389  * Maestro internal process is not counted, only user code processes are
390  */
391 int simcall_process_count(void)
392 {
393   return simcall_BODY_process_count();
394 }
395
396 /**
397  * \ingroup simix_process_management
398  * \brief Return the PID of a #smx_process_t.
399  * \param process a SIMIX process
400  * \return the PID of this process
401  */
402 int simcall_process_get_PID(smx_process_t process)
403 {
404   if (process == SIMIX_process_self()) {
405     /* avoid a simcall if this function is called by the process itself */
406     return SIMIX_process_get_PID(process);
407   }
408
409   return simcall_BODY_process_get_PID(process);
410 }
411
412 /**
413  * \ingroup simix_process_management
414  * \brief Return the parent PID of a #smx_process_t.
415  * \param process a SIMIX process
416  * \return the PID of this process parenrt
417  */
418 int simcall_process_get_PPID(smx_process_t process)
419 {
420   if (process == SIMIX_process_self()) {
421     /* avoid a simcall if this function is called by the process itself */
422     return SIMIX_process_get_PPID(process);
423   }
424
425   return simcall_BODY_process_get_PPID(process);
426 }
427
428 /**
429  * \ingroup simix_process_management
430  * \brief Return the user data of a #smx_process_t.
431  * \param process a SIMIX process
432  * \return the user data of this process
433  */
434 void* simcall_process_get_data(smx_process_t process)
435 {
436   if (process == SIMIX_process_self()) {
437     /* avoid a simcall if this function is called by the process itself */
438     return SIMIX_process_get_data(process);
439   }
440
441   return simcall_BODY_process_get_data(process);
442 }
443
444 /**
445  * \ingroup simix_process_management
446  * \brief Set the user data of a #smx_process_t.
447  *
448  * This functions sets the user data associated to \a process.
449  * \param process SIMIX process
450  * \param data User data
451  */
452 void simcall_process_set_data(smx_process_t process, void *data)
453 {
454   if (process == SIMIX_process_self()) {
455     /* avoid a simcall if this function is called by the process itself */
456     SIMIX_process_self_set_data(process, data);
457   }
458   else {
459     simcall_BODY_process_set_data(process, data);
460   }
461 }
462
463 /**
464  * \ingroup simix_process_management
465  * \brief Set the kill time of a process.
466  * \param process a process
467  * \param kill_time a double
468  */
469 void simcall_process_set_kill_time(smx_process_t process, double kill_time)
470 {
471
472   if (kill_time > SIMIX_get_clock()) {
473     if (simix_global->kill_process_function) {
474       XBT_DEBUG("Set kill time %f for process %s(%s)",kill_time, process->name,
475           sg_host_name(process->smx_host));
476       SIMIX_timer_set(kill_time, simix_global->kill_process_function, process);
477     }
478   }
479 }
480
481 /**
482  * \ingroup simix_process_management
483  * \brief Return the location on which an agent is running.
484  *
485  * This functions returns the smx_host_t corresponding to the location on which
486  * \a process is running.
487  * \param process SIMIX process
488  * \return SIMIX host
489  */
490 smx_host_t simcall_process_get_host(smx_process_t process)
491 {
492   return simcall_BODY_process_get_host(process);
493 }
494
495 /**
496  * \ingroup simix_process_management
497  * \brief Return the name of an agent.
498  *
499  * This functions checks whether \a process is a valid pointer or not and return its name.
500  * \param process SIMIX process
501  * \return The process name
502  */
503 const char* simcall_process_get_name(smx_process_t process)
504 {
505   if (process == SIMIX_process_self()) {
506     /* avoid a simcall if this function is called by the process itself */
507     return process->name;
508   }
509   return simcall_BODY_process_get_name(process);
510 }
511
512 /**
513  * \ingroup simix_process_management
514  * \brief Returns true if the process is suspended .
515  *
516  * This checks whether a process is suspended or not by inspecting the task on which it was waiting for the completion.
517  * \param process SIMIX process
518  * \return 1, if the process is suspended, else 0.
519  */
520 int simcall_process_is_suspended(smx_process_t process)
521 {
522   return  simcall_BODY_process_is_suspended(process);
523 }
524
525 /**
526  * \ingroup simix_process_management
527  * \brief Return the properties
528  *
529  * This functions returns the properties associated with this process
530  */
531 xbt_dict_t simcall_process_get_properties(smx_process_t process)
532 {
533   return simcall_BODY_process_get_properties(process);
534 }
535 /**
536  * \ingroup simix_process_management
537  * \brief Add an on_exit function
538  * Add an on_exit function which will be executed when the process exits/is killed.
539  */
540 XBT_PUBLIC(void) simcall_process_on_exit(smx_process_t process, int_f_pvoid_t fun, void *data)
541 {
542   simcall_BODY_process_on_exit(process, fun, data);
543 }
544 /**
545  * \ingroup simix_process_management
546  * \brief Sets the process to be auto-restarted or not by SIMIX when its host comes back up.
547  * Will restart the process when the host comes back up if auto_restart is set to 1.
548  */
549
550 XBT_PUBLIC(void) simcall_process_auto_restart_set(smx_process_t process, int auto_restart)
551 {
552   simcall_BODY_process_auto_restart_set(process, auto_restart);
553 }
554
555 /**
556  * \ingroup simix_process_management
557  * \brief Restarts the process, killing it and starting it again from scratch.
558  */
559 XBT_PUBLIC(smx_process_t) simcall_process_restart(smx_process_t process)
560 {
561   return simcall_BODY_process_restart(process);
562 }
563 /**
564  * \ingroup simix_process_management
565  * \brief Creates a new sleep SIMIX action.
566  *
567  * This function creates a SURF action and allocates the data necessary
568  * to create the SIMIX action. It can raise a host_error exception if the
569  * host crashed. The default SIMIX name of the action is "sleep".
570  *
571  *   \param duration Time duration of the sleep.
572  *   \return A result telling whether the sleep was successful
573  */
574 e_smx_state_t simcall_process_sleep(double duration)
575 {
576   /* checking for infinite values */
577   xbt_assert(isfinite(duration), "duration is not finite!");
578   return simcall_BODY_process_sleep(duration);
579 }
580
581 /**
582  *  \ingroup simix_rdv_management
583  *  \brief Creates a new rendez-vous point
584  *  \param name The name of the rendez-vous point
585  *  \return The created rendez-vous point
586  */
587 smx_rdv_t simcall_rdv_create(const char *name)
588 {
589   return simcall_BODY_rdv_create(name);
590 }
591
592
593 /**
594  *  \ingroup simix_rdv_management
595  *  \brief Destroy a rendez-vous point
596  *  \param rdv The rendez-vous point to destroy
597  */
598 void simcall_rdv_destroy(smx_rdv_t rdv)
599 {
600   simcall_BODY_rdv_destroy(rdv);
601 }
602 /**
603  *  \ingroup simix_rdv_management
604  *  \brief Returns a rendez-vous point knowing its name
605  */
606 smx_rdv_t simcall_rdv_get_by_name(const char *name)
607 {
608   xbt_assert(name != NULL, "Invalid parameter for simcall_rdv_get_by_name (name is NULL)");
609
610   /* FIXME: this is a horrible loss of performance, so we hack it out by
611    * skipping the simcall (for now). It works in parallel, it won't work on
612    * distributed but probably we will change MSG for that. */
613
614   /*
615   smx_simcall_t simcall = simcall_mine();
616   simcall->call = SIMCALL_RDV_GEY_BY_NAME;
617   simcall->rdv_get_by_name.name = name;
618   SIMIX_simcall_push(simcall->issuer);
619   return simcall->rdv_get_by_name.result;*/
620
621   return SIMIX_rdv_get_by_name(name);
622 }
623
624 /**
625  *  \ingroup simix_rdv_management
626  *  \brief Counts the number of communication actions of a given host pending
627  *         on a rendez-vous point.
628  *  \param rdv The rendez-vous point
629  *  \param host The host to be counted
630  *  \return The number of comm actions pending in the rdv
631  */
632 int simcall_rdv_comm_count_by_host(smx_rdv_t rdv, smx_host_t host)
633 {
634   return simcall_BODY_rdv_comm_count_by_host(rdv, host);
635 }
636
637 /**
638  *  \ingroup simix_rdv_management
639  *  \brief returns the communication at the head of the rendez-vous
640  *  \param rdv The rendez-vous point
641  *  \return The communication or NULL if empty
642  */
643 smx_action_t simcall_rdv_get_head(smx_rdv_t rdv)
644 {
645   return simcall_BODY_rdv_get_head(rdv);
646 }
647
648 void simcall_rdv_set_receiver(smx_rdv_t rdv, smx_process_t process)
649 {
650   simcall_BODY_rdv_set_receiver(rdv, process);
651 }
652
653 smx_process_t simcall_rdv_get_receiver(smx_rdv_t rdv)
654 {
655   return simcall_BODY_rdv_get_receiver(rdv);
656 }
657
658 /**
659  * \ingroup simix_comm_management
660  */
661 void simcall_comm_send(smx_rdv_t rdv, double task_size, double rate,
662                          void *src_buff, size_t src_buff_size,
663                          int (*match_fun)(void *, void *, smx_action_t), void *data,
664                          double timeout)
665 {
666   /* checking for infinite values */
667   xbt_assert(isfinite(task_size), "task_size is not finite!");
668   xbt_assert(isfinite(rate), "rate is not finite!");
669   xbt_assert(isfinite(timeout), "timeout is not finite!");
670   
671   xbt_assert(rdv, "No rendez-vous point defined for send");
672
673   if (MC_is_active()) {
674     /* the model-checker wants two separate simcalls */
675     smx_action_t comm = simcall_comm_isend(rdv, task_size, rate,
676         src_buff, src_buff_size, match_fun, NULL, data, 0);
677     simcall_comm_wait(comm, timeout);
678   }
679   else {
680     simcall_BODY_comm_send(rdv, task_size, rate, src_buff, src_buff_size,
681                          match_fun, data, timeout);
682   }
683 }
684
685 /**
686  * \ingroup simix_comm_management
687  */
688 smx_action_t simcall_comm_isend(smx_rdv_t rdv, double task_size, double rate,
689                               void *src_buff, size_t src_buff_size,
690                               int (*match_fun)(void *, void *, smx_action_t),
691                               void (*clean_fun)(void *),
692                               void *data,
693                               int detached)
694 {
695   /* checking for infinite values */
696   xbt_assert(isfinite(task_size), "task_size is not finite!");
697   xbt_assert(isfinite(rate), "rate is not finite!");
698   
699   xbt_assert(rdv, "No rendez-vous point defined for isend");
700
701   return simcall_BODY_comm_isend(rdv, task_size, rate, src_buff,
702                                  src_buff_size, match_fun,
703                                  clean_fun, data, detached);
704 }
705 /**
706  * \ingroup simix_comm_management
707  */
708 void simcall_comm_recv(smx_rdv_t rdv, void *dst_buff, size_t * dst_buff_size,
709                          int (*match_fun)(void *, void *, smx_action_t), void *data, double timeout)
710 {
711   xbt_assert(isfinite(timeout), "timeout is not finite!");
712   xbt_assert(rdv, "No rendez-vous point defined for recv");
713
714   if (MC_is_active()) {
715     /* the model-checker wants two separate simcalls */
716     smx_action_t comm = simcall_comm_irecv(rdv, dst_buff, dst_buff_size,
717         match_fun, data);
718     simcall_comm_wait(comm, timeout);
719   }
720   else {
721     simcall_BODY_comm_recv(rdv, dst_buff, dst_buff_size,
722                            match_fun, data, timeout);
723   }
724 }
725 /**
726  * \ingroup simix_comm_management
727  */
728 smx_action_t simcall_comm_irecv(smx_rdv_t rdv, void *dst_buff, size_t *dst_buff_size,
729                                   int (*match_fun)(void *, void *, smx_action_t), void *data)
730 {
731   xbt_assert(rdv, "No rendez-vous point defined for irecv");
732
733   return simcall_BODY_comm_irecv(rdv, dst_buff, dst_buff_size, 
734                                  match_fun, data);
735 }
736
737
738 /**
739  * \ingroup simix_comm_management
740  */
741 smx_action_t simcall_comm_iprobe(smx_rdv_t rdv, int src, int tag,
742                                 int (*match_fun)(void *, void *, smx_action_t), void *data)
743 {
744   xbt_assert(rdv, "No rendez-vous point defined for iprobe");
745
746   return simcall_BODY_comm_iprobe(rdv, src, tag, match_fun, data);
747 }
748
749 void simcall_comm_destroy(smx_action_t comm)
750 {
751   xbt_assert(comm, "Invalid parameter");
752
753   /* FIXME remove this simcall type: comms are auto-destroyed now */
754
755   /*
756   smx_simcall_t simcall = simcall_mine();
757
758   simcall->call = SIMCALL_COMM_DESTROY;
759   simcall->comm_destroy.comm = comm;
760
761   SIMIX_simcall_push(simcall->issuer);
762   */
763 }
764
765 /**
766  * \ingroup simix_comm_management
767  */
768 void simcall_comm_cancel(smx_action_t comm)
769 {
770   simcall_BODY_comm_cancel(comm);
771 }
772
773 /**
774  * \ingroup simix_comm_management
775  */
776 unsigned int simcall_comm_waitany(xbt_dynar_t comms)
777 {
778   return simcall_BODY_comm_waitany(comms);
779 }
780
781 /**
782  * \ingroup simix_comm_management
783  */
784 int simcall_comm_testany(xbt_dynar_t comms)
785 {
786   if (xbt_dynar_is_empty(comms))
787     return -1;
788   return simcall_BODY_comm_testany(comms);
789 }
790
791 /**
792  * \ingroup simix_comm_management
793  */
794 void simcall_comm_wait(smx_action_t comm, double timeout)
795 {
796   xbt_assert(isfinite(timeout), "timeout is not finite!");
797   simcall_BODY_comm_wait(comm, timeout);
798 }
799
800 #ifdef HAVE_TRACING
801 /**
802  * \brief Set the category of an action.
803  *
804  * This functions changes the category only. It calls a surf function.
805  * \param execution The execution action
806  * \param category The tracing category
807  */
808 void simcall_set_category(smx_action_t action, const char *category)
809 {
810   if (category == NULL) {
811     return;
812   }
813   simcall_BODY_set_category(action, category);
814 }
815 #endif
816
817 /**
818  * \ingroup simix_comm_management
819  *
820  */
821 int simcall_comm_test(smx_action_t comm)
822 {
823   return simcall_BODY_comm_test(comm);
824 }
825
826 /**
827  * \ingroup simix_comm_management
828  *
829  */
830 double simcall_comm_get_remains(smx_action_t comm)
831 {
832   return simcall_BODY_comm_get_remains(comm);
833 }
834
835 /**
836  * \ingroup simix_comm_management
837  *
838  */
839 e_smx_state_t simcall_comm_get_state(smx_action_t comm)
840 {
841   return simcall_BODY_comm_get_state(comm);
842 }
843
844 /**
845  * \ingroup simix_comm_management
846  *
847  */
848 void *simcall_comm_get_src_data(smx_action_t comm)
849 {
850   return simcall_BODY_comm_get_src_data(comm);
851 }
852
853 /**
854  * \ingroup simix_comm_management
855  *
856  */
857 void *simcall_comm_get_dst_data(smx_action_t comm)
858 {
859   return simcall_BODY_comm_get_dst_data(comm);
860 }
861
862 /**
863  * \ingroup simix_comm_management
864  *
865  */
866 smx_process_t simcall_comm_get_src_proc(smx_action_t comm)
867 {
868   return simcall_BODY_comm_get_src_proc(comm);
869 }
870
871 /**
872  * \ingroup simix_comm_management
873  *
874  */
875 smx_process_t simcall_comm_get_dst_proc(smx_action_t comm)
876 {
877   return simcall_BODY_comm_get_dst_proc(comm);  
878 }
879
880 #ifdef HAVE_LATENCY_BOUND_TRACKING
881 int simcall_comm_is_latency_bounded(smx_action_t comm)
882 {
883   return simcall_BODY_comm_is_latency_bounded(comm);
884 }
885 #endif
886
887 /**
888  * \ingroup simix_synchro_management
889  *
890  */
891 smx_mutex_t simcall_mutex_init(void)
892 {
893   if(!simix_global) {
894     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
895     xbt_abort();
896   }
897   return simcall_BODY_mutex_init();
898 }
899
900 /**
901  * \ingroup simix_synchro_management
902  *
903  */
904 void simcall_mutex_destroy(smx_mutex_t mutex)
905 {
906   simcall_BODY_mutex_destroy(mutex);
907 }
908
909 /**
910  * \ingroup simix_synchro_management
911  *
912  */
913 void simcall_mutex_lock(smx_mutex_t mutex)
914 {
915   simcall_BODY_mutex_lock(mutex);  
916 }
917
918 /**
919  * \ingroup simix_synchro_management
920  *
921  */
922 int simcall_mutex_trylock(smx_mutex_t mutex)
923 {
924   return simcall_BODY_mutex_trylock(mutex);  
925 }
926
927 /**
928  * \ingroup simix_synchro_management
929  *
930  */
931 void simcall_mutex_unlock(smx_mutex_t mutex)
932 {
933   simcall_BODY_mutex_unlock(mutex); 
934 }
935
936 /**
937  * \ingroup simix_synchro_management
938  *
939  */
940 smx_cond_t simcall_cond_init(void)
941 {
942   return simcall_BODY_cond_init();
943 }
944
945 /**
946  * \ingroup simix_synchro_management
947  *
948  */
949 void simcall_cond_destroy(smx_cond_t cond)
950 {
951   simcall_BODY_cond_destroy(cond);
952 }
953
954 /**
955  * \ingroup simix_synchro_management
956  *
957  */
958 void simcall_cond_signal(smx_cond_t cond)
959 {
960   simcall_BODY_cond_signal(cond);
961 }
962
963 /**
964  * \ingroup simix_synchro_management
965  *
966  */
967 void simcall_cond_wait(smx_cond_t cond, smx_mutex_t mutex)
968 {
969   simcall_BODY_cond_wait(cond, mutex);
970 }
971
972 /**
973  * \ingroup simix_synchro_management
974  *
975  */
976 void simcall_cond_wait_timeout(smx_cond_t cond,
977                                  smx_mutex_t mutex,
978                                  double timeout)
979 {
980   xbt_assert(isfinite(timeout), "timeout is not finite!");
981   simcall_BODY_cond_wait_timeout(cond, mutex, timeout);
982 }
983
984 /**
985  * \ingroup simix_synchro_management
986  *
987  */
988 void simcall_cond_broadcast(smx_cond_t cond)
989 {
990   simcall_BODY_cond_broadcast(cond);
991 }
992
993 /**
994  * \ingroup simix_synchro_management
995  *
996  */
997 smx_sem_t simcall_sem_init(int capacity)
998 {
999   return simcall_BODY_sem_init(capacity);  
1000 }
1001
1002 /**
1003  * \ingroup simix_synchro_management
1004  *
1005  */
1006 void simcall_sem_destroy(smx_sem_t sem)
1007 {
1008   simcall_sem_destroy(sem);
1009 }
1010
1011 /**
1012  * \ingroup simix_synchro_management
1013  *
1014  */
1015 void simcall_sem_release(smx_sem_t sem)
1016 {
1017   simcall_BODY_sem_release(sem);  
1018 }
1019
1020 /**
1021  * \ingroup simix_synchro_management
1022  *
1023  */
1024 int simcall_sem_would_block(smx_sem_t sem)
1025 {
1026   return simcall_BODY_sem_would_block(sem);
1027 }
1028
1029 /**
1030  * \ingroup simix_synchro_management
1031  *
1032  */
1033 void simcall_sem_acquire(smx_sem_t sem)
1034 {
1035   simcall_BODY_sem_acquire(sem);
1036 }
1037
1038 /**
1039  * \ingroup simix_synchro_management
1040  *
1041  */
1042 void simcall_sem_acquire_timeout(smx_sem_t sem, double timeout)
1043 {
1044   xbt_assert(isfinite(timeout), "timeout is not finite!");
1045   simcall_BODY_sem_acquire_timeout(sem, timeout);
1046 }
1047
1048 /**
1049  * \ingroup simix_synchro_management
1050  *
1051  */
1052 int simcall_sem_get_capacity(smx_sem_t sem)
1053 {
1054   return simcall_BODY_sem_get_capacity(sem);
1055 }
1056
1057 /**
1058  * \ingroup simix_file_management
1059  *
1060  */
1061 double simcall_file_read(void* ptr, size_t size, size_t nmemb, smx_file_t stream)
1062 {
1063   return simcall_BODY_file_read(ptr, size, nmemb, stream);
1064 }
1065
1066 /**
1067  * \ingroup simix_file_management
1068  *
1069  */
1070 size_t simcall_file_write(const void* ptr, size_t size, size_t nmemb, smx_file_t stream)
1071 {
1072   return simcall_BODY_file_write(ptr, size, nmemb, stream);
1073 }
1074
1075 /**
1076  * \ingroup simix_file_management
1077  * \brief
1078  */
1079 smx_file_t simcall_file_open(const char* mount, const char* path, const char* mode)
1080 {
1081   return simcall_BODY_file_open(mount, path, mode);
1082 }
1083
1084 /**
1085  * \ingroup simix_file_management
1086  *
1087  */
1088 int simcall_file_close(smx_file_t fp)
1089 {
1090   return simcall_BODY_file_close(fp);  
1091 }
1092
1093 /**
1094  * \ingroup simix_file_management
1095  *
1096  */
1097 int simcall_file_stat(smx_file_t fd, s_file_stat_t *buf)
1098 {
1099   return simcall_BODY_file_stat(fd, buf);
1100 }
1101
1102 /**
1103  * \ingroup simix_file_management
1104  *
1105  */
1106 int simcall_file_unlink(smx_file_t fd)
1107 {
1108   return simcall_BODY_file_unlink(fd);
1109 }
1110
1111 /**
1112  * \ingroup simix_file_management
1113  *
1114  */
1115 xbt_dict_t simcall_file_ls(const char* mount, const char* path)
1116 {
1117   return simcall_BODY_file_ls(mount, path);
1118 }
1119
1120 #ifdef HAVE_MC
1121
1122 void *simcall_mc_snapshot(void)
1123 {
1124   return simcall_BODY_mc_snapshot();
1125 }
1126
1127 int simcall_mc_compare_snapshots(void *s1, void *s2){ 
1128   return simcall_BODY_mc_compare_snapshots(s1, s2);
1129 }
1130
1131 #endif /* HAVE_MC */
1132
1133 /* ****************************************************************************************** */
1134 /* TUTORIAL: New API                                                                          */
1135 /* All functions for simcall                                                                  */
1136 /* ****************************************************************************************** */
1137 int simcall_new_api_fct(const char* param1, double param2){
1138   smx_simcall_t simcall = SIMIX_simcall_mine();
1139   simcall->call = SIMCALL_NEW_API_INIT;
1140   simcall->new_api.param1 = param1;
1141   simcall->new_api.param2 = param2;
1142
1143   SIMIX_simcall_push(simcall->issuer);
1144   return simcall->new_api.result;
1145 }
1146
1147 /* ************************************************************************** */
1148
1149 /** @brief returns a printable string representing a simcall */
1150 const char *SIMIX_simcall_name(e_smx_simcall_t kind) {
1151   return simcall_names[kind];
1152 }