3 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix);
5 * \brief Returns a host given its name.
7 * \param name The name of the host to get
8 * \return The corresponding host
10 smx_host_t SIMIX_req_host_get_by_name(const char *name)
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;
21 * \brief Returns the name of a host.
23 * \param host A SIMIX host
24 * \return The name of this host
26 const char* SIMIX_req_host_get_name(smx_host_t host)
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;
37 * \brief Returns a dict of the properties assigned to a host.
40 * \return The properties of this host
42 xbt_dict_t SIMIX_req_host_get_properties(smx_host_t host)
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;
53 * \brief Returns the speed of the processor.
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)
59 double SIMIX_req_host_get_speed(smx_host_t host)
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;
70 * \brief Returns the available speed of the processor.
72 * \return Speed currently available (in Mflop/s)
74 double SIMIX_req_host_get_available_speed(smx_host_t host)
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;
85 * \brief Returns the state of a host.
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
91 int SIMIX_req_host_get_state(smx_host_t host)
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;
102 * \brief Returns the user data associated to a host.
104 * \param host SIMIX host
105 * \return the user data of this host
107 void* SIMIX_req_host_get_data(smx_host_t host)
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;
118 * \brief Sets the user data associated to a host.
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
124 void SIMIX_req_host_set_data(smx_host_t host, void *data)
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);
134 /** \brief Creates an action that executes some computation of an host.
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.
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
144 smx_action_t SIMIX_req_host_execute(const char *name, smx_host_t host,
145 double computation_amount)
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;
157 /** \brief Creates an action that may involve parallel computation on
158 * several hosts and communication between them.
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
170 smx_action_t SIMIX_req_host_parallel_execute(const char *name,
172 smx_host_t *host_list,
173 double *computation_amount,
174 double *communication_amount,
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;
193 * \brief Destroys an execution action.
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
198 void SIMIX_req_host_execution_destroy(smx_action_t execution)
202 req.call = REQ_HOST_EXECUTION_DESTROY;
203 req.host_execution_destroy.execution = execution;
204 SIMIX_request_push(&req);
208 * \brief Cancels an execution action.
210 * This functions stops the execution. It calls a surf function.
211 * \param action The execution action to cancel
213 void SIMIX_req_host_execution_cancel(smx_action_t execution)
217 req.call = REQ_HOST_EXECUTION_CANCEL;
218 req.host_execution_cancel.execution = execution;
219 SIMIX_request_push(&req);
223 * \brief Returns how much of an execution action remains to be done.
225 * \param Action The execution action
226 * \return The remaining amount
228 double SIMIX_req_host_execution_get_remains(smx_action_t execution)
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;
239 * \brief Returns the state of an execution action.
241 * \param execution The execution action
244 e_smx_state_t SIMIX_req_host_execution_get_state(smx_action_t execution)
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;
255 * \brief Changes the priority of an execution action.
257 * This functions changes the priority only. It calls a surf function.
258 * \param execution The execution action
259 * \param priority The new priority
261 void SIMIX_req_host_execution_set_priority(smx_action_t execution, double priority)
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);
272 * \brief Waits for the completion of an execution action.
274 * \param execution The execution action
276 void SIMIX_req_host_execution_wait(smx_action_t execution)
280 req.call = REQ_HOST_EXECUTION_WAIT;
281 req.host_execution_wait.execution = execution;
282 SIMIX_request_push(&req);
286 * \brief Creates and runs a new SIMIX process.
288 * The structure and the corresponding threada are created and put in the list of ready processes.
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
300 smx_process_t SIMIX_req_process_create(const char *name,
301 xbt_main_func_t code,
303 const char *hostname,
304 int argc, char **argv,
305 xbt_dict_t properties)
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;
321 /** \brief Kills a SIMIX process.
323 * This function simply kills a process.
325 * \param process poor victim
327 void SIMIX_req_process_kill(smx_process_t process)
331 req.call = REQ_PROCESS_KILL;
332 req.process_kill.process = process;
333 SIMIX_request_push(&req);
337 * \brief Migrates an agent to another location.
339 * This function changes the value of the host on which \a process is running.
341 * \param process the process to migrate
342 * \param source name of the previous host
343 * \param dest name of the new host
345 void SIMIX_req_process_change_host(smx_process_t process, const char *source, const char *dest)
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);
357 * \brief Suspends a process.
359 * This function suspends the process by suspending the action
360 * it was waiting for completion.
362 * \param process a SIMIX process
364 void SIMIX_req_process_suspend(smx_process_t process)
368 req.call = REQ_PROCESS_SUSPEND;
369 req.process_suspend.process = process;
370 SIMIX_request_push(&req);
374 * \brief Resumes a suspended process.
376 * This function resumes a suspended process by resuming the action
377 * it was waiting for completion.
379 * \param process a SIMIX process
381 void SIMIX_req_process_resume(smx_process_t process)
385 req.call = REQ_PROCESS_RESUME;
386 req.process_resume.process = process;
387 SIMIX_request_push(&req);
391 * \brief Returns the amount of SIMIX processes in the system
393 * Maestro internal process is not counted, only user code processes are
395 int SIMIX_req_process_count(void)
399 req.call = REQ_PROCESS_COUNT;
400 SIMIX_request_push(&req);
401 return req.process_count.result;
405 * \brief Return the user data of a #smx_process_t.
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
411 void* SIMIX_req_process_get_data(smx_process_t process)
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;
422 * \brief Set the user data of a #m_process_t.
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
428 void SIMIX_req_process_set_data(smx_process_t process, void *data)
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);
439 * \brief Return the location on which an agent is running.
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
445 smx_host_t SIMIX_req_process_get_host(smx_process_t process)
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;
456 * \brief Return the name of an agent.
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
462 const char* SIMIX_req_process_get_name(smx_process_t process)
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;
473 * \brief Returns true if the process is suspended .
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.
479 int SIMIX_req_process_is_suspended(smx_process_t process)
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;
489 /** \ingroup m_process_management
490 * \brief Return the properties
492 * This functions returns the properties associated with this process
494 xbt_dict_t SIMIX_req_process_get_properties(smx_process_t process)
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;
504 /** \brief Creates a new sleep SIMIX action.
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".
510 * \param duration Time duration of the sleep.
511 * \return A result telling whether the sleep was successful
513 e_smx_state_t SIMIX_req_process_sleep(double duration)
517 req.call = REQ_PROCESS_SLEEP;
518 req.process_sleep.duration = duration;
519 SIMIX_request_push(&req);
520 return req.process_sleep.result;
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
528 smx_rdv_t SIMIX_req_rdv_create(const char *name)
532 req.call = REQ_RDV_CREATE;
533 req.rdv_create.name = name;
535 SIMIX_request_push(&req);
536 return req.rdv_create.result;
541 * \brief Destroy a rendez-vous point
542 * \param name The rendez-vous point to destroy
544 void SIMIX_req_rdv_destroy(smx_rdv_t rdv)
548 req.call = REQ_RDV_DESTROY;
549 req.rdv_destroy.rdv = rdv;
551 SIMIX_request_push(&req);
554 smx_rdv_t SIMIX_req_rdv_get_by_name(const char *name)
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;
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
571 int SIMIX_req_rdv_comm_count_by_host(smx_rdv_t rdv, smx_host_t host)
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;
579 SIMIX_request_push(&req);
580 return req.rdv_comm_count_by_host.result;
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
588 smx_action_t SIMIX_req_rdv_get_head(smx_rdv_t rdv)
592 req.call = REQ_RDV_GET_HEAD;
593 req.rdv_get_head.rdv = rdv;
595 SIMIX_request_push(&req);
596 return req.rdv_get_head.result;
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)
604 xbt_assert0(rdv, "No rendez-vous point defined for isend");
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;
614 SIMIX_request_push(&req);
615 return req.comm_isend.result;
618 smx_action_t SIMIX_req_comm_irecv(smx_rdv_t rdv, void *dst_buff, size_t * dst_buff_size)
622 xbt_assert0(rdv, "No rendez-vous point defined for isend");
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;
629 SIMIX_request_push(&req);
630 return req.comm_irecv.result;
633 void SIMIX_req_comm_destroy(smx_action_t comm)
637 req.call = REQ_COMM_DESTROY;
638 req.comm_destroy.comm = comm;
640 SIMIX_request_push(&req);
643 void SIMIX_req_comm_cancel(smx_action_t comm)
647 req.call = REQ_COMM_CANCEL;
648 req.comm_cancel.comm = comm;
650 SIMIX_request_push(&req);
653 unsigned int SIMIX_req_comm_waitany(xbt_dynar_t comms)
657 req.call = REQ_COMM_WAITANY;
658 req.comm_waitany.comms = comms;
660 SIMIX_request_push(&req);
661 return req.comm_waitany.result;
664 int SIMIX_req_comm_testany(xbt_dynar_t comms)
667 if (xbt_dynar_length(comms)==0)
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;
674 SIMIX_request_push(&req);
675 return req.comm_waitany.result;
678 void SIMIX_req_comm_wait(smx_action_t comm, double timeout)
682 req.call = REQ_COMM_WAIT;
683 req.comm_wait.comm = comm;
684 req.comm_wait.timeout = timeout;
686 SIMIX_request_push(&req);
691 * \brief Set the category of an action.
693 * This functions changes the category only. It calls a surf function.
694 * \param execution The execution action
695 * \param category The tracing category
697 void SIMIX_req_set_category(smx_action_t action, const char *category)
701 req.call = REQ_SET_CATEGORY;
702 req.set_category.action = action;
703 req.set_category.category = category;
705 SIMIX_request_push(&req);
709 int SIMIX_req_comm_test(smx_action_t comm)
713 req.call = REQ_COMM_TEST;
714 req.comm_test.comm = comm;
716 SIMIX_request_push(&req);
717 return req.comm_test.result;
720 double SIMIX_req_comm_get_remains(smx_action_t comm)
724 req.call = REQ_COMM_GET_REMAINS;
725 req.comm_get_remains.comm = comm;
727 SIMIX_request_push(&req);
728 return req.comm_get_remains.result;
731 e_smx_state_t SIMIX_req_comm_get_state(smx_action_t comm)
735 req.call = REQ_COMM_GET_STATE;
736 req.comm_get_state.comm = comm;
738 SIMIX_request_push(&req);
739 return req.comm_get_state.result;
742 void *SIMIX_req_comm_get_data(smx_action_t comm)
746 req.call = REQ_COMM_GET_DATA;
747 req.comm_get_data.comm = comm;
749 SIMIX_request_push(&req);
750 return req.comm_get_data.result;
753 void *SIMIX_req_comm_get_src_buff(smx_action_t comm)
757 req.call = REQ_COMM_GET_SRC_BUFF;
758 req.comm_get_src_buff.comm = comm;
760 SIMIX_request_push(&req);
761 return req.comm_get_src_buff.result;
764 void *SIMIX_req_comm_get_dst_buff(smx_action_t comm)
768 req.call = REQ_COMM_GET_DST_BUFF;
769 req.comm_get_dst_buff.comm = comm;
771 SIMIX_request_push(&req);
772 return req.comm_get_dst_buff.result;
775 size_t SIMIX_req_comm_get_src_buff_size(smx_action_t comm)
779 req.call = REQ_COMM_GET_SRC_BUFF_SIZE;
780 req.comm_get_src_buff_size.comm = comm;
782 SIMIX_request_push(&req);
783 return req.comm_get_src_buff_size.result;
786 size_t SIMIX_req_comm_get_dst_buff_size(smx_action_t comm)
790 req.call = REQ_COMM_GET_DST_BUFF_SIZE;
791 req.comm_get_dst_buff_size.comm = comm;
793 SIMIX_request_push(&req);
794 return req.comm_get_dst_buff_size.result;
797 smx_process_t SIMIX_req_comm_get_src_proc(smx_action_t comm)
801 req.call = REQ_COMM_GET_SRC_PROC;
802 req.comm_get_src_proc.comm = comm;
804 SIMIX_request_push(&req);
805 return req.comm_get_src_proc.result;
808 smx_process_t SIMIX_req_comm_get_dst_proc(smx_action_t comm)
812 req.call = REQ_COMM_GET_DST_PROC;
813 req.comm_get_dst_proc.comm = comm;
815 SIMIX_request_push(&req);
816 return req.comm_get_dst_proc.result;
819 #ifdef HAVE_LATENCY_BOUND_TRACKING
820 int SIMIX_req_comm_is_latency_bounded(smx_action_t comm)
824 req.call = REQ_COMM_IS_LATENCY_BOUNDED;
825 req.comm_is_latency_bounded.comm = comm;
827 SIMIX_request_push(&req);
828 return req.comm_is_latency_bounded.result;
832 smx_mutex_t SIMIX_req_mutex_init(void)
836 req.call = REQ_MUTEX_INIT;
838 SIMIX_request_push(&req);
839 return req.mutex_init.result;
842 void SIMIX_req_mutex_destroy(smx_mutex_t mutex)
846 req.call = REQ_MUTEX_DESTROY;
847 req.mutex_destroy.mutex = mutex;
849 SIMIX_request_push(&req);
852 void SIMIX_req_mutex_lock(smx_mutex_t mutex)
856 req.call = REQ_MUTEX_LOCK;
857 req.mutex_lock.mutex = mutex;
859 SIMIX_request_push(&req);
862 int SIMIX_req_mutex_trylock(smx_mutex_t mutex)
866 req.call = REQ_MUTEX_TRYLOCK;
867 req.mutex_trylock.mutex = mutex;
869 SIMIX_request_push(&req);
870 return req.mutex_trylock.result;
873 void SIMIX_req_mutex_unlock(smx_mutex_t mutex)
877 req.call = REQ_MUTEX_UNLOCK;
878 req.mutex_unlock.mutex = mutex;
880 SIMIX_request_push(&req);
884 smx_cond_t SIMIX_req_cond_init(void)
888 req.call = REQ_COND_INIT;
890 SIMIX_request_push(&req);
891 return req.cond_init.result;
894 void SIMIX_req_cond_destroy(smx_cond_t cond)
898 req.call = REQ_COND_DESTROY;
899 req.cond_destroy.cond = cond;
901 SIMIX_request_push(&req);
904 void SIMIX_req_cond_signal(smx_cond_t cond)
908 req.call = REQ_COND_SIGNAL;
909 req.cond_signal.cond = cond;
911 SIMIX_request_push(&req);
914 void SIMIX_req_cond_wait(smx_cond_t cond, smx_mutex_t mutex)
918 req.call = REQ_COND_WAIT;
919 req.cond_wait.cond = cond;
920 req.cond_wait.mutex = mutex;
922 SIMIX_request_push(&req);
925 void SIMIX_req_cond_wait_timeout(smx_cond_t cond,
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;
936 SIMIX_request_push(&req);
939 void SIMIX_req_cond_broadcast(smx_cond_t cond)
943 req.call = REQ_COND_BROADCAST;
944 req.cond_broadcast.cond = cond;
946 SIMIX_request_push(&req);
950 smx_sem_t SIMIX_req_sem_init(int capacity)
954 req.call = REQ_SEM_INIT;
955 req.sem_init.capacity = capacity;
957 SIMIX_request_push(&req);
958 return req.sem_init.result;
961 void SIMIX_req_sem_destroy(smx_sem_t sem)
965 req.call = REQ_SEM_DESTROY;
966 req.sem_destroy.sem = sem;
968 SIMIX_request_push(&req);
971 void SIMIX_req_sem_release(smx_sem_t sem)
975 req.call = REQ_SEM_RELEASE;
976 req.sem_release.sem = sem;
978 SIMIX_request_push(&req);
981 int SIMIX_req_sem_would_block(smx_sem_t sem)
985 req.call = REQ_SEM_WOULD_BLOCK;
986 req.sem_would_block.sem = sem;
988 SIMIX_request_push(&req);
989 return req.sem_would_block.result;
992 void SIMIX_req_sem_acquire(smx_sem_t sem)
996 req.call = REQ_SEM_ACQUIRE;
997 req.sem_acquire.sem = sem;
999 SIMIX_request_push(&req);
1002 void SIMIX_req_sem_acquire_timeout(smx_sem_t sem, double timeout)
1006 req.call = REQ_SEM_ACQUIRE_TIMEOUT;
1007 req.sem_acquire_timeout.sem = sem;
1008 req.sem_acquire_timeout.timeout = timeout;
1010 SIMIX_request_push(&req);
1013 int SIMIX_req_sem_get_capacity(smx_sem_t sem)
1017 req.call = REQ_SEM_GET_CAPACITY;
1018 req.sem_get_capacity.sem = sem;
1020 SIMIX_request_push(&req);
1021 return req.sem_get_capacity.result;