X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/15220d2486268d4eac7e25aac434a9139fb2a187..d6fc96fb24bb0006584d44bee70df5f67b37f5fb:/src/simix/smx_smurf_private.h diff --git a/src/simix/smx_smurf_private.h b/src/simix/smx_smurf_private.h index d1116506f7..61b606c635 100644 --- a/src/simix/smx_smurf_private.h +++ b/src/simix/smx_smurf_private.h @@ -9,8 +9,14 @@ /********************************* Simcalls *********************************/ -/* we want to build the e_smx_simcall_t enumeration and the table of the - * corresponding strings automatically, using macros */ +/* 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(, ) + * + * */ #define SIMCALL_LIST1 \ SIMCALL_ENUM_ELEMENT(SIMCALL_NONE),\ @@ -97,31 +103,42 @@ 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) - +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 SIMCALL_LIST2 \ -,SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_IS_LATENCY_BOUNDED) +,SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_IS_LATENCY_BOUNDED, SIMIX_comm_is_latency_bounded) #else #define SIMCALL_LIST2 #endif #ifdef HAVE_TRACING #define SIMCALL_LIST3 \ -,SIMCALL_ENUM_ELEMENT(SIMCALL_SET_CATEGORY) +,SIMCALL_ENUM_ELEMENT(SIMCALL_SET_CATEGORY, SIMIX_set_category) #else #define SIMCALL_LIST3 #endif +#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 +#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 SIMCALL_ENUM_ELEMENT(x) x +#define SIMCALL_ENUM_ELEMENT(x, y) x /** * \brief All possible simcalls. @@ -136,6 +153,8 @@ SIMCALL_LIST 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 { @@ -223,7 +242,9 @@ typedef struct s_smx_simcall { struct { smx_action_t execution; + struct s_smx_simcall *simcall; e_smx_state_t result; + } host_execution_wait; struct { @@ -603,6 +624,25 @@ typedef struct s_smx_simcall { 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_simcall_t, *smx_simcall_t; @@ -615,5 +655,100 @@ 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