From 5f884c941c776c6be4e98fb19c75b056397f1c17 Mon Sep 17 00:00:00 2001 From: mquinson Date: Mon, 13 Dec 2010 12:40:56 +0000 Subject: [PATCH 1/1] function to see the name of syscall types in debugging messages (and use it on SIMIX_request_push) git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/simgrid/simgrid/trunk@9148 48e7efb5-ca39-0410-a469-dd3cf9ba447f --- include/simix/simix.h | 2 + src/simix/smx_smurf.c | 8 ++-- src/simix/smx_user.c | 89 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 96 insertions(+), 3 deletions(-) diff --git a/include/simix/simix.h b/include/simix/simix.h index f2f2994276..3ef1f75a58 100644 --- a/include/simix/simix.h +++ b/include/simix/simix.h @@ -230,6 +230,8 @@ XBT_PUBLIC(void) SIMIX_req_sem_acquire_timeout(smx_sem_t sem, XBT_PUBLIC(unsigned int) SIMIX_req_sem_acquire_any(xbt_dynar_t sems); XBT_PUBLIC(int) SIMIX_req_sem_get_capacity(smx_sem_t sem); +const char *SIMIX_request_name(int kind); + /* functions to let the state machine context factory mess with simix flow */ XBT_PUBLIC(void*) SIMIX_request_get_result(int id); XBT_PUBLIC(int) SIMIX_request_last_id(void); diff --git a/src/simix/smx_smurf.c b/src/simix/smx_smurf.c index 60e64b1760..475b3fbdf9 100644 --- a/src/simix/smx_smurf.c +++ b/src/simix/smx_smurf.c @@ -37,12 +37,14 @@ void SIMIX_request_push() if (_surf_parallel_contexts) xbt_os_mutex_acquire(sync_req_positions); xbt_heap_push(req_todo,&issuer->request,issuer->pid); - DEBUG3("Pushed request %d of %s; now %d requests waiting", - issuer->request.call,issuer->name,xbt_heap_size(req_todo)); + DEBUG4("Pushed request %s (%d) of %s; now %d requests waiting", + SIMIX_request_name(issuer->request.call), issuer->request.call, + issuer->name,xbt_heap_size(req_todo)); if (_surf_parallel_contexts) xbt_os_mutex_release(sync_req_positions); - DEBUG2("Yield process '%s' on request of type %d", issuer->name, issuer->request.call); + DEBUG3("Yield process '%s' on request of type %s (%d)", issuer->name, + SIMIX_request_name(issuer->request.call), issuer->request.call); SIMIX_process_yield(); } else { SIMIX_request_pre(&issuer->request); diff --git a/src/simix/smx_user.c b/src/simix/smx_user.c index 49b044dd63..4c04a1527b 100644 --- a/src/simix/smx_user.c +++ b/src/simix/smx_user.c @@ -1214,3 +1214,92 @@ void *SIMIX_request_get_result(int kind) { int SIMIX_request_last_id() { return SIMIX_req_mine()->call; } +/** @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: 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 "REQ_SET_CATEGORY"; +#endif + + 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"; + #endif + + 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; +} -- 2.20.1