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

diff --git a/src/simix/smurf_private.h b/src/simix/smurf_private.h
index 2d6c1be..f4d6a2b 100644 (file)
--- 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 (file)
index 0000000..84d9cca
--- /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 0f34218..7ed0ac1 100644 (file)
--- 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 975e36e..55f7497 100644 (file)
--- 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];
 }