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);
273 * \brief Set the category of an execution action.
275 * This functions changes the priority only. It calls a surf function.
276 * \param execution The execution action
277 * \param priority The new priority
279 void SIMIX_req_host_execution_set_category(smx_action_t execution, const char *category)
283 req.call = REQ_HOST_EXECUTION_SET_CATEGORY;
284 req.host_execution_set_category.execution = execution;
285 req.host_execution_set_category.category = xbt_strdup (category);
286 SIMIX_request_push(&req);
291 * \brief Waits for the completion of an execution action.
293 * \param execution The execution action
295 void SIMIX_req_host_execution_wait(smx_action_t execution)
299 req.call = REQ_HOST_EXECUTION_WAIT;
300 req.host_execution_wait.execution = execution;
301 SIMIX_request_push(&req);
305 * \brief Creates and runs a new SIMIX process.
307 * The structure and the corresponding threada are created and put in the list of ready processes.
309 * \param name a name for the process. It is for user-level information and can be NULL.
310 * \param code the main function of the process
311 * \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.
312 * It can be retrieved with the function \ref SIMIX_req_process_get_data.
313 * \param hostname name of the host where the new agent is executed.
314 * \param argc first argument passed to \a code
315 * \param argv second argument passed to \a code
316 * \param properties the properties of the process
317 * \return The new process
319 smx_process_t SIMIX_req_process_create(const char *name,
320 xbt_main_func_t code,
322 const char *hostname,
323 int argc, char **argv,
324 xbt_dict_t properties)
328 req.call = REQ_PROCESS_CREATE;
329 req.process_create.name = name;
330 req.process_create.code = code;
331 req.process_create.data = data;
332 req.process_create.hostname = hostname;
333 req.process_create.argc = argc;
334 req.process_create.argv = argv;
335 req.process_create.properties = properties;
336 SIMIX_request_push(&req);
337 return req.process_create.result;
340 /** \brief Kills a SIMIX process.
342 * This function simply kills a process.
344 * \param process poor victim
346 void SIMIX_req_process_kill(smx_process_t process)
350 req.call = REQ_PROCESS_KILL;
351 req.process_kill.process = process;
352 SIMIX_request_push(&req);
356 * \brief Migrates an agent to another location.
358 * This function changes the value of the host on which \a process is running.
360 * \param process the process to migrate
361 * \param source name of the previous host
362 * \param dest name of the new host
364 void SIMIX_req_process_change_host(smx_process_t process, const char *source, const char *dest)
368 req.call = REQ_PROCESS_CHANGE_HOST;
369 req.process_change_host.process = process;
370 req.process_change_host.source = source;
371 req.process_change_host.dest = dest;
372 SIMIX_request_push(&req);
376 * \brief Suspends a process.
378 * This function suspends the process by suspending the action
379 * it was waiting for completion.
381 * \param process a SIMIX process
383 void SIMIX_req_process_suspend(smx_process_t process)
387 req.call = REQ_PROCESS_SUSPEND;
388 req.process_suspend.process = process;
389 SIMIX_request_push(&req);
393 * \brief Resumes a suspended process.
395 * This function resumes a suspended process by resuming the action
396 * it was waiting for completion.
398 * \param process a SIMIX process
400 void SIMIX_req_process_resume(smx_process_t process)
404 req.call = REQ_PROCESS_RESUME;
405 req.process_resume.process = process;
406 SIMIX_request_push(&req);
410 * \brief Returns the amount of SIMIX processes in the system
412 * Maestro internal process is not counted, only user code processes are
414 int SIMIX_req_process_count(void)
418 req.call = REQ_PROCESS_COUNT;
419 SIMIX_request_push(&req);
420 return req.process_count.result;
424 * \brief Return the user data of a #smx_process_t.
426 * 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.
427 * \param process SIMIX process
428 * \return A void pointer to the user data
430 void* SIMIX_req_process_get_data(smx_process_t process)
434 req.call = REQ_PROCESS_GET_DATA;
435 req.process_get_data.process = process;
436 SIMIX_request_push(&req);
437 return req.process_get_data.result;
441 * \brief Set the user data of a #m_process_t.
443 * 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.
444 * \param process SIMIX process
445 * \param data User data
447 void SIMIX_req_process_set_data(smx_process_t process, void *data)
451 req.call = REQ_PROCESS_SET_DATA;
452 req.process_set_data.process = process;
453 req.process_set_data.data = data;
454 SIMIX_request_push(&req);
458 * \brief Return the location on which an agent is running.
460 * 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.
461 * \param process SIMIX process
464 smx_host_t SIMIX_req_process_get_host(smx_process_t process)
468 req.call = REQ_PROCESS_GET_HOST;
469 req.process_get_host.process = process;
470 SIMIX_request_push(&req);
471 return req.process_get_host.result;
475 * \brief Return the name of an agent.
477 * This functions checks whether \a process is a valid pointer or not and return its name.
478 * \param process SIMIX process
479 * \return The process name
481 const char* SIMIX_req_process_get_name(smx_process_t process)
485 req.call = REQ_PROCESS_GET_NAME;
486 req.process_get_name.process = process;
487 SIMIX_request_push(&req);
488 return req.process_get_name.result;
492 * \brief Returns true if the process is suspended .
494 * This checks whether a process is suspended or not by inspecting the task on which it was waiting for the completion.
495 * \param process SIMIX process
496 * \return 1, if the process is suspended, else 0.
498 int SIMIX_req_process_is_suspended(smx_process_t process)
502 req.call = REQ_PROCESS_IS_SUSPENDED;
503 req.process_is_suspended.process = process;
504 SIMIX_request_push(&req);
505 return req.process_is_suspended.result;
508 /** \ingroup m_process_management
509 * \brief Return the properties
511 * This functions returns the properties associated with this process
513 xbt_dict_t SIMIX_req_process_get_properties(smx_process_t process)
517 req.call = REQ_PROCESS_GET_PROPERTIES;
518 req.process_get_properties.process = process;
519 SIMIX_request_push(&req);
520 return req.process_get_properties.result;
523 /** \brief Creates a new sleep SIMIX action.
525 * This function creates a SURF action and allocates the data necessary
526 * to create the SIMIX action. It can raise a host_error exception if the
527 * host crashed. The default SIMIX name of the action is "sleep".
529 * \param duration Time duration of the sleep.
530 * \return A result telling whether the sleep was successful
532 e_smx_state_t SIMIX_req_process_sleep(double duration)
536 req.call = REQ_PROCESS_SLEEP;
537 req.process_sleep.duration = duration;
538 SIMIX_request_push(&req);
539 return req.process_sleep.result;
543 * \brief Creates a new rendez-vous point
544 * \param name The name of the rendez-vous point
545 * \return The created rendez-vous point
547 smx_rdv_t SIMIX_req_rdv_create(const char *name)
551 req.call = REQ_RDV_CREATE;
552 req.rdv_create.name = name;
554 SIMIX_request_push(&req);
555 return req.rdv_create.result;
560 * \brief Destroy a rendez-vous point
561 * \param name The rendez-vous point to destroy
563 void SIMIX_req_rdv_destroy(smx_rdv_t rdv)
567 req.call = REQ_RDV_DESTROY;
568 req.rdv_destroy.rdv = rdv;
570 SIMIX_request_push(&req);
573 smx_rdv_t SIMIX_req_rdv_get_by_name(const char *name)
577 req.call = REQ_RDV_GEY_BY_NAME;
578 req.rdv_get_by_name.name = name;
579 SIMIX_request_push(&req);
580 return req.rdv_get_by_name.result;
584 * \brief counts the number of communication requests of a given host pending
585 * on a rendez-vous point
586 * \param rdv The rendez-vous point
587 * \param host The host to be counted
588 * \return The number of comm request pending in the rdv
590 int SIMIX_req_rdv_comm_count_by_host(smx_rdv_t rdv, smx_host_t host)
594 req.call = REQ_RDV_COMM_COUNT_BY_HOST;
595 req.rdv_comm_count_by_host.rdv = rdv;
596 req.rdv_comm_count_by_host.host = host;
598 SIMIX_request_push(&req);
599 return req.rdv_comm_count_by_host.result;
603 * \brief returns the communication at the head of the rendez-vous
604 * \param rdv The rendez-vous point
605 * \return The communication or NULL if empty
607 smx_action_t SIMIX_req_rdv_get_head(smx_rdv_t rdv)
611 req.call = REQ_RDV_GET_HEAD;
612 req.rdv_get_head.rdv = rdv;
614 SIMIX_request_push(&req);
615 return req.rdv_get_head.result;
618 smx_action_t SIMIX_req_comm_isend(smx_rdv_t rdv, double task_size, double rate,
619 void *src_buff, size_t src_buff_size, void *data)
623 xbt_assert0(rdv, "No rendez-vous point defined for isend");
625 req.call = REQ_COMM_ISEND;
626 req.comm_isend.rdv = rdv;
627 req.comm_isend.task_size = task_size;
628 req.comm_isend.rate = rate;
629 req.comm_isend.src_buff = src_buff;
630 req.comm_isend.src_buff_size = src_buff_size;
631 req.comm_isend.data = data;
633 SIMIX_request_push(&req);
634 return req.comm_isend.result;
637 smx_action_t SIMIX_req_comm_irecv(smx_rdv_t rdv, void *dst_buff, size_t * dst_buff_size)
641 xbt_assert0(rdv, "No rendez-vous point defined for isend");
643 req.call = REQ_COMM_IRECV;
644 req.comm_irecv.rdv = rdv;
645 req.comm_irecv.dst_buff = dst_buff;
646 req.comm_irecv.dst_buff_size = dst_buff_size;
648 SIMIX_request_push(&req);
649 return req.comm_irecv.result;
652 void SIMIX_req_comm_destroy(smx_action_t comm)
656 req.call = REQ_COMM_DESTROY;
657 req.comm_destroy.comm = comm;
659 SIMIX_request_push(&req);
662 void SIMIX_req_comm_cancel(smx_action_t comm)
666 req.call = REQ_COMM_CANCEL;
667 req.comm_cancel.comm = comm;
669 SIMIX_request_push(&req);
672 unsigned int SIMIX_req_comm_waitany(xbt_dynar_t comms)
676 req.call = REQ_COMM_WAITANY;
677 req.comm_waitany.comms = comms;
679 SIMIX_request_push(&req);
680 return req.comm_waitany.result;
683 int SIMIX_req_comm_testany(xbt_dynar_t comms)
686 if (xbt_dynar_length(comms)==0)
689 WARN0("SIMIX_comm_testany is not implemented yet. Using waitany instead. This changes the semantic...");
690 req.call = REQ_COMM_WAITANY;
691 req.comm_waitany.comms = comms;
693 SIMIX_request_push(&req);
694 return req.comm_waitany.result;
697 void SIMIX_req_comm_wait(smx_action_t comm, double timeout)
701 req.call = REQ_COMM_WAIT;
702 req.comm_wait.comm = comm;
703 req.comm_wait.timeout = timeout;
705 SIMIX_request_push(&req);
708 int SIMIX_req_comm_test(smx_action_t comm)
712 req.call = REQ_COMM_TEST;
713 req.comm_test.comm = comm;
715 SIMIX_request_push(&req);
716 return req.comm_test.result;
719 double SIMIX_req_comm_get_remains(smx_action_t comm)
723 req.call = REQ_COMM_GET_REMAINS;
724 req.comm_get_remains.comm = comm;
726 SIMIX_request_push(&req);
727 return req.comm_get_remains.result;
730 e_smx_state_t SIMIX_req_comm_get_state(smx_action_t comm)
734 req.call = REQ_COMM_GET_STATE;
735 req.comm_get_state.comm = comm;
737 SIMIX_request_push(&req);
738 return req.comm_get_state.result;
741 void *SIMIX_req_comm_get_data(smx_action_t comm)
745 req.call = REQ_COMM_GET_DATA;
746 req.comm_get_data.comm = comm;
748 SIMIX_request_push(&req);
749 return req.comm_get_data.result;
752 void *SIMIX_req_comm_get_src_buff(smx_action_t comm)
756 req.call = REQ_COMM_GET_SRC_BUFF;
757 req.comm_get_src_buff.comm = comm;
759 SIMIX_request_push(&req);
760 return req.comm_get_src_buff.result;
763 void *SIMIX_req_comm_get_dst_buff(smx_action_t comm)
767 req.call = REQ_COMM_GET_DST_BUFF;
768 req.comm_get_dst_buff.comm = comm;
770 SIMIX_request_push(&req);
771 return req.comm_get_dst_buff.result;
774 size_t SIMIX_req_comm_get_src_buff_size(smx_action_t comm)
778 req.call = REQ_COMM_GET_SRC_BUFF_SIZE;
779 req.comm_get_src_buff_size.comm = comm;
781 SIMIX_request_push(&req);
782 return req.comm_get_src_buff_size.result;
785 size_t SIMIX_req_comm_get_dst_buff_size(smx_action_t comm)
789 req.call = REQ_COMM_GET_DST_BUFF_SIZE;
790 req.comm_get_dst_buff_size.comm = comm;
792 SIMIX_request_push(&req);
793 return req.comm_get_dst_buff_size.result;
796 smx_process_t SIMIX_req_comm_get_src_proc(smx_action_t comm)
800 req.call = REQ_COMM_GET_SRC_PROC;
801 req.comm_get_src_proc.comm = comm;
803 SIMIX_request_push(&req);
804 return req.comm_get_src_proc.result;
807 smx_process_t SIMIX_req_comm_get_dst_proc(smx_action_t comm)
811 req.call = REQ_COMM_GET_DST_PROC;
812 req.comm_get_dst_proc.comm = comm;
814 SIMIX_request_push(&req);
815 return req.comm_get_dst_proc.result;
818 #ifdef HAVE_LATENCY_BOUND_TRACKING
819 int SIMIX_req_comm_is_latency_bounded(smx_action_t comm)
823 req.call = REQ_COMM_IS_LATENCY_BOUNDED;
824 req.comm_is_latency_bounded.comm = comm;
826 SIMIX_request_push(&req);
827 return req.comm_is_latency_bounded.result;
831 smx_mutex_t SIMIX_req_mutex_init(void)
835 req.call = REQ_MUTEX_INIT;
837 SIMIX_request_push(&req);
838 return req.mutex_init.result;
841 void SIMIX_req_mutex_destroy(smx_mutex_t mutex)
845 req.call = REQ_MUTEX_DESTROY;
846 req.mutex_destroy.mutex = mutex;
848 SIMIX_request_push(&req);
851 void SIMIX_req_mutex_lock(smx_mutex_t mutex)
855 req.call = REQ_MUTEX_LOCK;
856 req.mutex_lock.mutex = mutex;
858 SIMIX_request_push(&req);
861 int SIMIX_req_mutex_trylock(smx_mutex_t mutex)
865 req.call = REQ_MUTEX_TRYLOCK;
866 req.mutex_trylock.mutex = mutex;
868 SIMIX_request_push(&req);
869 return req.mutex_trylock.result;
872 void SIMIX_req_mutex_unlock(smx_mutex_t mutex)
876 req.call = REQ_MUTEX_UNLOCK;
877 req.mutex_unlock.mutex = mutex;
879 SIMIX_request_push(&req);
883 smx_cond_t SIMIX_req_cond_init(void)
887 req.call = REQ_COND_INIT;
889 SIMIX_request_push(&req);
890 return req.cond_init.result;
893 void SIMIX_req_cond_destroy(smx_cond_t cond)
897 req.call = REQ_COND_DESTROY;
898 req.cond_destroy.cond = cond;
900 SIMIX_request_push(&req);
903 void SIMIX_req_cond_signal(smx_cond_t cond)
907 req.call = REQ_COND_SIGNAL;
908 req.cond_signal.cond = cond;
910 SIMIX_request_push(&req);
913 void SIMIX_req_cond_wait(smx_cond_t cond, smx_mutex_t mutex)
917 req.call = REQ_COND_WAIT;
918 req.cond_wait.cond = cond;
919 req.cond_wait.mutex = mutex;
921 SIMIX_request_push(&req);
924 void SIMIX_req_cond_wait_timeout(smx_cond_t cond,
930 req.call = REQ_COND_WAIT_TIMEOUT;
931 req.cond_wait_timeout.cond = cond;
932 req.cond_wait_timeout.mutex = mutex;
933 req.cond_wait_timeout.timeout = timeout;
935 SIMIX_request_push(&req);
938 void SIMIX_req_cond_broadcast(smx_cond_t cond)
942 req.call = REQ_COND_BROADCAST;
943 req.cond_broadcast.cond = cond;
945 SIMIX_request_push(&req);
949 smx_sem_t SIMIX_req_sem_init(int capacity)
953 req.call = REQ_SEM_INIT;
954 req.sem_init.capacity = capacity;
956 SIMIX_request_push(&req);
957 return req.sem_init.result;
960 void SIMIX_req_sem_destroy(smx_sem_t sem)
964 req.call = REQ_SEM_DESTROY;
965 req.sem_destroy.sem = sem;
967 SIMIX_request_push(&req);
970 void SIMIX_req_sem_release(smx_sem_t sem)
974 req.call = REQ_SEM_RELEASE;
975 req.sem_release.sem = sem;
977 SIMIX_request_push(&req);
980 int SIMIX_req_sem_would_block(smx_sem_t sem)
984 req.call = REQ_SEM_WOULD_BLOCK;
985 req.sem_would_block.sem = sem;
987 SIMIX_request_push(&req);
988 return req.sem_would_block.result;
991 void SIMIX_req_sem_acquire(smx_sem_t sem)
995 req.call = REQ_SEM_ACQUIRE;
996 req.sem_acquire.sem = sem;
998 SIMIX_request_push(&req);
1001 void SIMIX_req_sem_acquire_timeout(smx_sem_t sem, double timeout)
1005 req.call = REQ_SEM_ACQUIRE_TIMEOUT;
1006 req.sem_acquire_timeout.sem = sem;
1007 req.sem_acquire_timeout.timeout = timeout;
1009 SIMIX_request_push(&req);
1012 int SIMIX_req_sem_get_capacity(smx_sem_t sem)
1016 req.call = REQ_SEM_GET_CAPACITY;
1017 req.sem_get_capacity.sem = sem;
1019 SIMIX_request_push(&req);
1020 return req.sem_get_capacity.result;