}
/* ************************************************************************** */
-/** @brief gets the result of previous syscall
- *
- * This function is only useful in state machine mechanism.
- *
- * In this case, the execution of every SIMIX_req_* function above was cut at
- * SIMIX_request_push(), which calls yield() which calls suspend(), which longjmp
- * to the point right before running the user code. When the control is passed
- * back to the user, he needs to get the result of the syscall he did.
- * That is why this function is made for.
- *
- * To extend this function, simply make sure that the end of the SIMIX_req_*
- * function matches what is written in this big switch
- */
-void *SIMIX_request_get_result(int kind) {
- smx_req_t req = SIMIX_req_mine();
+/** @brief returns a printable string representing the request kind */
+const char *SIMIX_request_name(int kind) {
switch ((e_smx_req_t) kind) {
- case REQ_NO_REQ:
- xbt_die("There is no request waiting, cannot provide the result");
- case REQ_HOST_GET_BY_NAME:
- return req->host_get_by_name.result;
- case REQ_HOST_GET_NAME:
- return (void*)req->host_get_name.result;
- case REQ_HOST_GET_PROPERTIES:
- return req->host_get_properties.result;
- case REQ_HOST_GET_SPEED:
- return &req->host_get_speed.result; /* double */
- case REQ_HOST_GET_AVAILABLE_SPEED:
- return &req->host_get_available_speed.result; /* double */
- case REQ_HOST_GET_STATE:
- return &req->host_get_state.result; /* int */
- case REQ_HOST_GET_DATA:
- return req->host_get_data.result;
- case REQ_HOST_SET_DATA:
- return NULL; /* void */
- case REQ_HOST_EXECUTE:
- return req->host_execute.result;
- case REQ_HOST_PARALLEL_EXECUTE:
- return req->host_parallel_execute.result;
- case REQ_HOST_EXECUTION_DESTROY:
- return NULL; /* void */
- case REQ_HOST_EXECUTION_CANCEL:
- return NULL; /* void */
- case REQ_HOST_EXECUTION_GET_REMAINS:
- return &req->host_execution_get_remains.result; /* double */
- case REQ_HOST_EXECUTION_GET_STATE:
- return &req->host_execution_get_state.result; /* e_smx_state_t */
- case REQ_HOST_EXECUTION_SET_PRIORITY:
- return NULL; /* void */
- case REQ_HOST_EXECUTION_WAIT:
- return NULL; /* void */
- case REQ_PROCESS_CREATE:
- return req->process_create.result;
- case REQ_PROCESS_KILL:
- return NULL; /* void */
- case REQ_PROCESS_CHANGE_HOST:
- return NULL; /* void */
- case REQ_PROCESS_SUSPEND:
- return NULL; /* void */
- case REQ_PROCESS_RESUME:
- return NULL; /* void */
- case REQ_PROCESS_COUNT:
- return &req->process_count.result; /* int */
- case REQ_PROCESS_GET_DATA:
- return req->process_get_data.result;
- case REQ_PROCESS_SET_DATA:
- return NULL; /* void */
- case REQ_PROCESS_GET_HOST:
- return req->process_get_host.result;
- case REQ_PROCESS_GET_NAME:
- return (void*)req->process_get_name.result;
- case REQ_PROCESS_IS_SUSPENDED:
- return &req->process_is_suspended.result; /* int */
- case REQ_PROCESS_GET_PROPERTIES:
- return req->process_get_properties.result;
- case REQ_PROCESS_SLEEP:
- return &req->process_sleep.result; /* e_smx_state_t */
- case REQ_RDV_CREATE:
- return req->rdv_create.result;
- case REQ_RDV_DESTROY:
- return NULL; /* void */
- case REQ_RDV_GEY_BY_NAME:
- return req->rdv_get_by_name.result;
- case REQ_RDV_COMM_COUNT_BY_HOST:
- return &req->rdv_comm_count_by_host.result; /* int */
- case REQ_RDV_GET_HEAD:
- return req->rdv_get_head.result;
- case REQ_COMM_ISEND:
- return req->comm_isend.result;
- case REQ_COMM_IRECV:
- return req->comm_irecv.result;
- case REQ_COMM_DESTROY:
- case REQ_COMM_CANCEL:
- return NULL; /* void */
- case REQ_COMM_WAITANY:
- return &req->comm_waitany.result;
- case REQ_COMM_TESTANY:
- return &req->comm_testany.result;
- case REQ_COMM_WAIT:
- return NULL; /* void */
+ case REQ_NO_REQ: return "REQ_NO_REQ";
+ case REQ_HOST_GET_BY_NAME: return "REQ_HOST_GET_BY_NAME";
+ case REQ_HOST_GET_NAME: return "REQ_HOST_GET_NAME";
+ case REQ_HOST_GET_PROPERTIES: return "REQ_HOST_GET_PROPERTIES";
+ case REQ_HOST_GET_SPEED: return "REQ_HOST_GET_SPEED";
+ case REQ_HOST_GET_AVAILABLE_SPEED: return "REQ_HOST_GET_AVAILABLE_SPEED";
+ case REQ_HOST_GET_STATE: return "REQ_HOST_GET_STATE";
+ case REQ_HOST_GET_DATA: return "REQ_HOST_GET_DATA";
+ case REQ_HOST_SET_DATA: return "REQ_HOST_SET_DATA";
+ case REQ_HOST_EXECUTE: return "REQ_HOST_EXECUTE";
+ case REQ_HOST_PARALLEL_EXECUTE: return "REQ_HOST_PARALLEL_EXECUTE";
+ case REQ_HOST_EXECUTION_DESTROY: return "REQ_HOST_EXECUTION_DESTROY";
+ case REQ_HOST_EXECUTION_CANCEL: return "REQ_HOST_EXECUTION_CANCEL";
+ case REQ_HOST_EXECUTION_GET_REMAINS: return "REQ_HOST_EXECUTION_GET_REMAINS";
+ case REQ_HOST_EXECUTION_GET_STATE: return "REQ_HOST_EXECUTION_GET_STATE";
+ case REQ_HOST_EXECUTION_SET_PRIORITY: return "REQ_HOST_EXECUTION_SET_PRIORITY";
+ case REQ_HOST_EXECUTION_WAIT: return "REQ_HOST_EXECUTION_WAIT";
+ case REQ_PROCESS_CREATE: return "REQ_PROCESS_CREATE";
+ case REQ_PROCESS_KILL: return "REQ_PROCESS_KILL";
+ case REQ_PROCESS_CHANGE_HOST: return "REQ_PROCESS_CHANGE_HOST";
+ case REQ_PROCESS_SUSPEND: return "REQ_PROCESS_SUSPEND";
+ case REQ_PROCESS_RESUME: return "REQ_PROCESS_RESUME";
+ case REQ_PROCESS_COUNT: return "REQ_PROCESS_COUNT";
+ case REQ_PROCESS_GET_DATA: return "REQ_PROCESS_GET_DATA";
+ case REQ_PROCESS_SET_DATA: return "REQ_PROCESS_SET_DATA";
+ case REQ_PROCESS_GET_HOST: return "REQ_PROCESS_GET_HOST";
+ case REQ_PROCESS_GET_NAME: return "REQ_PROCESS_GET_NAME";
+ case REQ_PROCESS_IS_SUSPENDED: return "REQ_PROCESS_IS_SUSPENDED";
+ case REQ_PROCESS_GET_PROPERTIES: return "REQ_PROCESS_GET_PROPERTIES";
+ case REQ_PROCESS_SLEEP: return "REQ_PROCESS_SLEEP";
+ case REQ_RDV_CREATE: return "REQ_RDV_CREATE";
+ case REQ_RDV_DESTROY: return "REQ_RDV_DESTROY";
+ case REQ_RDV_GEY_BY_NAME: return "REQ_RDV_GEY_BY_NAME";
+ case REQ_RDV_COMM_COUNT_BY_HOST: return "REQ_RDV_COMM_COUNT_BY_HOST";
+ case REQ_RDV_GET_HEAD: return "REQ_RDV_GET_HEAD";
+ case REQ_COMM_ISEND: return "REQ_COMM_ISEND";
+ case REQ_COMM_IRECV: return "REQ_COMM_IRECV";
+ case REQ_COMM_DESTROY: return "REQ_COMM_DESTROY";
+ case REQ_COMM_CANCEL: return "REQ_COMM_CANCEL";
+ case REQ_COMM_WAITANY: return "REQ_COMM_WAITANY";
+ case REQ_COMM_TESTANY: return "REQ_COMM_TESTANY";
+ case REQ_COMM_WAIT: return "REQ_COMM_WAIT";
#ifdef HAVE_TRACING
- case REQ_SET_CATEGORY:
- return NULL; /* void */
+ case REQ_SET_CATEGORY: return "REQ_SET_CATEGORY";
#endif
- case REQ_COMM_TEST:
- return &req->comm_test.result; /* int */
- case REQ_COMM_GET_REMAINS:
- return &req->comm_get_remains.result; /* double */
- case REQ_COMM_GET_STATE:
- return &req->comm_get_state.result; /* e_smx_state_t */
- case REQ_COMM_GET_SRC_DATA:
- return req->comm_get_src_data.result;
- case REQ_COMM_GET_DST_DATA:
- return req->comm_get_dst_data.result;
- case REQ_COMM_GET_SRC_BUFF:
- return req->comm_get_src_buff.result;
- case REQ_COMM_GET_DST_BUFF:
- return req->comm_get_dst_buff.result;
- case REQ_COMM_GET_SRC_BUFF_SIZE:
- return &req->comm_get_src_buff_size.result; /* size_t */
- case REQ_COMM_GET_DST_BUFF_SIZE:
- return &req->comm_get_dst_buff_size.result; /* size_t */
- case REQ_COMM_GET_SRC_PROC:
- return req->comm_get_src_proc.result;
- case REQ_COMM_GET_DST_PROC:
- return req->comm_get_dst_proc.result;
+ case REQ_COMM_TEST: return "REQ_COMM_TEST";
+ case REQ_COMM_GET_REMAINS: return "REQ_COMM_GET_REMAINS";
+ case REQ_COMM_GET_STATE: return "REQ_COMM_GET_STATE";
+ case REQ_COMM_GET_SRC_DATA: return "REQ_COMM_GET_SRC_DATA";
+ case REQ_COMM_GET_DST_DATA: return "REQ_COMM_GET_DST_DATA";
+ case REQ_COMM_GET_SRC_BUFF: return "REQ_COMM_GET_SRC_BUFF";
+ case REQ_COMM_GET_DST_BUFF: return "REQ_COMM_GET_DST_BUFF";
+ case REQ_COMM_GET_SRC_BUFF_SIZE: return "REQ_COMM_GET_SRC_BUFF_SIZE";
+ case REQ_COMM_GET_DST_BUFF_SIZE: return "REQ_COMM_GET_DST_BUFF_SIZE";
+ case REQ_COMM_GET_SRC_PROC: return "REQ_COMM_GET_SRC_PROC";
+ case REQ_COMM_GET_DST_PROC: return "REQ_COMM_GET_DST_PROC";
#ifdef HAVE_LATENCY_BOUND_TRACKING
- case REQ_COMM_IS_LATENCY_BOUNDED:
- return &req->comm_is_latency_bounded.result; /* int */
+ case REQ_COMM_IS_LATENCY_BOUNDED: return "REQ_COMM_IS_LATENCY_BOUNDED";
#endif
- case REQ_MUTEX_INIT:
- return req->mutex_init.result;
- case REQ_MUTEX_DESTROY:
- case REQ_MUTEX_LOCK:
- case REQ_MUTEX_UNLOCK:
- return NULL; /* void */
-
- case REQ_MUTEX_TRYLOCK:
- return &req->mutex_trylock.result; /* int */
-
- case REQ_COND_INIT:
- return req->cond_init.result;
- case REQ_COND_DESTROY:
- case REQ_COND_SIGNAL:
- case REQ_COND_WAIT:
- case REQ_COND_WAIT_TIMEOUT:
- case REQ_COND_BROADCAST:
- return NULL; /* void */
-
- case REQ_SEM_INIT:
- return req->sem_init.result;
- case REQ_SEM_DESTROY:
- case REQ_SEM_RELEASE:
- case REQ_SEM_ACQUIRE:
- case REQ_SEM_ACQUIRE_TIMEOUT:
- return NULL; /* void */
-
- case REQ_SEM_WOULD_BLOCK:
- return &req->sem_would_block.result; /* int */
- case REQ_SEM_GET_CAPACITY:
- return &req->sem_get_capacity.result; /* int */
+ case REQ_MUTEX_INIT: return "REQ_MUTEX_INIT";
+ case REQ_MUTEX_DESTROY: return "REQ_MUTEX_DESTROY";
+ case REQ_MUTEX_LOCK: return "REQ_MUTEX_LOCK";
+ case REQ_MUTEX_UNLOCK: return "REQ_MUTEX_UNLOCK";
+ case REQ_MUTEX_TRYLOCK: return "REQ_MUTEX_TRYLOCK";
+
+ case REQ_COND_INIT: return "REQ_COND_INIT";
+ case REQ_COND_DESTROY: return "REQ_COND_DESTROY";
+ case REQ_COND_SIGNAL: return "REQ_COND_SIGNAL";
+ case REQ_COND_WAIT: return "REQ_COND_WAIT";
+ case REQ_COND_WAIT_TIMEOUT: return "REQ_COND_WAIT_TIMEOUT";
+ case REQ_COND_BROADCAST: return "REQ_COND_BROADCAST";
+
+ case REQ_SEM_INIT: return "REQ_SEM_INIT";
+ case REQ_SEM_DESTROY: return "REQ_SEM_DESTROY";
+ case REQ_SEM_RELEASE: return "REQ_SEM_RELEASE";
+ case REQ_SEM_ACQUIRE: return "REQ_SEM_ACQUIRE";
+ case REQ_SEM_ACQUIRE_TIMEOUT: return "REQ_SEM_ACQUIRE_TIMEOUT";
+ case REQ_SEM_WOULD_BLOCK: return "REQ_SEM_WOULD_BLOCK";
+ case REQ_SEM_GET_CAPACITY: return "REQ_SEM_GET_CAPACITY";
}
THROW_IMPOSSIBLE;
}
-/** @brief returns the id of the lastly done syscall
- * Mainly (only?) useful for statemachine contextes
- */
-int SIMIX_request_last_id() {
- return SIMIX_req_mine()->call;
-}
