Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
faac628ff6f66e26ab021ec2c7078968abcf9dc5
[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_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(void)
327 {
328   simcall_BODY_process_killall();
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 user data of a #smx_process_t.
399  * \param process a SIMIX process
400  * \return the user data of this process
401  */
402 void* simcall_process_get_data(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_data(process);
407   }
408
409   return simcall_BODY_process_get_data(process);
410 }
411
412 /**
413  * \ingroup simix_process_management
414  * \brief Set the user data of a #smx_process_t.
415  *
416  * This functions sets the user data associated to \a process.
417  * \param process SIMIX process
418  * \param data User data
419  */
420 void simcall_process_set_data(smx_process_t process, void *data)
421 {
422   if (process == SIMIX_process_self()) {
423     /* avoid a simcall if this function is called by the process itself */
424     SIMIX_process_self_set_data(process, data);
425   }
426   else {
427     simcall_BODY_process_set_data(process, data);
428   }
429 }
430
431 /**
432  * \ingroup simix_process_management
433  * \brief Set the kill time of a process.
434  * \param process a process
435  * \param kill_time a double
436  */
437 void simcall_process_set_kill_time(smx_process_t process, double kill_time)
438 {
439
440   if (kill_time > SIMIX_get_clock()) {
441     if (simix_global->kill_process_function) {
442       XBT_DEBUG("Set kill time %f for process %s(%s)",kill_time, process->name,
443           process->smx_host->name);
444       SIMIX_timer_set(kill_time, simix_global->kill_process_function, process);
445     }
446   }
447 }
448
449 /**
450  * \ingroup simix_process_management
451  * \brief Return the location on which an agent is running.
452  *
453  * This functions returns the smx_host_t corresponding to the location on which
454  * \a process is running.
455  * \param process SIMIX process
456  * \return SIMIX host
457  */
458 smx_host_t simcall_process_get_host(smx_process_t process)
459 {
460   return simcall_BODY_process_get_host(process);
461 }
462
463 /**
464  * \ingroup simix_process_management
465  * \brief Return the name of an agent.
466  *
467  * This functions checks whether \a process is a valid pointer or not and return its name.
468  * \param process SIMIX process
469  * \return The process name
470  */
471 const char* simcall_process_get_name(smx_process_t process)
472 {
473   if (process == SIMIX_process_self()) {
474     /* avoid a simcall if this function is called by the process itself */
475     return process->name;
476   }
477   return simcall_BODY_process_get_name(process);
478 }
479
480 /**
481  * \ingroup simix_process_management
482  * \brief Returns true if the process is suspended .
483  *
484  * This checks whether a process is suspended or not by inspecting the task on which it was waiting for the completion.
485  * \param process SIMIX process
486  * \return 1, if the process is suspended, else 0.
487  */
488 int simcall_process_is_suspended(smx_process_t process)
489 {
490   return  simcall_BODY_process_is_suspended(process);
491 }
492
493 /**
494  * \ingroup simix_process_management
495  * \brief Return the properties
496  *
497  * This functions returns the properties associated with this process
498  */
499 xbt_dict_t simcall_process_get_properties(smx_process_t process)
500 {
501   return simcall_BODY_process_get_properties(process);
502 }
503 /**
504  * \ingroup simix_process_management
505  * \brief Add an on_exit function
506  * Add an on_exit function which will be executed when the process exits/is killed.
507  */
508 XBT_PUBLIC(void) simcall_process_on_exit(smx_process_t process, int_f_pvoid_t fun, void *data)
509 {
510   simcall_BODY_process_on_exit(process, fun, data);
511 }
512 /**
513  * \ingroup simix_process_management
514  * \brief Sets the process to be auto-restarted or not by SIMIX when its host comes back up.
515  * Will restart the process when the host comes back up if auto_restart is set to 1.
516  */
517
518 XBT_PUBLIC(void) simcall_process_auto_restart_set(smx_process_t process, int auto_restart)
519 {
520   simcall_BODY_process_auto_restart_set(process, auto_restart);
521 }
522
523 /**
524  * \ingroup simix_process_management
525  * \brief Restarts the process, killing it and starting it again from scratch.
526  */
527 XBT_PUBLIC(smx_process_t) simcall_process_restart(smx_process_t process)
528 {
529   return simcall_BODY_process_restart(process);
530 }
531 /**
532  * \ingroup simix_process_management
533  * \brief Creates a new sleep SIMIX action.
534  *
535  * This function creates a SURF action and allocates the data necessary
536  * to create the SIMIX action. It can raise a host_error exception if the
537  * host crashed. The default SIMIX name of the action is "sleep".
538  *
539  *   \param duration Time duration of the sleep.
540  *   \return A result telling whether the sleep was successful
541  */
542 e_smx_state_t simcall_process_sleep(double duration)
543 {
544   /* checking for infinite values */
545   xbt_assert(isfinite(duration), "duration is not finite!");
546   return simcall_BODY_process_sleep(duration);
547 }
548
549 /**
550  *  \ingroup simix_rdv_management
551  *  \brief Creates a new rendez-vous point
552  *  \param name The name of the rendez-vous point
553  *  \return The created rendez-vous point
554  */
555 smx_rdv_t simcall_rdv_create(const char *name)
556 {
557   return simcall_BODY_rdv_create(name);
558 }
559
560
561 /**
562  *  \ingroup simix_rdv_management
563  *  \brief Destroy a rendez-vous point
564  *  \param rdv The rendez-vous point to destroy
565  */
566 void simcall_rdv_destroy(smx_rdv_t rdv)
567 {
568   simcall_BODY_rdv_destroy(rdv);
569 }
570 /**
571  *  \ingroup simix_rdv_management
572  *  \brief Returns a rendez-vous point knowing its name
573  */
574 smx_rdv_t simcall_rdv_get_by_name(const char *name)
575 {
576   xbt_assert(name != NULL, "Invalid parameter for simcall_rdv_get_by_name (name is NULL)");
577
578   /* FIXME: this is a horrible lost of performance, so we hack it out by
579    * skipping the simcall (for now). It works in parallel, it won't work on
580    * distributed but probably we will change MSG for that. */
581
582   /*
583   smx_simcall_t simcall = simcall_mine();
584   simcall->call = SIMCALL_RDV_GEY_BY_NAME;
585   simcall->rdv_get_by_name.name = name;
586   SIMIX_simcall_push(simcall->issuer);
587   return simcall->rdv_get_by_name.result;*/
588
589   return SIMIX_rdv_get_by_name(name);
590 }
591
592 /**
593  *  \ingroup simix_rdv_management
594  *  \brief Counts the number of communication actions of a given host pending
595  *         on a rendez-vous point.
596  *  \param rdv The rendez-vous point
597  *  \param host The host to be counted
598  *  \return The number of comm actions pending in the rdv
599  */
600 int simcall_rdv_comm_count_by_host(smx_rdv_t rdv, smx_host_t host)
601 {
602   return simcall_BODY_rdv_comm_count_by_host(rdv, host);
603 }
604
605 /**
606  *  \ingroup simix_rdv_management
607  *  \brief returns the communication at the head of the rendez-vous
608  *  \param rdv The rendez-vous point
609  *  \return The communication or NULL if empty
610  */
611 smx_action_t simcall_rdv_get_head(smx_rdv_t rdv)
612 {
613   return simcall_BODY_rdv_get_head(rdv);
614 }
615
616 void simcall_rdv_set_receiver(smx_rdv_t rdv, smx_process_t process)
617 {
618   simcall_BODY_rdv_set_receiver(rdv, process);
619 }
620
621 smx_process_t simcall_rdv_get_receiver(smx_rdv_t rdv)
622 {
623   return simcall_BODY_rdv_get_receiver(rdv);
624 }
625
626 /**
627  * \ingroup simix_comm_management
628  */
629 void simcall_comm_send(smx_rdv_t rdv, double task_size, double rate,
630                          void *src_buff, size_t src_buff_size,
631                          int (*match_fun)(void *, void *, smx_action_t), void *data,
632                          double timeout)
633 {
634   /* checking for infinite values */
635   xbt_assert(isfinite(task_size), "task_size is not finite!");
636   xbt_assert(isfinite(rate), "rate is not finite!");
637   xbt_assert(isfinite(timeout), "timeout is not finite!");
638   
639   xbt_assert(rdv, "No rendez-vous point defined for send");
640
641   if (MC_is_active()) {
642     /* the model-checker wants two separate simcalls */
643     smx_action_t comm = simcall_comm_isend(rdv, task_size, rate,
644         src_buff, src_buff_size, match_fun, NULL, data, 0);
645     simcall_comm_wait(comm, timeout);
646   }
647   else {
648     simcall_BODY_comm_send(rdv, task_size, rate, src_buff, src_buff_size,
649                          match_fun, data, timeout);
650   }
651 }
652
653 /**
654  * \ingroup simix_comm_management
655  */
656 smx_action_t simcall_comm_isend(smx_rdv_t rdv, double task_size, double rate,
657                               void *src_buff, size_t src_buff_size,
658                               int (*match_fun)(void *, void *, smx_action_t),
659                               void (*clean_fun)(void *),
660                               void *data,
661                               int detached)
662 {
663   /* checking for infinite values */
664   xbt_assert(isfinite(task_size), "task_size is not finite!");
665   xbt_assert(isfinite(rate), "rate is not finite!");
666   
667   xbt_assert(rdv, "No rendez-vous point defined for isend");
668
669   return simcall_BODY_comm_isend(rdv, task_size, rate, src_buff,
670                                  src_buff_size, match_fun,
671                                  clean_fun, data, detached);
672 }
673 /**
674  * \ingroup simix_comm_management
675  */
676 void simcall_comm_recv(smx_rdv_t rdv, void *dst_buff, size_t * dst_buff_size,
677                          int (*match_fun)(void *, void *, smx_action_t), void *data, double timeout)
678 {
679   xbt_assert(isfinite(timeout), "timeout is not finite!");
680   xbt_assert(rdv, "No rendez-vous point defined for recv");
681
682   if (MC_is_active()) {
683     /* the model-checker wants two separate simcalls */
684     smx_action_t comm = simcall_comm_irecv(rdv, dst_buff, dst_buff_size,
685         match_fun, data);
686     simcall_comm_wait(comm, timeout);
687   }
688   else {
689     simcall_BODY_comm_recv(rdv, dst_buff, dst_buff_size,
690                            match_fun, data, timeout);
691   }
692 }
693 /**
694  * \ingroup simix_comm_management
695  */
696 smx_action_t simcall_comm_irecv(smx_rdv_t rdv, void *dst_buff, size_t *dst_buff_size,
697                                   int (*match_fun)(void *, void *, smx_action_t), void *data)
698 {
699   xbt_assert(rdv, "No rendez-vous point defined for irecv");
700
701   return simcall_BODY_comm_irecv(rdv, dst_buff, dst_buff_size, 
702                                  match_fun, data);
703 }
704
705
706 /**
707  * \ingroup simix_comm_management
708  */
709 smx_action_t simcall_comm_iprobe(smx_rdv_t rdv, int src, int tag,
710                                 int (*match_fun)(void *, void *, smx_action_t), void *data)
711 {
712   xbt_assert(rdv, "No rendez-vous point defined for iprobe");
713
714   return simcall_BODY_comm_iprobe(rdv, src, tag, match_fun, data);
715 }
716
717 void simcall_comm_destroy(smx_action_t comm)
718 {
719   xbt_assert(comm, "Invalid parameter");
720
721   /* FIXME remove this simcall type: comms are auto-destroyed now */
722
723   /*
724   smx_simcall_t simcall = simcall_mine();
725
726   simcall->call = SIMCALL_COMM_DESTROY;
727   simcall->comm_destroy.comm = comm;
728
729   SIMIX_simcall_push(simcall->issuer);
730   */
731 }
732
733 /**
734  * \ingroup simix_comm_management
735  */
736 void simcall_comm_cancel(smx_action_t comm)
737 {
738   simcall_BODY_comm_cancel(comm);
739 }
740
741 /**
742  * \ingroup simix_comm_management
743  */
744 unsigned int simcall_comm_waitany(xbt_dynar_t comms)
745 {
746   return simcall_BODY_comm_waitany(comms);
747 }
748
749 /**
750  * \ingroup simix_comm_management
751  */
752 int simcall_comm_testany(xbt_dynar_t comms)
753 {
754   if (xbt_dynar_is_empty(comms))
755     return -1;
756   return simcall_BODY_comm_testany(comms);
757 }
758
759 /**
760  * \ingroup simix_comm_management
761  */
762 void simcall_comm_wait(smx_action_t comm, double timeout)
763 {
764   xbt_assert(isfinite(timeout), "timeout is not finite!");
765   simcall_BODY_comm_wait(comm, timeout);
766 }
767
768 #ifdef HAVE_TRACING
769 /**
770  * \brief Set the category of an action.
771  *
772  * This functions changes the category only. It calls a surf function.
773  * \param execution The execution action
774  * \param category The tracing category
775  */
776 void simcall_set_category(smx_action_t action, const char *category)
777 {
778   if (category == NULL) {
779     return;
780   }
781   simcall_BODY_set_category(action, category);
782 }
783 #endif
784
785 /**
786  * \ingroup simix_comm_management
787  *
788  */
789 int simcall_comm_test(smx_action_t comm)
790 {
791   return simcall_BODY_comm_test(comm);
792 }
793
794 /**
795  * \ingroup simix_comm_management
796  *
797  */
798 double simcall_comm_get_remains(smx_action_t comm)
799 {
800   return simcall_BODY_comm_get_remains(comm);
801 }
802
803 /**
804  * \ingroup simix_comm_management
805  *
806  */
807 e_smx_state_t simcall_comm_get_state(smx_action_t comm)
808 {
809   return simcall_BODY_comm_get_state(comm);
810 }
811
812 /**
813  * \ingroup simix_comm_management
814  *
815  */
816 void *simcall_comm_get_src_data(smx_action_t comm)
817 {
818   return simcall_BODY_comm_get_src_data(comm);
819 }
820
821 /**
822  * \ingroup simix_comm_management
823  *
824  */
825 void *simcall_comm_get_dst_data(smx_action_t comm)
826 {
827   return simcall_BODY_comm_get_dst_data(comm);
828 }
829
830 /**
831  * \ingroup simix_comm_management
832  *
833  */
834 smx_process_t simcall_comm_get_src_proc(smx_action_t comm)
835 {
836   return simcall_BODY_comm_get_src_proc(comm);
837 }
838
839 /**
840  * \ingroup simix_comm_management
841  *
842  */
843 smx_process_t simcall_comm_get_dst_proc(smx_action_t comm)
844 {
845   return simcall_BODY_comm_get_dst_proc(comm);  
846 }
847
848 #ifdef HAVE_LATENCY_BOUND_TRACKING
849 int simcall_comm_is_latency_bounded(smx_action_t comm)
850 {
851   return simcall_BODY_comm_is_latency_bounded(comm);
852 }
853 #endif
854
855 /**
856  * \ingroup simix_synchro_management
857  *
858  */
859 smx_mutex_t simcall_mutex_init(void)
860 {
861   if(!simix_global) {
862     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
863     xbt_abort();
864   }
865   return simcall_BODY_mutex_init();
866 }
867
868 /**
869  * \ingroup simix_synchro_management
870  *
871  */
872 void simcall_mutex_destroy(smx_mutex_t mutex)
873 {
874   simcall_BODY_mutex_destroy(mutex);
875 }
876
877 /**
878  * \ingroup simix_synchro_management
879  *
880  */
881 void simcall_mutex_lock(smx_mutex_t mutex)
882 {
883   simcall_BODY_mutex_lock(mutex);  
884 }
885
886 /**
887  * \ingroup simix_synchro_management
888  *
889  */
890 int simcall_mutex_trylock(smx_mutex_t mutex)
891 {
892   return simcall_BODY_mutex_trylock(mutex);  
893 }
894
895 /**
896  * \ingroup simix_synchro_management
897  *
898  */
899 void simcall_mutex_unlock(smx_mutex_t mutex)
900 {
901   simcall_BODY_mutex_unlock(mutex); 
902 }
903
904 /**
905  * \ingroup simix_synchro_management
906  *
907  */
908 smx_cond_t simcall_cond_init(void)
909 {
910   return simcall_BODY_cond_init();
911 }
912
913 /**
914  * \ingroup simix_synchro_management
915  *
916  */
917 void simcall_cond_destroy(smx_cond_t cond)
918 {
919   simcall_BODY_cond_destroy(cond);
920 }
921
922 /**
923  * \ingroup simix_synchro_management
924  *
925  */
926 void simcall_cond_signal(smx_cond_t cond)
927 {
928   simcall_BODY_cond_signal(cond);
929 }
930
931 /**
932  * \ingroup simix_synchro_management
933  *
934  */
935 void simcall_cond_wait(smx_cond_t cond, smx_mutex_t mutex)
936 {
937   simcall_BODY_cond_wait(cond, mutex);
938 }
939
940 /**
941  * \ingroup simix_synchro_management
942  *
943  */
944 void simcall_cond_wait_timeout(smx_cond_t cond,
945                                  smx_mutex_t mutex,
946                                  double timeout)
947 {
948   xbt_assert(isfinite(timeout), "timeout is not finite!");
949   simcall_BODY_cond_wait_timeout(cond, mutex, timeout);
950 }
951
952 /**
953  * \ingroup simix_synchro_management
954  *
955  */
956 void simcall_cond_broadcast(smx_cond_t cond)
957 {
958   simcall_BODY_cond_broadcast(cond);
959 }
960
961 /**
962  * \ingroup simix_synchro_management
963  *
964  */
965 smx_sem_t simcall_sem_init(int capacity)
966 {
967   return simcall_BODY_sem_init(capacity);  
968 }
969
970 /**
971  * \ingroup simix_synchro_management
972  *
973  */
974 void simcall_sem_destroy(smx_sem_t sem)
975 {
976   simcall_sem_destroy(sem);
977 }
978
979 /**
980  * \ingroup simix_synchro_management
981  *
982  */
983 void simcall_sem_release(smx_sem_t sem)
984 {
985   simcall_BODY_sem_release(sem);  
986 }
987
988 /**
989  * \ingroup simix_synchro_management
990  *
991  */
992 int simcall_sem_would_block(smx_sem_t sem)
993 {
994   return simcall_BODY_sem_would_block(sem);
995 }
996
997 /**
998  * \ingroup simix_synchro_management
999  *
1000  */
1001 void simcall_sem_acquire(smx_sem_t sem)
1002 {
1003   simcall_BODY_sem_acquire(sem);
1004 }
1005
1006 /**
1007  * \ingroup simix_synchro_management
1008  *
1009  */
1010 void simcall_sem_acquire_timeout(smx_sem_t sem, double timeout)
1011 {
1012   xbt_assert(isfinite(timeout), "timeout is not finite!");
1013   simcall_BODY_sem_acquire_timeout(sem, timeout);
1014 }
1015
1016 /**
1017  * \ingroup simix_synchro_management
1018  *
1019  */
1020 int simcall_sem_get_capacity(smx_sem_t sem)
1021 {
1022   return simcall_BODY_sem_get_capacity(sem);
1023 }
1024
1025 /**
1026  * \ingroup simix_file_management
1027  *
1028  */
1029 double simcall_file_read(void* ptr, size_t size, size_t nmemb, smx_file_t stream)
1030 {
1031   return simcall_BODY_file_read(ptr, size, nmemb, stream);
1032 }
1033
1034 /**
1035  * \ingroup simix_file_management
1036  *
1037  */
1038 size_t simcall_file_write(const void* ptr, size_t size, size_t nmemb, smx_file_t stream)
1039 {
1040   return simcall_BODY_file_write(ptr, size, nmemb, stream);
1041 }
1042
1043 /**
1044  * \ingroup simix_file_management
1045  * \brief
1046  */
1047 smx_file_t simcall_file_open(const char* mount, const char* path, const char* mode)
1048 {
1049   return simcall_BODY_file_open(mount, path, mode);
1050 }
1051
1052 /**
1053  * \ingroup simix_file_management
1054  *
1055  */
1056 int simcall_file_close(smx_file_t fp)
1057 {
1058   return simcall_BODY_file_close(fp);  
1059 }
1060
1061 /**
1062  * \ingroup simix_file_management
1063  *
1064  */
1065 int simcall_file_stat(smx_file_t fd, s_file_stat_t *buf)
1066 {
1067   return simcall_BODY_file_stat(fd, buf);
1068 }
1069
1070 /**
1071  * \ingroup simix_file_management
1072  *
1073  */
1074 int simcall_file_unlink(smx_file_t fd)
1075 {
1076   return simcall_BODY_file_unlink(fd);
1077 }
1078
1079 /**
1080  * \ingroup simix_file_management
1081  *
1082  */
1083 xbt_dict_t simcall_file_ls(const char* mount, const char* path)
1084 {
1085   return simcall_BODY_file_ls(mount, path);
1086 }
1087
1088 #ifdef HAVE_MC
1089
1090 void *simcall_mc_snapshot(void)
1091 {
1092   return simcall_BODY_mc_snapshot();
1093 }
1094
1095 int simcall_mc_compare_snapshots(void *s1, void *s2){ 
1096   return simcall_BODY_mc_compare_snapshots(s1, s2);
1097 }
1098
1099 #endif /* HAVE_MC */
1100
1101 /* ****************************************************************************************** */
1102 /* TUTORIAL: New API                                                                          */
1103 /* All functions for simcall                                                                  */
1104 /* ****************************************************************************************** */
1105 int simcall_new_api_fct(const char* param1, double param2){
1106   smx_simcall_t simcall = SIMIX_simcall_mine();
1107   simcall->call = SIMCALL_NEW_API_INIT;
1108   simcall->new_api.param1 = param1;
1109   simcall->new_api.param2 = param2;
1110
1111   SIMIX_simcall_push(simcall->issuer);
1112   return simcall->new_api.result;
1113 }
1114
1115 /* ************************************************************************** */
1116
1117 /** @brief returns a printable string representing a simcall */
1118 const char *SIMIX_simcall_name(e_smx_simcall_t kind) {
1119   return simcall_names[kind];
1120 }