From faa8aeec1cac19b146adffeabe3fb4db846311b3 Mon Sep 17 00:00:00 2001 From: thiery Date: Mon, 24 Jan 2011 12:02:47 +0000 Subject: [PATCH] SIMIX requests: generate strings from enumeration values automatically git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/simgrid/simgrid/trunk@9478 48e7efb5-ca39-0410-a469-dd3cf9ba447f --- src/simix/smurf_private.h | 78 +------------------------------- src/simix/smx_req_enum.h | 94 +++++++++++++++++++++++++++++++++++++++ src/simix/smx_smurf.c | 2 +- src/simix/smx_user.c | 94 ++++----------------------------------- 4 files changed, 104 insertions(+), 164 deletions(-) create mode 100644 src/simix/smx_req_enum.h diff --git a/src/simix/smurf_private.h b/src/simix/smurf_private.h index 2d6c1bed56..f4d6a2bf70 100644 --- a/src/simix/smurf_private.h +++ b/src/simix/smurf_private.h @@ -9,83 +9,7 @@ /********************************* Requests ***********************************/ typedef enum { - REQ_NO_REQ, /* Used when there is no ongoing request here */ - REQ_HOST_GET_BY_NAME, - REQ_HOST_GET_NAME, - REQ_HOST_GET_PROPERTIES, - REQ_HOST_GET_SPEED, - REQ_HOST_GET_AVAILABLE_SPEED, - REQ_HOST_GET_STATE, - REQ_HOST_GET_DATA, - REQ_HOST_SET_DATA, - REQ_HOST_EXECUTE, - REQ_HOST_PARALLEL_EXECUTE, - REQ_HOST_EXECUTION_DESTROY, - REQ_HOST_EXECUTION_CANCEL, - REQ_HOST_EXECUTION_GET_REMAINS, - REQ_HOST_EXECUTION_GET_STATE, - REQ_HOST_EXECUTION_SET_PRIORITY, - REQ_HOST_EXECUTION_WAIT, - REQ_PROCESS_CREATE, - REQ_PROCESS_KILL, - REQ_PROCESS_CHANGE_HOST, - REQ_PROCESS_SUSPEND, - REQ_PROCESS_RESUME, - REQ_PROCESS_COUNT, - REQ_PROCESS_GET_DATA, - REQ_PROCESS_SET_DATA, - REQ_PROCESS_GET_HOST, - REQ_PROCESS_GET_NAME, - REQ_PROCESS_IS_SUSPENDED, - REQ_PROCESS_GET_PROPERTIES, - REQ_PROCESS_SLEEP, - REQ_RDV_CREATE, - REQ_RDV_DESTROY, - REQ_RDV_GEY_BY_NAME, - REQ_RDV_COMM_COUNT_BY_HOST, - REQ_RDV_GET_HEAD, - REQ_COMM_ISEND, - REQ_COMM_IRECV, - REQ_COMM_DESTROY, - REQ_COMM_CANCEL, - REQ_COMM_WAITANY, - REQ_COMM_WAIT, - REQ_COMM_TEST, - REQ_COMM_TESTANY, - REQ_COMM_GET_REMAINS, - REQ_COMM_GET_STATE, - REQ_COMM_GET_SRC_DATA, - REQ_COMM_GET_DST_DATA, - REQ_COMM_GET_SRC_BUFF, - REQ_COMM_GET_DST_BUFF, - REQ_COMM_GET_SRC_BUFF_SIZE, - REQ_COMM_GET_DST_BUFF_SIZE, - REQ_COMM_GET_SRC_PROC, - REQ_COMM_GET_DST_PROC, -#ifdef HAVE_LATENCY_BOUND_TRACKING - REQ_COMM_IS_LATENCY_BOUNDED, -#endif -#ifdef HAVE_TRACING - REQ_SET_CATEGORY, -#endif - REQ_MUTEX_INIT, - REQ_MUTEX_DESTROY, - REQ_MUTEX_LOCK, - REQ_MUTEX_TRYLOCK, - REQ_MUTEX_UNLOCK, - REQ_COND_INIT, - REQ_COND_DESTROY, - REQ_COND_SIGNAL, - REQ_COND_WAIT, - REQ_COND_WAIT_TIMEOUT, - REQ_COND_BROADCAST, - REQ_SEM_INIT, - REQ_SEM_DESTROY, - REQ_SEM_RELEASE, - REQ_SEM_WOULD_BLOCK, - REQ_SEM_ACQUIRE, - REQ_SEM_ACQUIRE_TIMEOUT, - REQ_SEM_GET_CAPACITY +#include "smx_req_enum.h" } e_smx_req_t; typedef struct s_smx_req { diff --git a/src/simix/smx_req_enum.h b/src/simix/smx_req_enum.h new file mode 100644 index 0000000000..84d9ccae23 --- /dev/null +++ b/src/simix/smx_req_enum.h @@ -0,0 +1,94 @@ +/* Copyright (c) 2007, 2008, 2009, 2010. The SimGrid Team. + * All rights reserved. */ + +/* This program is free software; you can redistribute it and/or modify it + * under the terms of the license (GNU LGPL) which comes with this package. */ + + +/* This header contains the list of all SIMIX request types. + * It may be included mutiple times, with different definitions of the + * SIMIX_REQ_ENUM_ELEMENT macro to build different things. */ +#ifndef SIMIX_REQ_ENUM_ELEMENT +#define SIMIX_REQ_ENUM_ELEMENT(x) x +#endif + +SIMIX_REQ_ENUM_ELEMENT(REQ_NO_REQ), /* Used when there is no ongoing request here */ +SIMIX_REQ_ENUM_ELEMENT(REQ_HOST_GET_BY_NAME), +SIMIX_REQ_ENUM_ELEMENT(REQ_HOST_GET_NAME), +SIMIX_REQ_ENUM_ELEMENT(REQ_HOST_GET_PROPERTIES), +SIMIX_REQ_ENUM_ELEMENT(REQ_HOST_GET_SPEED), +SIMIX_REQ_ENUM_ELEMENT(REQ_HOST_GET_AVAILABLE_SPEED), +SIMIX_REQ_ENUM_ELEMENT(REQ_HOST_GET_STATE), +SIMIX_REQ_ENUM_ELEMENT(REQ_HOST_GET_DATA), +SIMIX_REQ_ENUM_ELEMENT(REQ_HOST_SET_DATA), +SIMIX_REQ_ENUM_ELEMENT(REQ_HOST_EXECUTE), +SIMIX_REQ_ENUM_ELEMENT(REQ_HOST_PARALLEL_EXECUTE), +SIMIX_REQ_ENUM_ELEMENT(REQ_HOST_EXECUTION_DESTROY), +SIMIX_REQ_ENUM_ELEMENT(REQ_HOST_EXECUTION_CANCEL), +SIMIX_REQ_ENUM_ELEMENT(REQ_HOST_EXECUTION_GET_REMAINS), +SIMIX_REQ_ENUM_ELEMENT(REQ_HOST_EXECUTION_GET_STATE), +SIMIX_REQ_ENUM_ELEMENT(REQ_HOST_EXECUTION_SET_PRIORITY), +SIMIX_REQ_ENUM_ELEMENT(REQ_HOST_EXECUTION_WAIT), +SIMIX_REQ_ENUM_ELEMENT(REQ_PROCESS_CREATE), +SIMIX_REQ_ENUM_ELEMENT(REQ_PROCESS_KILL), +SIMIX_REQ_ENUM_ELEMENT(REQ_PROCESS_CHANGE_HOST), +SIMIX_REQ_ENUM_ELEMENT(REQ_PROCESS_SUSPEND), +SIMIX_REQ_ENUM_ELEMENT(REQ_PROCESS_RESUME), +SIMIX_REQ_ENUM_ELEMENT(REQ_PROCESS_COUNT), +SIMIX_REQ_ENUM_ELEMENT(REQ_PROCESS_GET_DATA), +SIMIX_REQ_ENUM_ELEMENT(REQ_PROCESS_SET_DATA), +SIMIX_REQ_ENUM_ELEMENT(REQ_PROCESS_GET_HOST), +SIMIX_REQ_ENUM_ELEMENT(REQ_PROCESS_GET_NAME), +SIMIX_REQ_ENUM_ELEMENT(REQ_PROCESS_IS_SUSPENDED), +SIMIX_REQ_ENUM_ELEMENT(REQ_PROCESS_GET_PROPERTIES), +SIMIX_REQ_ENUM_ELEMENT(REQ_PROCESS_SLEEP), +SIMIX_REQ_ENUM_ELEMENT(REQ_RDV_CREATE), +SIMIX_REQ_ENUM_ELEMENT(REQ_RDV_DESTROY), +SIMIX_REQ_ENUM_ELEMENT(REQ_RDV_GEY_BY_NAME), +SIMIX_REQ_ENUM_ELEMENT(REQ_RDV_COMM_COUNT_BY_HOST), +SIMIX_REQ_ENUM_ELEMENT(REQ_RDV_GET_HEAD), +SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_ISEND), +SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_IRECV), +SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_DESTROY), +SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_CANCEL), +SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_WAITANY), +SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_WAIT), +SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_TEST), +SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_TESTANY), +SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_GET_REMAINS), +SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_GET_STATE), +SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_GET_SRC_DATA), +SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_GET_DST_DATA), +SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_GET_SRC_BUFF), +SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_GET_DST_BUFF), +SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_GET_SRC_BUFF_SIZE), +SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_GET_DST_BUFF_SIZE), +SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_GET_SRC_PROC), +SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_GET_DST_PROC), +#ifdef HAVE_LATENCY_BOUND_TRACKING +SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_IS_LATENCY_BOUNDED), +#endif +#ifdef HAVE_TRACING +SIMIX_REQ_ENUM_ELEMENT(REQ_SET_CATEGORY), +#endif +SIMIX_REQ_ENUM_ELEMENT(REQ_MUTEX_INIT), +SIMIX_REQ_ENUM_ELEMENT(REQ_MUTEX_DESTROY), +SIMIX_REQ_ENUM_ELEMENT(REQ_MUTEX_LOCK), +SIMIX_REQ_ENUM_ELEMENT(REQ_MUTEX_TRYLOCK), +SIMIX_REQ_ENUM_ELEMENT(REQ_MUTEX_UNLOCK), +SIMIX_REQ_ENUM_ELEMENT(REQ_COND_INIT), +SIMIX_REQ_ENUM_ELEMENT(REQ_COND_DESTROY), +SIMIX_REQ_ENUM_ELEMENT(REQ_COND_SIGNAL), +SIMIX_REQ_ENUM_ELEMENT(REQ_COND_WAIT), +SIMIX_REQ_ENUM_ELEMENT(REQ_COND_WAIT_TIMEOUT), +SIMIX_REQ_ENUM_ELEMENT(REQ_COND_BROADCAST), +SIMIX_REQ_ENUM_ELEMENT(REQ_SEM_INIT), +SIMIX_REQ_ENUM_ELEMENT(REQ_SEM_DESTROY), +SIMIX_REQ_ENUM_ELEMENT(REQ_SEM_RELEASE), +SIMIX_REQ_ENUM_ELEMENT(REQ_SEM_WOULD_BLOCK), +SIMIX_REQ_ENUM_ELEMENT(REQ_SEM_ACQUIRE), +SIMIX_REQ_ENUM_ELEMENT(REQ_SEM_ACQUIRE_TIMEOUT), +SIMIX_REQ_ENUM_ELEMENT(REQ_SEM_GET_CAPACITY) + +#undef SIMIX_REQ_ENUM_ELEMENT + diff --git a/src/simix/smx_smurf.c b/src/simix/smx_smurf.c index 0f34218233..7ed0ac1791 100644 --- a/src/simix/smx_smurf.c +++ b/src/simix/smx_smurf.c @@ -215,7 +215,7 @@ void SIMIX_request_pre(smx_req_t req, int value) break; case REQ_RDV_GET_HEAD: - req->rdv_get_head.result = SIMIX_rdv_get_head(req->rdv_get_head.rdv); + req->rdv_get_head.result = SIMIX_rdv_get_head(req->rdv_get_head.rdv); SIMIX_request_answer(req); break; diff --git a/src/simix/smx_user.c b/src/simix/smx_user.c index 975e36e6ce..55f74976d9 100644 --- a/src/simix/smx_user.c +++ b/src/simix/smx_user.c @@ -1,6 +1,13 @@ #include "private.h" XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix); + +static const char* request_names[] = { +#define SIMIX_REQ_ENUM_ELEMENT(x) #x /* generate strings from the enumeration values */ +#include "smx_req_enum.h" +#undef SIMIX_REQ_ENUM_ELEMENT +}; + /** * \brief Returns a host given its name. * @@ -1044,90 +1051,5 @@ int SIMIX_req_sem_get_capacity(smx_sem_t sem) /** @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; + return request_names[kind]; } -- 2.20.1