#ifndef _SIMIX_SMURF_PRIVATE_H
#define _SIMIX_SMURF_PRIVATE_H
-/********************************* Requests ***********************************/
-
-/* we want to build the e_smx_t enumeration and the table of the corresponding
- * strings automatically, using macros */
-
-#define SIMIX_REQ_LIST1 \
-SIMIX_REQ_ENUM_ELEMENT(REQ_NO_REQ),\
-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_KILLALL),\
-SIMIX_REQ_ENUM_ELEMENT(REQ_PROCESS_CLEANUP),\
-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_SEND),\
-SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_ISEND),\
-SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_RECV),\
-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_PROC),\
-SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_GET_DST_PROC),\
-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),\
-SIMIX_REQ_ENUM_ELEMENT(REQ_FILE_READ)
-
-/* REQ_COMM_IS_LATENCY_BOUNDED and REQ_SET_CATEGORY make things complicated
+/********************************* Simcalls *********************************/
+
+/* we want to build the e_smx_simcall_t enumeration, the table of the
+ * corresponding simcalls string names, and the simcall handlers table
+ * automatically, using macros.
+ * To add a new simcall follow the following syntax:
+ *
+ * SIMCALL_ENUM_ELEMENT(<simcall_enumeration_id>, <simcall_handler_function>)
+ *
+ * */
+
+#define SIMCALL_LIST1 \
+SIMCALL_ENUM_ELEMENT(SIMCALL_NONE),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_GET_BY_NAME),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_GET_NAME),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_GET_PROPERTIES),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_GET_SPEED),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_GET_AVAILABLE_SPEED),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_GET_STATE),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_GET_DATA),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_SET_DATA),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_EXECUTE),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_PARALLEL_EXECUTE),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_EXECUTION_DESTROY),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_EXECUTION_CANCEL),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_EXECUTION_GET_REMAINS),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_EXECUTION_GET_STATE),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_EXECUTION_SET_PRIORITY),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_EXECUTION_WAIT),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_CREATE),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_KILL),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_KILLALL),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_CLEANUP),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_CHANGE_HOST),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_SUSPEND),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_RESUME),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_COUNT),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_GET_DATA),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_SET_DATA),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_GET_HOST),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_GET_NAME),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_IS_SUSPENDED),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_GET_PROPERTIES),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_SLEEP),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_ON_EXIT),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_AUTO_RESTART_SET),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_RESTART),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_RDV_CREATE),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_RDV_DESTROY),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_RDV_GEY_BY_NAME),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_RDV_COMM_COUNT_BY_HOST),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_RDV_GET_HEAD),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_RDV_SET_RECV),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_RDV_GET_RECV),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_SEND),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_ISEND),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_RECV),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_IRECV),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_DESTROY),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_CANCEL),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_WAITANY),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_WAIT),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_TEST),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_TESTANY),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_IPROBE),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_GET_REMAINS),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_GET_STATE),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_GET_SRC_DATA),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_GET_DST_DATA),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_GET_SRC_PROC),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_GET_DST_PROC),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_MUTEX_INIT),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_MUTEX_DESTROY),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_MUTEX_LOCK),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_MUTEX_TRYLOCK),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_MUTEX_UNLOCK),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_COND_INIT),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_COND_DESTROY),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_COND_SIGNAL),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_COND_WAIT),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_COND_WAIT_TIMEOUT),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_COND_BROADCAST),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_SEM_INIT),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_SEM_DESTROY),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_SEM_RELEASE),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_SEM_WOULD_BLOCK),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_SEM_ACQUIRE),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_SEM_ACQUIRE_TIMEOUT),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_SEM_GET_CAPACITY),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_FILE_READ),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_FILE_WRITE),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_FILE_OPEN),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_FILE_CLOSE),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_FILE_STAT), \
+SIMCALL_ENUM_ELEMENT(SIMCALL_FILE_UNLINK),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_FILE_LS),\
+SIMCALL_ENUM_ELEMENT(SIMCALL_ASR_GET_PROPERTIES), \
+/* ****************************************************************************************** */ \
+/* TUTORIAL: New API */ \
+/* ****************************************************************************************** */ \
+SIMCALL_ENUM_ELEMENT(SIMCALL_NEW_API_INIT)
+
+/* SIMCALL_COMM_IS_LATENCY_BOUNDED and SIMCALL_SET_CATEGORY make things complicated
* because they are not always present */
#ifdef HAVE_LATENCY_BOUND_TRACKING
-#define SIMIX_REQ_LIST2 \
-,SIMIX_REQ_ENUM_ELEMENT(REQ_COMM_IS_LATENCY_BOUNDED)
+#define SIMCALL_LIST2 \
+,SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_IS_LATENCY_BOUNDED, SIMIX_comm_is_latency_bounded)
#else
-#define SIMIX_REQ_LIST2
+#define SIMCALL_LIST2
#endif
#ifdef HAVE_TRACING
-#define SIMIX_REQ_LIST3 \
-,SIMIX_REQ_ENUM_ELEMENT(REQ_SET_CATEGORY)
+#define SIMCALL_LIST3 \
+,SIMCALL_ENUM_ELEMENT(SIMCALL_SET_CATEGORY, SIMIX_set_category)
#else
-#define SIMIX_REQ_LIST3
+#define SIMCALL_LIST3
#endif
-/* SIMIX_REQ_LIST is the final macro to use */
-#define SIMIX_REQ_LIST SIMIX_REQ_LIST1 SIMIX_REQ_LIST2 SIMIX_REQ_LIST3
+#ifdef HAVE_MC
+#define SIMCALL_LIST4 \
+ ,SIMCALL_ENUM_ELEMENT(SIMCALL_MC_SNAPSHOT) \
+ ,SIMCALL_ENUM_ELEMENT(SIMCALL_MC_COMPARE_SNAPSHOTS)
+#else
+#define SIMCALL_LIST4
+#endif
+
+/* SIMCALL_LIST is the final macro to use */
+#define SIMCALL_LIST SIMCALL_LIST1 SIMCALL_LIST2 SIMCALL_LIST3 SIMCALL_LIST4
/* you can redefine the following macro differently to generate something else
* with the list of enumeration values (e.g. a table of strings or a table of function pointers) */
-#define SIMIX_REQ_ENUM_ELEMENT(x) x
+#define SIMCALL_ENUM_ELEMENT(x, y) x
/**
- * \brief All possible SIMIX requests.
+ * \brief All possible simcalls.
*/
typedef enum {
-SIMIX_REQ_LIST
-} e_smx_req_t;
+SIMCALL_LIST
+} e_smx_simcall_t;
/**
- * \brief Represents a SIMIX request.
+ * \brief Represents a simcall to the kernel.
*/
-typedef struct s_smx_req {
- e_smx_req_t call;
+typedef struct s_smx_simcall {
+ e_smx_simcall_t call;
smx_process_t issuer;
+ union u_smx_scalar *args;
+ //FIXME: union u_smx_scalar retval;
union {
xbt_main_func_t code;
void *data;
const char *hostname;
+ double kill_time;
int argc;
char **argv;
xbt_dict_t properties;
+ int auto_restart;
} process_create;
struct {
e_smx_state_t result;
} process_sleep;
+ struct {
+ smx_process_t process;
+ int_f_pvoid_t fun;
+ void *data;
+ } process_on_exit;
+
+ struct {
+ smx_process_t process;
+ int auto_restart;
+ } process_auto_restart;
+
+ struct {
+ smx_process_t process;
+ smx_process_t result;
+ } process_restart;
+
struct {
const char *name;
smx_rdv_t result;
smx_action_t result;
} rdv_get_head;
+ struct {
+ smx_rdv_t rdv;
+ smx_process_t receiver;
+ } rdv_set_rcv_proc;
+
+ struct {
+ smx_rdv_t rdv;
+ smx_process_t result;
+ } rdv_get_rcv_proc;
+
struct {
smx_rdv_t rdv;
double task_size;
double rate;
void *src_buff;
size_t src_buff_size;
- int (*match_fun)(void *, void *);
+ int (*match_fun)(void *, void *, smx_action_t);
void *data;
double timeout;
} comm_send;
double rate;
void *src_buff;
size_t src_buff_size;
- int (*match_fun)(void *, void *);
+ int (*match_fun)(void *, void *, smx_action_t);
void (*clean_fun)(void *);
void *data;
int detached;
smx_rdv_t rdv;
void *dst_buff;
size_t *dst_buff_size;
- int (*match_fun)(void *, void *);
+ int (*match_fun)(void *, void *, smx_action_t);
void *data;
double timeout;
} comm_recv;
smx_rdv_t rdv;
void *dst_buff;
size_t *dst_buff_size;
- int (*match_fun)(void *, void *);
- void *data;
+ int (*match_fun)(void *, void *, smx_action_t);
+ void *data;
smx_action_t result;
} comm_irecv;
+ struct {
+ smx_rdv_t rdv;
+ int src;
+ int tag;
+ int (*match_fun)(void *, void *, smx_action_t);
+ void *data;
+ smx_action_t result;
+ } comm_iprobe;
+
struct {
smx_action_t comm;
} comm_destroy;
} sem_get_capacity;
struct {
- char* name;;
+ void *ptr;
+ size_t size;
+ size_t nmemb;
+ smx_file_t stream;
+ double result;
} file_read;
+
+ struct {
+ const void *ptr;
+ size_t size;
+ size_t nmemb;
+ smx_file_t stream;
+ size_t result;
+ } file_write;
+
+ struct {
+ const char* mount;
+ const char* path;
+ const char* mode;
+ smx_file_t result;
+ } file_open;
+
+ struct {
+ smx_file_t fp;
+ int result;
+ } file_close;
+
+ struct {
+ smx_file_t fd;
+ s_file_stat_t buf;
+ int result;
+ } file_stat;
+
+ struct {
+ smx_file_t fd;
+ int result;
+ } file_unlink;
+
+ struct {
+ const char *mount;
+ const char *path;
+ xbt_dict_t result;
+ } file_ls;
+
+ struct {
+ const char* name;
+ xbt_dict_t result;
+ } asr_get_properties;
+
+ struct{
+ void *s;
+ } mc_snapshot;
+
+ struct{
+ void *snapshot1;
+ void *snapshot2;
+ int result;
+ } mc_compare_snapshots;
+
+ /* ****************************************************************************************** */
+ /* TUTORIAL: New API */
+ /* ****************************************************************************************** */
+ struct {
+ const char* param1;
+ double param2;
+ int result;
+ } new_api;
+
};
-} s_smx_req_t, *smx_req_t;
+} s_smx_simcall_t, *smx_simcall_t;
/******************************** General *************************************/
-void SIMIX_request_push(smx_process_t self);
-void SIMIX_request_answer(smx_req_t);
-void SIMIX_request_pre(smx_req_t, int);
-void SIMIX_request_post(smx_action_t);
-XBT_INLINE smx_req_t SIMIX_req_mine(void);
+void SIMIX_simcall_push(smx_process_t self);
+void SIMIX_simcall_answer(smx_simcall_t);
+void SIMIX_simcall_pre(smx_simcall_t, int);
+void SIMIX_simcall_post(smx_action_t);
+smx_simcall_t SIMIX_simcall_mine(void);
+const char *SIMIX_simcall_name(e_smx_simcall_t kind);
+
+/*************************** New simcall interface ****************************/
+
+/* Pack all possible scalar types in an union */
+union u_smx_scalar {
+ char c;
+ const char* cc;
+ short s;
+ int i;
+ long l;
+ unsigned char uc;
+ unsigned short us;
+ unsigned int ui;
+ unsigned long ul;
+ float f;
+ double d;
+ void* p;
+};
+
+#define SIMIX_pack_args(...) (u_smx_scalar_t[]){MAP(INIT_FIELD, __VA_ARGS__)}
+
+
+/*
+ * Define scalar type wrappers to ease the use of simcalls.
+ * These are used to wrap the arguments in SIMIX_simcall macro.
+ */
+#define CHAR(x) (c,x)
+#define STRING(x) (cc,x)
+#define SHORT(x) (s,x)
+#define INT(x) (i,x)
+#define LONG(x) (l,x)
+#define UCHAR(x) (uc,x)
+#define USHORT(x) (us,x)
+#define UINT(x) (ui,x)
+#define ULONG(x) (ul,x)
+#define FLOAT(x) (f,x)
+#define DOUBLE(x) (d,x)
+#define PTR(x) (p,x)
+
+/*
+ * Some macro machinery to get a MAP over the arguments of a variadic macro.
+ * It uses a FOLD to apply a macro to every argument, and because there is
+ * no recursion in the C preprocessor we must create a new macro for every
+ * depth of FOLD's recursion.
+ */
+
+/* FOLD macro */
+#define FE_1(WHAT, X) WHAT(X)
+#define FE_2(WHAT, X, ...) WHAT(X), FE_1(WHAT, __VA_ARGS__)
+#define FE_3(WHAT, X, ...) WHAT(X), FE_2(WHAT, __VA_ARGS__)
+#define FE_4(WHAT, X, ...) WHAT(X), FE_3(WHAT, __VA_ARGS__)
+#define FE_5(WHAT, X, ...) WHAT(X), FE_4(WHAT, __VA_ARGS__)
+/* NOTE: add as many FE_n as needed (maximum number of simcall arguments )*/
+
+/* Make a MAP macro usgin FOLD (will apply 'action' to the arguments.
+ * GET_MACRO is a smart hack that counts the number of arguments passed to
+ * the variadic macro, and it is used to invoke the right FOLD depth.
+ */
+#define GET_MACRO(_1,_2,_3,_4,_5,NAME,...) NAME
+#define MAP(action,...) \
+ GET_MACRO(__VA_ARGS__,FE_5,FE_4,FE_3,FE_2,FE_1) (action, __VA_ARGS__)
+
+
+/* Generate code to initialize the field 'x' with value 'y' of an structure or union */
+#define INIT_FIELD_(x,y) {.x = y}
+#define INIT_FIELD(t) INIT_FIELD_ t
+
+/* Project the second element of a tuple */
+#define SECOND_(x, y) y
+#define SECOND(t) SECOND_ t
+
+/*
+ * \brief Simcall invocation macro
+ * It calls a dummy function that uses the format attribute to ensure typesafety (see
+ * gcc format attribute), then it invokes the real simcall function packing the
+ * user provided arguments in an array.
+ * \param id a simcall id (from the simcall enumeration ids)
+ *
+ */
+#define SIMIX_simcall(id, ...) \
+ SIMIX_simcall_typecheck(simcall_types[id], MAP(SECOND, __VA_ARGS__)); \
+ __SIMIX_simcall(id, (u_smx_scalar_t[]){MAP(INIT_FIELD, __VA_ARGS__)})
+
+void __SIMIX_simcall(e_smx_simcall_t simcall_id, u_smx_scalar_t *args);
+
+/*
+ * \biref Dummy variadic function used to typecheck the arguments of a simcall
+ * \param fmt A format string following printf style
+ */
+void SIMIX_simcall_typecheck(const char *fmt, ...) __attribute__ ((format (printf, 1, 2)));
+
+typedef smx_action_t (*simcall_handler_t)(u_smx_scalar_t *);
+
+extern const char *simcall_types[];
+extern simcall_handler_t simcall_table[];
#endif
