Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
5f28f0fc652d6f12276d14349f19b3f9ac7c96d9
[simgrid.git] / src / simix / smx_user.c
1 #include "private.h"
2
3 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix);
4 /**
5  * \brief Returns a host given its name.
6  *
7  * \param name The name of the host to get
8  * \return The corresponding host
9  */
10 smx_host_t SIMIX_req_host_get_by_name(const char *name)
11 {
12   s_smx_req_t req;
13
14   req.call = REQ_HOST_GET_BY_NAME;
15   req.host_get_by_name.name = name;
16   SIMIX_request_push(&req);
17   return req.host_get_by_name.result;
18 }
19
20 /**
21  * \brief Returns the name of a host.
22  *
23  * \param host A SIMIX host
24  * \return The name of this host
25  */
26 const char* SIMIX_req_host_get_name(smx_host_t host)
27 {
28   s_smx_req_t req;
29
30   req.call = REQ_HOST_GET_NAME;
31   req.host_get_name.host = host;
32   SIMIX_request_push(&req);
33   return req.host_get_name.result;
34 }
35
36 /**
37  * \brief Returns a dict of the properties assigned to a host.
38  *
39  * \param host A host
40  * \return The properties of this host
41  */
42 xbt_dict_t SIMIX_req_host_get_properties(smx_host_t host)
43 {
44   s_smx_req_t req;
45
46   req.call = REQ_HOST_GET_PROPERTIES;
47   req.host_get_properties.host = host;
48   SIMIX_request_push(&req);
49   return req.host_get_properties.result;
50 }
51
52 /**
53  * \brief Returns the speed of the processor.
54  *
55  * The speed returned does not take into account the current load on the machine.
56  * \param host A SIMIX host
57  * \return The speed of this host (in Mflop/s)
58  */
59 double SIMIX_req_host_get_speed(smx_host_t host)
60 {
61   s_smx_req_t req;
62
63   req.call = REQ_HOST_GET_SPEED;
64   req.host_get_speed.host = host;
65   SIMIX_request_push(&req);
66   return req.host_get_speed.result;
67 }
68
69 /**
70  * \brief Returns the available speed of the processor.
71  *
72  * \return Speed currently available (in Mflop/s)
73  */
74 double SIMIX_req_host_get_available_speed(smx_host_t host)
75 {
76   s_smx_req_t req;
77
78   req.call = REQ_HOST_GET_AVAILABLE_SPEED;
79   req.host_get_available_speed.host = host;
80   SIMIX_request_push(&req);
81   return req.host_get_available_speed.result;
82 }
83
84 /**
85  * \brief Returns the state of a host.
86  *
87  * Two states are possible: 1 if the host is active or 0 if it has crashed.
88  * \param host A SIMIX host
89  * \return 1 if the host is available, 0 otherwise
90  */
91 int SIMIX_req_host_get_state(smx_host_t host)
92 {
93   s_smx_req_t req;
94
95   req.call = REQ_HOST_GET_STATE;
96   req.host_get_state.host = host;
97   SIMIX_request_push(&req);
98   return req.host_get_state.result;
99 }
100
101 /**
102  * \brief Returns the user data associated to a host.
103  *
104  * \param host SIMIX host
105  * \return the user data of this host
106  */
107 void* SIMIX_req_host_get_data(smx_host_t host)
108 {
109   s_smx_req_t req;
110
111   req.call = REQ_HOST_GET_DATA;
112   req.host_get_data.host = host;
113   SIMIX_request_push(&req);
114   return req.host_get_data.result;
115 }
116
117 /**
118  * \brief Sets the user data associated to a host.
119  *
120  * The host must not have previous user data associated to it.
121  * \param A host SIMIX host
122  * \param data The user data to set
123  */
124 void SIMIX_req_host_set_data(smx_host_t host, void *data)
125 {
126   s_smx_req_t req;
127
128   req.call = REQ_HOST_SET_DATA;
129   req.host_set_data.host = host;
130   req.host_set_data.data = data;
131   SIMIX_request_push(&req);
132 }
133
134 /** \brief Creates an action that executes some computation of an host.
135  *
136  * This function creates a SURF action and allocates the data necessary
137  * to create the SIMIX action. It can raise a host_error exception if the host crashed.
138  *
139  * \param name Name of the execution action to create
140  * \param host SIMIX host where the action will be executed
141  * \param amount Computation amount (in bytes)
142  * \return A new SIMIX execution action
143  */
144 smx_action_t SIMIX_req_host_execute(const char *name, smx_host_t host,
145                                 double computation_amount)
146 {
147   s_smx_req_t req;
148
149   req.call = REQ_HOST_EXECUTE;
150   req.host_execute.name = name;
151   req.host_execute.host = host;
152   req.host_execute.computation_amount = computation_amount;
153   SIMIX_request_push(&req);
154   return req.host_execute.result;
155 }
156
157 /** \brief Creates an action that may involve parallel computation on
158  * several hosts and communication between them.
159  *
160  * \param name Name of the execution action to create
161  * \param host_nb Number of hosts where the action will be executed
162  * \param host_list Array (of size host_nb) of hosts where the action will be executed
163  * \param computation_amount Array (of size host_nb) of computation amount of hosts (in bytes)
164  * \param communication_amount Array (of size host_nb * host_nb) representing the communication
165  * amount between each pair of hosts
166  * \param amount the SURF action amount
167  * \param rate the SURF action rate
168  * \return A new SIMIX execution action
169  */
170 smx_action_t SIMIX_req_host_parallel_execute(const char *name,
171                                          int host_nb,
172                                          smx_host_t *host_list,
173                                          double *computation_amount,
174                                          double *communication_amount,
175                                          double amount,
176                                          double rate)
177 {
178   s_smx_req_t req;
179
180   req.call = REQ_HOST_PARALLEL_EXECUTE;
181   req.host_parallel_execute.name = name;
182   req.host_parallel_execute.host_nb = host_nb;
183   req.host_parallel_execute.host_list = host_list;
184   req.host_parallel_execute.computation_amount = computation_amount;
185   req.host_parallel_execute.communication_amount = communication_amount;
186   req.host_parallel_execute.amount = amount;
187   req.host_parallel_execute.rate = rate;
188   SIMIX_request_push(&req);
189   return req.host_parallel_execute.result;
190 }
191
192 /**
193  * \brief Destroys an execution action.
194  *
195  * Destroys an action, freing its memory. This function cannot be called if there are a conditional waiting for it.
196  * \param action The execution action to destroy
197  */
198 void SIMIX_req_host_execution_destroy(smx_action_t execution)
199 {
200   s_smx_req_t req;
201
202   req.call = REQ_HOST_EXECUTION_DESTROY;
203   req.host_execution_destroy.execution = execution;
204   SIMIX_request_push(&req);
205 }
206
207 /**
208  * \brief Cancels an execution action.
209  *
210  * This functions stops the execution. It calls a surf function.
211  * \param action The execution action to cancel
212  */
213 void SIMIX_req_host_execution_cancel(smx_action_t execution)
214 {
215   s_smx_req_t req;
216
217   req.call = REQ_HOST_EXECUTION_CANCEL;
218   req.host_execution_cancel.execution = execution;
219   SIMIX_request_push(&req);
220 }
221
222 /**
223  * \brief Returns how much of an execution action remains to be done.
224  *
225  * \param Action The execution action
226  * \return The remaining amount
227  */
228 double SIMIX_req_host_execution_get_remains(smx_action_t execution)
229 {
230   s_smx_req_t req;
231
232   req.call = REQ_HOST_EXECUTION_GET_REMAINS;
233   req.host_execution_get_remains.execution = execution;
234   SIMIX_request_push(&req);
235   return req.host_execution_get_remains.result;
236 }
237
238 /**
239  * \brief Returns the state of an execution action.
240  *
241  * \param execution The execution action
242  * \return The state
243  */
244 e_smx_state_t SIMIX_req_host_execution_get_state(smx_action_t execution)
245 {
246   s_smx_req_t req;
247
248   req.call = REQ_HOST_EXECUTION_GET_STATE;
249   req.host_execution_get_state.execution = execution;
250   SIMIX_request_push(&req);
251   return req.host_execution_get_state.result;
252 }
253
254 /**
255  * \brief Changes the priority of an execution action.
256  *
257  * This functions changes the priority only. It calls a surf function.
258  * \param execution The execution action
259  * \param priority The new priority
260  */
261 void SIMIX_req_host_execution_set_priority(smx_action_t execution, double priority)
262 {
263   s_smx_req_t req;
264
265   req.call = REQ_HOST_EXECUTION_SET_PRIORITY;
266   req.host_execution_set_priority.execution = execution;
267   req.host_execution_set_priority.priority = priority;
268   SIMIX_request_push(&req);
269 }
270
271 /**
272  * \brief Waits for the completion of an execution action.
273  *
274  * \param execution The execution action
275  */
276 void SIMIX_req_host_execution_wait(smx_action_t execution)
277 {
278   s_smx_req_t req;
279
280   req.call = REQ_HOST_EXECUTION_WAIT;
281   req.host_execution_wait.execution = execution;
282   SIMIX_request_push(&req);
283 }
284
285 /**
286  * \brief Creates and runs a new SIMIX process.
287  *
288  * The structure and the corresponding threada are created and put in the list of ready processes.
289  *
290  * \param name a name for the process. It is for user-level information and can be NULL.
291  * \param code the main function of the process
292  * \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.
293  * It can be retrieved with the function \ref SIMIX_req_process_get_data.
294  * \param hostname name of the host where the new agent is executed.
295  * \param argc first argument passed to \a code
296  * \param argv second argument passed to \a code
297  * \param properties the properties of the process
298  * \return The new process
299  */
300 smx_process_t SIMIX_req_process_create(const char *name,
301                                    xbt_main_func_t code,
302                                    void *data,
303                                    const char *hostname,
304                                    int argc, char **argv,
305                                    xbt_dict_t properties)
306 {
307   s_smx_req_t req;
308
309   req.call = REQ_PROCESS_CREATE;
310   req.process_create.name = name;
311   req.process_create.code = code;
312   req.process_create.data = data;
313   req.process_create.hostname = hostname;
314   req.process_create.argc = argc;
315   req.process_create.argv = argv;
316   req.process_create.properties = properties;
317   SIMIX_request_push(&req);
318   return req.process_create.result;
319 }
320
321 /** \brief Kills a SIMIX process.
322  *
323  * This function simply kills a  process.
324  *
325  * \param process poor victim
326  */
327 void SIMIX_req_process_kill(smx_process_t process)
328 {
329   s_smx_req_t req;
330
331   req.call = REQ_PROCESS_KILL;
332   req.process_kill.process = process;
333   SIMIX_request_push(&req);
334 }
335
336 /**
337  * \brief Migrates an agent to another location.
338  *
339  * This function changes the value of the host on which \a process is running.
340  *
341  * \param process the process to migrate
342  * \param source name of the previous host
343  * \param dest name of the new host
344  */
345 void SIMIX_req_process_change_host(smx_process_t process, const char *source, const char *dest)
346 {
347   s_smx_req_t req;
348
349   req.call = REQ_PROCESS_CHANGE_HOST;
350   req.process_change_host.process = process;
351   req.process_change_host.source = source;
352   req.process_change_host.dest = dest;
353   SIMIX_request_push(&req);
354 }
355
356 /**
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 SIMIX_req_process_suspend(smx_process_t process)
365 {
366   s_smx_req_t req;
367
368   req.call = REQ_PROCESS_SUSPEND;
369   req.process_suspend.process = process;
370   SIMIX_request_push(&req);
371 }
372
373 /**
374  * \brief Resumes a suspended process.
375  *
376  * This function resumes a suspended process by resuming the action
377  * it was waiting for completion.
378  *
379  * \param process a SIMIX process
380  */
381 void SIMIX_req_process_resume(smx_process_t process)
382 {
383   s_smx_req_t req;
384
385   req.call = REQ_PROCESS_RESUME;
386   req.process_resume.process = process;
387   SIMIX_request_push(&req);
388 }
389
390 /**
391  * \brief Returns the amount of SIMIX processes in the system
392  *
393  * Maestro internal process is not counted, only user code processes are
394  */
395 int SIMIX_req_process_count(void)
396 {
397   s_smx_req_t req;
398
399   req.call = REQ_PROCESS_COUNT;
400   SIMIX_request_push(&req);
401   return req.process_count.result;
402 }
403
404 /**
405  * \brief Return the user data of a #smx_process_t.
406  *
407  * This functions checks whether \a process is a valid pointer or not and return the user data associated to \a process if it is possible.
408  * \param process SIMIX process
409  * \return A void pointer to the user data
410  */
411 void* SIMIX_req_process_get_data(smx_process_t process)
412 {
413   s_smx_req_t req;
414
415   req.call = REQ_PROCESS_GET_DATA;
416   req.process_get_data.process = process;
417   SIMIX_request_push(&req);
418   return req.process_get_data.result;
419 }
420
421 /**
422  * \brief Set the user data of a #m_process_t.
423  *
424  * This functions checks whether \a process is a valid pointer or not and set the user data associated to \a process if it is possible.
425  * \param process SIMIX process
426  * \param data User data
427  */
428 void SIMIX_req_process_set_data(smx_process_t process, void *data)
429 {
430   s_smx_req_t req;
431
432   req.call = REQ_PROCESS_SET_DATA;
433   req.process_set_data.process = process;
434   req.process_set_data.data = data;
435   SIMIX_request_push(&req);
436 }
437
438 /**
439  * \brief Return the location on which an agent is running.
440  *
441  * This functions checks whether \a process is a valid pointer or not and return the m_host_t corresponding to the location on which \a process is running.
442  * \param process SIMIX process
443  * \return SIMIX host
444  */
445 smx_host_t SIMIX_req_process_get_host(smx_process_t process)
446 {
447   s_smx_req_t req;
448
449   req.call = REQ_PROCESS_GET_HOST;
450   req.process_get_host.process = process;
451   SIMIX_request_push(&req);
452   return req.process_get_host.result;
453 }
454
455 /**
456  * \brief Return the name of an agent.
457  *
458  * This functions checks whether \a process is a valid pointer or not and return its name.
459  * \param process SIMIX process
460  * \return The process name
461  */
462 const char* SIMIX_req_process_get_name(smx_process_t process)
463 {
464   s_smx_req_t req;
465
466   req.call = REQ_PROCESS_GET_NAME;
467   req.process_get_name.process = process;
468   SIMIX_request_push(&req);
469   return req.process_get_name.result;
470 }
471
472 /**
473  * \brief Returns true if the process is suspended .
474  *
475  * This checks whether a process is suspended or not by inspecting the task on which it was waiting for the completion.
476  * \param process SIMIX process
477  * \return 1, if the process is suspended, else 0.
478  */
479 int SIMIX_req_process_is_suspended(smx_process_t process)
480 {
481   s_smx_req_t req;
482
483   req.call = REQ_PROCESS_IS_SUSPENDED;
484   req.process_is_suspended.process = process;
485   SIMIX_request_push(&req);
486   return req.process_is_suspended.result;
487 }
488
489 /** \ingroup m_process_management
490  * \brief Return the properties
491  *
492  * This functions returns the properties associated with this process
493  */
494 xbt_dict_t SIMIX_req_process_get_properties(smx_process_t process)
495 {
496   s_smx_req_t req;
497
498   req.call = REQ_PROCESS_GET_PROPERTIES;
499   req.process_get_properties.process = process;
500   SIMIX_request_push(&req);
501   return req.process_get_properties.result;
502 }
503
504 /** \brief Creates a new sleep SIMIX action.
505  *
506  * This function creates a SURF action and allocates the data necessary
507  * to create the SIMIX action. It can raise a host_error exception if the
508  * host crashed. The default SIMIX name of the action is "sleep".
509  *
510  *      \param duration Time duration of the sleep.
511  *      \return A result telling whether the sleep was successful
512  */
513 e_smx_state_t SIMIX_req_process_sleep(double duration)
514 {
515   s_smx_req_t req;
516
517   req.call = REQ_PROCESS_SLEEP;
518   req.process_sleep.duration = duration;
519   SIMIX_request_push(&req);
520   return req.process_sleep.result;
521 }
522
523 /**
524  *  \brief Creates a new rendez-vous point
525  *  \param name The name of the rendez-vous point
526  *  \return The created rendez-vous point
527  */
528 smx_rdv_t SIMIX_req_rdv_create(const char *name)
529 {
530   s_smx_req_t req;
531
532   req.call = REQ_RDV_CREATE;
533   req.rdv_create.name = name;
534
535   SIMIX_request_push(&req);
536   return req.rdv_create.result;
537 }
538
539
540 /**
541  *  \brief Destroy a rendez-vous point
542  *  \param name The rendez-vous point to destroy
543  */
544 void SIMIX_req_rdv_destroy(smx_rdv_t rdv)
545 {
546   s_smx_req_t req;
547
548   req.call = REQ_RDV_DESTROY; 
549   req.rdv_destroy.rdv = rdv;
550
551   SIMIX_request_push(&req);
552 }
553
554 smx_rdv_t SIMIX_req_rdv_get_by_name(const char *name)
555 {
556   s_smx_req_t req;
557
558   req.call = REQ_RDV_GEY_BY_NAME;
559   req.rdv_get_by_name.name = name;
560   SIMIX_request_push(&req);
561   return req.rdv_get_by_name.result;
562 }
563
564 /**
565  *  \brief counts the number of communication requests of a given host pending
566  *         on a rendez-vous point
567  *  \param rdv The rendez-vous point
568  *  \param host The host to be counted
569  *  \return The number of comm request pending in the rdv
570  */
571 int SIMIX_req_rdv_comm_count_by_host(smx_rdv_t rdv, smx_host_t host)
572 {
573   s_smx_req_t req;
574
575   req.call = REQ_RDV_COMM_COUNT_BY_HOST; 
576   req.rdv_comm_count_by_host.rdv = rdv;
577   req.rdv_comm_count_by_host.host = host;
578
579   SIMIX_request_push(&req);
580   return req.rdv_comm_count_by_host.result;
581 }
582
583 /**
584  *  \brief returns the communication at the head of the rendez-vous
585  *  \param rdv The rendez-vous point
586  *  \return The communication or NULL if empty
587  */
588 smx_action_t SIMIX_req_rdv_get_head(smx_rdv_t rdv)
589 {
590   s_smx_req_t req;
591
592   req.call = REQ_RDV_GET_HEAD; 
593   req.rdv_get_head.rdv = rdv;
594
595   SIMIX_request_push(&req);
596   return req.rdv_get_head.result;
597 }
598
599 smx_action_t SIMIX_req_comm_isend(smx_rdv_t rdv, double task_size, double rate,
600                               void *src_buff, size_t src_buff_size, void *data)
601 {
602   s_smx_req_t req;
603
604   xbt_assert0(rdv, "No rendez-vous point defined for isend");
605
606   req.call = REQ_COMM_ISEND;
607   req.comm_isend.rdv = rdv;
608   req.comm_isend.task_size = task_size;
609   req.comm_isend.rate = rate;
610   req.comm_isend.src_buff = src_buff;
611   req.comm_isend.src_buff_size = src_buff_size;
612   req.comm_isend.data = data;
613
614   SIMIX_request_push(&req);
615   return req.comm_isend.result;
616 }
617
618 smx_action_t SIMIX_req_comm_irecv(smx_rdv_t rdv, void *dst_buff, size_t * dst_buff_size)
619 {
620   s_smx_req_t req;
621
622   xbt_assert0(rdv, "No rendez-vous point defined for isend");
623
624   req.call = REQ_COMM_IRECV;
625   req.comm_irecv.rdv = rdv;
626   req.comm_irecv.dst_buff = dst_buff;
627   req.comm_irecv.dst_buff_size = dst_buff_size;
628
629   SIMIX_request_push(&req);
630   return req.comm_irecv.result;
631 }
632
633 void SIMIX_req_comm_destroy(smx_action_t comm)
634 {
635   s_smx_req_t req;
636
637   req.call = REQ_COMM_DESTROY;
638   req.comm_destroy.comm = comm;
639
640   SIMIX_request_push(&req);
641 }
642
643 void SIMIX_req_comm_cancel(smx_action_t comm)
644 {
645   s_smx_req_t req;
646
647   req.call = REQ_COMM_CANCEL;
648   req.comm_cancel.comm = comm;
649
650   SIMIX_request_push(&req);
651 }
652
653 unsigned int SIMIX_req_comm_waitany(xbt_dynar_t comms)
654 {
655   s_smx_req_t req;
656
657   req.call = REQ_COMM_WAITANY;
658   req.comm_waitany.comms = comms;
659
660   SIMIX_request_push(&req);
661   return req.comm_waitany.result;
662 }
663
664 int SIMIX_req_comm_testany(xbt_dynar_t comms)
665 {
666   s_smx_req_t req;
667   if (xbt_dynar_length(comms)==0)
668     return -1;
669
670   WARN0("SIMIX_comm_testany is not implemented yet. Using waitany instead. This changes the semantic...");
671   req.call = REQ_COMM_WAITANY;
672   req.comm_waitany.comms = comms;
673
674   SIMIX_request_push(&req);
675   return req.comm_waitany.result;
676 }
677
678 void SIMIX_req_comm_wait(smx_action_t comm, double timeout)
679 {
680   s_smx_req_t req;
681
682   req.call = REQ_COMM_WAIT;
683   req.comm_wait.comm = comm;
684   req.comm_wait.timeout = timeout;
685
686   SIMIX_request_push(&req);
687 }
688
689 #ifdef HAVE_TRACING
690 /**
691  * \brief Set the category of an action.
692  *
693  * This functions changes the category only. It calls a surf function.
694  * \param execution The execution action
695  * \param category The tracing category
696  */
697 void SIMIX_req_set_category(smx_action_t action, const char *category)
698 {
699   s_smx_req_t req;
700
701   req.call = REQ_SET_CATEGORY;
702   req.set_category.action = action;
703   req.set_category.category = category;
704
705   SIMIX_request_push(&req);
706 }
707 #endif
708
709 int SIMIX_req_comm_test(smx_action_t comm)
710 {
711   s_smx_req_t req;
712
713   req.call = REQ_COMM_TEST;
714   req.comm_test.comm = comm;
715
716   SIMIX_request_push(&req);
717   return req.comm_test.result;
718 }
719
720 double SIMIX_req_comm_get_remains(smx_action_t comm)
721 {
722   s_smx_req_t req;
723
724   req.call = REQ_COMM_GET_REMAINS;
725   req.comm_get_remains.comm = comm;
726
727   SIMIX_request_push(&req);
728   return req.comm_get_remains.result;
729 }
730
731 e_smx_state_t SIMIX_req_comm_get_state(smx_action_t comm)
732 {
733   s_smx_req_t req;
734
735   req.call = REQ_COMM_GET_STATE;
736   req.comm_get_state.comm = comm;
737
738   SIMIX_request_push(&req);
739   return req.comm_get_state.result;
740 }
741
742 void *SIMIX_req_comm_get_data(smx_action_t comm)
743 {
744   s_smx_req_t req;
745
746   req.call = REQ_COMM_GET_DATA;
747   req.comm_get_data.comm = comm;
748
749   SIMIX_request_push(&req);
750   return req.comm_get_data.result;
751 }
752
753 void *SIMIX_req_comm_get_src_buff(smx_action_t comm)
754 {
755   s_smx_req_t req;
756
757   req.call = REQ_COMM_GET_SRC_BUFF;
758   req.comm_get_src_buff.comm = comm;
759
760   SIMIX_request_push(&req);
761   return req.comm_get_src_buff.result;
762 }
763
764 void *SIMIX_req_comm_get_dst_buff(smx_action_t comm)
765 {
766   s_smx_req_t req;
767
768   req.call = REQ_COMM_GET_DST_BUFF;
769   req.comm_get_dst_buff.comm = comm;
770
771   SIMIX_request_push(&req);
772   return req.comm_get_dst_buff.result;
773 }
774
775 size_t SIMIX_req_comm_get_src_buff_size(smx_action_t comm)
776 {
777   s_smx_req_t req;
778
779   req.call = REQ_COMM_GET_SRC_BUFF_SIZE;
780   req.comm_get_src_buff_size.comm = comm;
781
782   SIMIX_request_push(&req);
783   return req.comm_get_src_buff_size.result;
784 }
785
786 size_t SIMIX_req_comm_get_dst_buff_size(smx_action_t comm)
787 {
788   s_smx_req_t req;
789
790   req.call = REQ_COMM_GET_DST_BUFF_SIZE;
791   req.comm_get_dst_buff_size.comm = comm;
792
793   SIMIX_request_push(&req);
794   return req.comm_get_dst_buff_size.result;
795 }
796
797 smx_process_t SIMIX_req_comm_get_src_proc(smx_action_t comm)
798 {
799   s_smx_req_t req;
800
801   req.call = REQ_COMM_GET_SRC_PROC;
802   req.comm_get_src_proc.comm = comm;
803
804   SIMIX_request_push(&req);
805   return req.comm_get_src_proc.result;
806 }
807
808 smx_process_t SIMIX_req_comm_get_dst_proc(smx_action_t comm)
809 {
810   s_smx_req_t req;
811
812   req.call = REQ_COMM_GET_DST_PROC;
813   req.comm_get_dst_proc.comm = comm;
814
815   SIMIX_request_push(&req);
816   return req.comm_get_dst_proc.result;
817 }
818
819 #ifdef HAVE_LATENCY_BOUND_TRACKING
820 int SIMIX_req_comm_is_latency_bounded(smx_action_t comm)
821 {
822   s_smx_req_t req;
823
824   req.call = REQ_COMM_IS_LATENCY_BOUNDED;
825   req.comm_is_latency_bounded.comm = comm;
826
827   SIMIX_request_push(&req);
828   return req.comm_is_latency_bounded.result;
829 }
830 #endif
831
832 smx_mutex_t SIMIX_req_mutex_init(void)
833 {
834   s_smx_req_t req;
835
836   req.call = REQ_MUTEX_INIT;
837
838   SIMIX_request_push(&req);
839   return req.mutex_init.result;
840 }
841
842 void SIMIX_req_mutex_destroy(smx_mutex_t mutex)
843 {
844   s_smx_req_t req;
845
846   req.call = REQ_MUTEX_DESTROY;
847   req.mutex_destroy.mutex = mutex;
848
849   SIMIX_request_push(&req);
850 }
851
852 void SIMIX_req_mutex_lock(smx_mutex_t mutex)
853 {
854   s_smx_req_t req;
855
856   req.call = REQ_MUTEX_LOCK;
857   req.mutex_lock.mutex = mutex;
858
859   SIMIX_request_push(&req);
860 }
861
862 int SIMIX_req_mutex_trylock(smx_mutex_t mutex)
863 {
864   s_smx_req_t req;
865
866   req.call = REQ_MUTEX_TRYLOCK;
867   req.mutex_trylock.mutex = mutex;
868
869   SIMIX_request_push(&req);
870   return req.mutex_trylock.result;
871 }
872
873 void SIMIX_req_mutex_unlock(smx_mutex_t mutex)
874 {
875   s_smx_req_t req;
876
877   req.call = REQ_MUTEX_UNLOCK;
878   req.mutex_unlock.mutex = mutex;
879
880   SIMIX_request_push(&req);
881 }
882
883
884 smx_cond_t SIMIX_req_cond_init(void)
885 {
886   s_smx_req_t req;
887
888   req.call = REQ_COND_INIT;
889
890   SIMIX_request_push(&req);
891   return req.cond_init.result;
892 }
893
894 void SIMIX_req_cond_destroy(smx_cond_t cond)
895 {
896   s_smx_req_t req;
897
898   req.call = REQ_COND_DESTROY;
899   req.cond_destroy.cond = cond;
900
901   SIMIX_request_push(&req);
902 }
903
904 void SIMIX_req_cond_signal(smx_cond_t cond)
905 {
906   s_smx_req_t req;
907
908   req.call = REQ_COND_SIGNAL;
909   req.cond_signal.cond = cond;
910
911   SIMIX_request_push(&req);
912 }
913
914 void SIMIX_req_cond_wait(smx_cond_t cond, smx_mutex_t mutex)
915 {
916   s_smx_req_t req;
917
918   req.call = REQ_COND_WAIT;
919   req.cond_wait.cond = cond;
920   req.cond_wait.mutex = mutex;
921
922   SIMIX_request_push(&req);
923 }
924
925 void SIMIX_req_cond_wait_timeout(smx_cond_t cond,
926                                  smx_mutex_t mutex,
927                                  double timeout)
928 {
929   s_smx_req_t req;
930
931   req.call = REQ_COND_WAIT_TIMEOUT;
932   req.cond_wait_timeout.cond = cond;
933   req.cond_wait_timeout.mutex = mutex;
934   req.cond_wait_timeout.timeout = timeout;
935
936   SIMIX_request_push(&req);
937 }
938
939 void SIMIX_req_cond_broadcast(smx_cond_t cond)
940 {
941   s_smx_req_t req;
942
943   req.call = REQ_COND_BROADCAST;
944   req.cond_broadcast.cond = cond;
945
946   SIMIX_request_push(&req);
947 }
948
949
950 smx_sem_t SIMIX_req_sem_init(int capacity)
951 {
952   s_smx_req_t req;
953
954   req.call = REQ_SEM_INIT;
955   req.sem_init.capacity = capacity;
956
957   SIMIX_request_push(&req);
958   return req.sem_init.result;
959 }
960
961 void SIMIX_req_sem_destroy(smx_sem_t sem)
962 {
963   s_smx_req_t req;
964
965   req.call = REQ_SEM_DESTROY;
966   req.sem_destroy.sem = sem;
967
968   SIMIX_request_push(&req);
969 }
970
971 void SIMIX_req_sem_release(smx_sem_t sem)
972 {
973   s_smx_req_t req;
974
975   req.call = REQ_SEM_RELEASE;
976   req.sem_release.sem = sem;
977
978   SIMIX_request_push(&req);
979 }
980
981 int SIMIX_req_sem_would_block(smx_sem_t sem)
982 {
983   s_smx_req_t req;
984
985   req.call = REQ_SEM_WOULD_BLOCK;
986   req.sem_would_block.sem = sem;
987
988   SIMIX_request_push(&req);
989   return req.sem_would_block.result;
990 }
991
992 void SIMIX_req_sem_acquire(smx_sem_t sem)
993 {
994   s_smx_req_t req;
995
996   req.call = REQ_SEM_ACQUIRE;
997   req.sem_acquire.sem = sem;
998
999   SIMIX_request_push(&req);
1000 }
1001
1002 void SIMIX_req_sem_acquire_timeout(smx_sem_t sem, double timeout)
1003 {
1004   s_smx_req_t req;
1005
1006   req.call = REQ_SEM_ACQUIRE_TIMEOUT;
1007   req.sem_acquire_timeout.sem = sem;
1008   req.sem_acquire_timeout.timeout = timeout;
1009
1010   SIMIX_request_push(&req);
1011 }
1012
1013 int SIMIX_req_sem_get_capacity(smx_sem_t sem)
1014 {
1015   s_smx_req_t req;
1016
1017   req.call = REQ_SEM_GET_CAPACITY;
1018   req.sem_get_capacity.sem = sem;
1019
1020   SIMIX_request_push(&req);
1021   return req.sem_get_capacity.result;
1022 }
1023
1024
1025