← Back to branch summary

~ubuntu-branches/ubuntu/raring/simgrid/raring

« back to all changes in this revision

Viewing changes to src/simix/smx_smurf_private.h

  • Committer: Package Import Robot
  • Author(s): Martin Quinson
  • Date: 2013-01-31 00:24:51 UTC
  • mfrom: (10.1.6 sid)
  • Revision ID: package-import@ubuntu.com-20130131002451-krejhf7w7h24lpsc
Tags: 3.9~rc1-1
* New upstream release: the "Grasgory" release. Major changes:
  - Gras was completely removed from this version.
  - Documentation reorganization to ease browsing it.
  - New default value for the TCP_gamma parameter: 4MiB

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/simix/smx_smurf_private.h
9
9
 
10
10
/********************************* Simcalls *********************************/
11
11
 
12
 
/* we want to build the e_smx_simcall_t enumeration and the table of the
13
 
 * corresponding strings automatically, using macros */
14
 
 
15
 
#define SIMCALL_LIST1 \
16
 
SIMCALL_ENUM_ELEMENT(SIMCALL_NONE),\
17
 
SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_GET_BY_NAME),\
18
 
SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_GET_NAME),\
19
 
SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_GET_PROPERTIES),\
20
 
SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_GET_SPEED),\
21
 
SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_GET_AVAILABLE_SPEED),\
22
 
SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_GET_STATE),\
23
 
SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_GET_DATA),\
24
 
SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_SET_DATA),\
25
 
SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_EXECUTE),\
26
 
SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_PARALLEL_EXECUTE),\
27
 
SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_EXECUTION_DESTROY),\
28
 
SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_EXECUTION_CANCEL),\
29
 
SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_EXECUTION_GET_REMAINS),\
30
 
SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_EXECUTION_GET_STATE),\
31
 
SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_EXECUTION_SET_PRIORITY),\
32
 
SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_EXECUTION_WAIT),\
33
 
SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_CREATE),\
34
 
SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_KILL),\
35
 
SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_KILLALL),\
36
 
SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_CLEANUP),\
37
 
SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_CHANGE_HOST),\
38
 
SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_SUSPEND),\
39
 
SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_RESUME),\
40
 
SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_COUNT),\
41
 
SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_GET_DATA),\
42
 
SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_SET_DATA),\
43
 
SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_GET_HOST),\
44
 
SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_GET_NAME),\
45
 
SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_IS_SUSPENDED),\
46
 
SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_GET_PROPERTIES),\
47
 
SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_SLEEP),\
48
 
SIMCALL_ENUM_ELEMENT(SIMCALL_RDV_CREATE),\
49
 
SIMCALL_ENUM_ELEMENT(SIMCALL_RDV_DESTROY),\
50
 
SIMCALL_ENUM_ELEMENT(SIMCALL_RDV_GEY_BY_NAME),\
51
 
SIMCALL_ENUM_ELEMENT(SIMCALL_RDV_COMM_COUNT_BY_HOST),\
52
 
SIMCALL_ENUM_ELEMENT(SIMCALL_RDV_GET_HEAD),\
53
 
SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_SEND),\
54
 
SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_ISEND),\
55
 
SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_RECV),\
56
 
SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_IRECV),\
57
 
SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_DESTROY),\
58
 
SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_CANCEL),\
59
 
SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_WAITANY),\
60
 
SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_WAIT),\
61
 
SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_TEST),\
62
 
SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_TESTANY),\
63
 
SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_GET_REMAINS),\
64
 
SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_GET_STATE),\
65
 
SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_GET_SRC_DATA),\
66
 
SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_GET_DST_DATA),\
67
 
SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_GET_SRC_PROC),\
68
 
SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_GET_DST_PROC),\
69
 
SIMCALL_ENUM_ELEMENT(SIMCALL_MUTEX_INIT),\
70
 
SIMCALL_ENUM_ELEMENT(SIMCALL_MUTEX_DESTROY),\
71
 
SIMCALL_ENUM_ELEMENT(SIMCALL_MUTEX_LOCK),\
72
 
SIMCALL_ENUM_ELEMENT(SIMCALL_MUTEX_TRYLOCK),\
73
 
SIMCALL_ENUM_ELEMENT(SIMCALL_MUTEX_UNLOCK),\
74
 
SIMCALL_ENUM_ELEMENT(SIMCALL_COND_INIT),\
75
 
SIMCALL_ENUM_ELEMENT(SIMCALL_COND_DESTROY),\
76
 
SIMCALL_ENUM_ELEMENT(SIMCALL_COND_SIGNAL),\
77
 
SIMCALL_ENUM_ELEMENT(SIMCALL_COND_WAIT),\
78
 
SIMCALL_ENUM_ELEMENT(SIMCALL_COND_WAIT_TIMEOUT),\
79
 
SIMCALL_ENUM_ELEMENT(SIMCALL_COND_BROADCAST),\
80
 
SIMCALL_ENUM_ELEMENT(SIMCALL_SEM_INIT),\
81
 
SIMCALL_ENUM_ELEMENT(SIMCALL_SEM_DESTROY),\
82
 
SIMCALL_ENUM_ELEMENT(SIMCALL_SEM_RELEASE),\
83
 
SIMCALL_ENUM_ELEMENT(SIMCALL_SEM_WOULD_BLOCK),\
84
 
SIMCALL_ENUM_ELEMENT(SIMCALL_SEM_ACQUIRE),\
85
 
SIMCALL_ENUM_ELEMENT(SIMCALL_SEM_ACQUIRE_TIMEOUT),\
86
 
SIMCALL_ENUM_ELEMENT(SIMCALL_SEM_GET_CAPACITY),\
87
 
SIMCALL_ENUM_ELEMENT(SIMCALL_FILE_READ),\
88
 
SIMCALL_ENUM_ELEMENT(SIMCALL_FILE_WRITE),\
89
 
SIMCALL_ENUM_ELEMENT(SIMCALL_FILE_OPEN),\
90
 
SIMCALL_ENUM_ELEMENT(SIMCALL_FILE_CLOSE),\
91
 
SIMCALL_ENUM_ELEMENT(SIMCALL_FILE_STAT)
92
 
 
 
12
/* we want to build the e_smx_simcall_t enumeration, the table of the
 
13
 * corresponding simcalls string names, and the simcall handlers table
 
14
 * automatically, using macros.
 
15
 * To add a new simcall follow the following syntax:
 
16
 *
 
17
 * SIMCALL_ENUM_ELEMENT(<simcall_enumeration_id>, <simcall_handler_function>)
 
18
 *
 
19
 * */
 
20
 
 
21
/****************************
 
22
 * SIMCALL GENERATING MACRO *
 
23
 ****************************
 
24
 *
 
25
 * action(ENUM_NAME, func_name, result_type, params…) 
 
26
 *
 
27
 **/
 
28
 
 
29
/*
 
30
 * Some macro machinery to get a MAP over the arguments of a variadic macro.
 
31
 * It uses a FOLD to apply a macro to every argument, and because there is
 
32
 * no recursion in the C preprocessor we must create a new macro for every
 
33
 * depth of FOLD's recursion.
 
34
 */
 
35
 
 
36
/* FOLD macro */
 
37
#define FE_0(WHAT, X, ...)
 
38
#define FE_1(I, WHAT, X) WHAT(I, X)
 
39
#define FE_2(I, WHAT, X, ...) WHAT(I, X), FE_1(I+1, WHAT, __VA_ARGS__)
 
40
#define FE_3(I, WHAT, X, ...) WHAT(I, X), FE_2(I+1, WHAT, __VA_ARGS__)
 
41
#define FE_4(I, WHAT, X, ...) WHAT(I, X), FE_3(I+1, WHAT, __VA_ARGS__)
 
42
#define FE_5(I, WHAT, X, ...) WHAT(I, X), FE_4(I+1, WHAT, __VA_ARGS__)
 
43
#define FE_6(I, WHAT, X, ...) WHAT(I, X), FE_5(I+1, WHAT, __VA_ARGS__)
 
44
#define FE_7(I, WHAT, X, ...) WHAT(I, X), FE_6(I+1, WHAT, __VA_ARGS__)
 
45
#define FE_8(I, WHAT, X, ...) WHAT(I, X), FE_7(I+1, WHAT, __VA_ARGS__)
 
46
#define FE_9(I, WHAT, X, ...) WHAT(I, X), FE_8(I+1, WHAT, __VA_ARGS__)
 
47
#define FE_10(I, WHAT, X, ...) WHAT(I, X), FE_9(I+1, WHAT, __VA_ARGS__)
 
48
 
 
49
/* NOTE: add as many FE_n as needed (maximum number of simcall arguments )*/
 
50
 
 
51
/* Make a MAP macro usgin FOLD (will apply 'action' to the arguments.
 
52
 * GET_MACRO is a smart hack that counts the number of arguments passed to
 
53
 * the variadic macro, and it is used to invoke the right FOLD depth.
 
54
 */
 
55
#define GET_MACRO(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,NAME,...) NAME
 
56
#define MAP(action, ...) \
 
57
  GET_MACRO(, ##__VA_ARGS__, FE_10,FE_9,FE_8,FE_7,FE_6,FE_5,FE_4,FE_3,FE_2,FE_1, FE_0) (0, action, __VA_ARGS__)
 
58
 
 
59
/* MAP with default arguments */
 
60
#define APPLY_MAP(WHAT, I, X, ...) WHAT(I, __VA_ARGS__, X)
 
61
#define FE_DA_0(I, WHAT, args, X, ...)
 
62
#define FE_DA_1(I, WHAT, args, X, ...) APPLY_MAP(WHAT, I, X, args)
 
63
#define FE_DA_2(I, WHAT, args, X, ...) APPLY_MAP(WHAT, I, X, args) FE_DA_1(I+1, WHAT, args, __VA_ARGS__)
 
64
#define FE_DA_3(I, WHAT, args, X, ...) APPLY_MAP(WHAT, I, X, args) FE_DA_2(I+1, WHAT, args, __VA_ARGS__)
 
65
#define FE_DA_4(I, WHAT, args, X, ...) APPLY_MAP(WHAT, I, X, args) FE_DA_3(I+1, WHAT, args, __VA_ARGS__)
 
66
#define FE_DA_5(I, WHAT, args, X, ...) APPLY_MAP(WHAT, I, X, args) FE_DA_4(I+1, WHAT, args, __VA_ARGS__)
 
67
#define FE_DA_6(I, WHAT, args, X, ...) APPLY_MAP(WHAT, I, X, args) FE_DA_5(I+1, WHAT, args, __VA_ARGS__)
 
68
#define FE_DA_7(I, WHAT, args, X, ...) APPLY_MAP(WHAT, I, X, args) FE_DA_6(I+1, WHAT, args, __VA_ARGS__)
 
69
#define FE_DA_8(I, WHAT, args, X, ...) APPLY_MAP(WHAT, I, X, args) FE_DA_7(I+1, WHAT, args, __VA_ARGS__)
 
70
#define FE_DA_9(I, WHAT, args, X, ...) APPLY_MAP(WHAT, I, X, args) FE_DA_8(I+1, WHAT, args, __VA_ARGS__)
 
71
#define FE_DA_10(I, WHAT, args, X, ...) APPLY_MAP(WHAT, I, X, args) FE_DA_9(I+1, WHAT, args, __VA_ARGS__)
 
72
 
 
73
#define MAP_WITH_DEFAULT_ARGS(action, args, ...) \
 
74
  GET_MACRO(, ##__VA_ARGS__, FE_DA_10,FE_DA_9,FE_DA_8,FE_DA_7,FE_DA_6,FE_DA_5,FE_DA_4,FE_DA_3,FE_DA_2,FE_DA_1, FE_DA_0) (0, action, args, __VA_ARGS__)
 
75
 
 
76
/*
 
77
 * Define scalar type wrappers to ease the use of simcalls.
 
78
 * These are used to wrap the arguments in SIMIX_simcall macro.
 
79
 */
 
80
#define TCHAR(n) (n, char, c)
 
81
#define TSTRING(n) (n, const char*, cc)
 
82
#define TSHORT(n) (n, short, s)
 
83
#define TINT(n) (n, int, i)
 
84
#define TLONG(n) (n, long, l)
 
85
#define TUCHAR(n) (n, unsigned char, uc)
 
86
#define TUSHORT(n) (n, unsigned short, us)
 
87
#define TUINT(n) (n, unsigned int, ui)
 
88
#define TULONG(n) (n, unsigned long, ul)
 
89
#define TFLOAT(n) (n, float, f)
 
90
#define TDOUBLE(n) (n, double, d)
 
91
#define TPTR(n) (n, void*, p)
 
92
#define TCPTR(n) (n, const void*, cp)
 
93
#define TSIZE(n) (n, size_t, si)
 
94
#define TVOID(n) (n, void)
 
95
#define TSPEC(n,t) (n, t, p)
 
96
 
 
97
/* use comma or nothing to separate elements*/
 
98
#define SIMCALL_SEP_COMMA ,
 
99
#define SIMCALL_SEP_NOTHING
 
100
 
 
101
/* get the name of the parameter */
 
102
#define SIMCALL_NAME_(name, type, field) name
 
103
#define SIMCALL_NAME(i, v) SIMCALL_NAME_ v
 
104
 
 
105
/* get the %s format code of the parameter */
 
106
#define SIMCALL_FORMAT_(name, type, field) %field
 
107
#define SIMCALL_FORMAT(i, v) SIMCALL_FORMAT_ v
 
108
 
 
109
/* get the field of the parameter */
 
110
#define SIMCALL_FIELD_(name, type, field) field
 
111
#define SIMCALL_FIELD(i, v) SIMCALL_FIELD_ v
 
112
 
 
113
/* get the parameter declaration */
 
114
#define SIMCALL_ARG_(name, type, field) type name
 
115
#define SIMCALL_ARG(i, v) SIMCALL_ARG_ v
 
116
 
 
117
/* get the parameter initialisation field */
 
118
#define SIMCALL_INIT_FIELD_(name, type, field) .field = name
 
119
#define SIMCALL_INIT_FIELD(i, d, v) self->simcall.args[i]SIMCALL_INIT_FIELD_ v;
 
120
 
 
121
/* get the case of the parameter */
 
122
#define SIMCALL_CASE_PARAM_(name, type, field) field
 
123
#define SIMCALL_CASE_PARAM(i, v) simcall->args[i].SIMCALL_CASE_PARAM_ v
 
124
 
 
125
/* generate some code for SIMCALL_CASE if the simcall has an answer */
 
126
#define MAYBE2(_0, _1, func, ...) func
 
127
 
 
128
#define SIMCALL_WITH_RESULT_BEGIN(name, type, field) simcall->result.field =
 
129
#define SIMCALL_WITHOUT_RESULT_BEGIN(name, type, field)
 
130
#define SIMCALL_RESULT_BEGIN_(name, type, ...)\
 
131
        MAYBE2(,##__VA_ARGS__, SIMCALL_WITH_RESULT_BEGIN, SIMCALL_WITHOUT_RESULT_BEGIN)\
 
132
        (name, type, __VA_ARGS__)
 
133
#define SIMCALL_RESULT_BEGIN(answer, res) answer(SIMCALL_RESULT_BEGIN_ res)
 
134
 
 
135
#define SIMCALL_RESULT_END_(name, type, ...)\
 
136
        SIMIX_simcall_answer(simcall);
 
137
#define SIMCALL_RESULT_END(answer, res) answer(SIMCALL_RESULT_END_ res)
 
138
 
 
139
/* generate some code for BODY function */
 
140
#define SIMCALL_FUNC_RETURN_TYPE_(name, type, ...) type
 
141
#define SIMCALL_FUNC_RETURN_TYPE(res) SIMCALL_FUNC_RETURN_TYPE_ res
 
142
 
 
143
#define SIMCALL_WITH_FUNC_SIMCALL(name, type, field) smx_simcall_t simcall = 
 
144
#define SIMCALL_WITHOUT_FUNC_SIMCALL(name, type, field)
 
145
#define SIMCALL_FUNC_SIMCALL_(name, type, ...)\
 
146
        MAYBE2(,##__VA_ARGS__, SIMCALL_WITH_FUNC_SIMCALL, SIMCALL_WITHOUT_FUNC_SIMCALL)\
 
147
        (name, type, __VA_ARGS__)
 
148
#define SIMCALL_FUNC_SIMCALL(res) SIMCALL_FUNC_SIMCALL_ res
 
149
 
 
150
#define SIMCALL_WITH_FUNC_RETURN(name, type, field) return self->simcall.result.field;
 
151
#define SIMCALL_WITHOUT_FUNC_RETURN(name, type, field)
 
152
#define SIMCALL_FUNC_RETURN_(name, type, ...)\
 
153
        MAYBE2(,##__VA_ARGS__, SIMCALL_WITH_FUNC_RETURN, SIMCALL_WITHOUT_FUNC_RETURN)\
 
154
        (name, type, __VA_ARGS__)
 
155
#define SIMCALL_FUNC_RETURN(res) SIMCALL_FUNC_RETURN_ res
 
156
 
 
157
 
 
158
/* generate the simcall enumeration */
 
159
#define SIMCALL_ENUM(type, ...)\
 
160
        type
 
161
 
 
162
/* generate the strings name from the enumeration values */
 
163
#define SIMCALL_STRING_TYPE(type, name, answer, res, ...)\
 
164
        [type] = STRINGIFY(type)
 
165
 
 
166
/* generate strings from the enumeration values */
 
167
#define SIMCALL_TYPE(type, name, answer, res, ...)\
 
168
        [type] = STRINGIFY(MAP(SIMCALL_FORMAT, __VA_ARGS__))
 
169
 
 
170
/* generate the simcalls BODY functions */
 
171
#define SIMCALL_FUNC(TYPE, NAME, ANSWER, RES, ...)\
 
172
  inline static SIMCALL_FUNC_RETURN_TYPE(RES) simcall_BODY_##NAME(MAP(SIMCALL_ARG, ##__VA_ARGS__)) { \
 
173
    smx_process_t self = SIMIX_process_self(); \
 
174
    self->simcall.call = TYPE; \
 
175
    memset(self->simcall.args, 0, sizeof(self->simcall.args));  \
 
176
    MAP_WITH_DEFAULT_ARGS(SIMCALL_INIT_FIELD, (), ##__VA_ARGS__) \
 
177
    if (self != simix_global->maestro_process) { \
 
178
      XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name, \
 
179
                SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call); \
 
180
      SIMIX_process_yield(self); \
 
181
    } else { \
 
182
      SIMIX_simcall_pre(&self->simcall, 0); \
 
183
    } \
 
184
    SIMCALL_FUNC_RETURN(RES) \
 
185
  }
 
186
 
 
187
/* generate a comma if there is an argument*/
 
188
#define WITHOUT_COMMA 
 
189
#define WITH_COMMA ,
 
190
#define GET_CLEAN(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10, NAME,...) NAME
 
191
#define MAYBE_COMMA(...) GET_CLEAN(,##__VA_ARGS__,WITH_COMMA,WITH_COMMA,WITH_COMMA,WITH_COMMA,WITH_COMMA,WITH_COMMA,WITH_COMMA,WITH_COMMA,WITH_COMMA,WITH_COMMA,WITHOUT_COMMA)
 
192
 
 
193
/* generate the simcalls cases for the SIMIX_simcall_pre function */
 
194
#define WITH_ANSWER(...) __VA_ARGS__
 
195
#define WITHOUT_ANSWER(...) 
 
196
#define SIMCALL_CASE(type, name, answer, res, ...)\
 
197
    case type:\
 
198
      SIMCALL_RESULT_BEGIN(answer, res) SIMIX_pre_ ## name(simcall MAYBE_COMMA(__VA_ARGS__) MAP(SIMCALL_CASE_PARAM, ##__VA_ARGS__));\
 
199
      SIMCALL_RESULT_END(answer, res)\
 
200
      break;
 
201
 
 
202
 
 
203
/*
 
204
 * Generate simcall args and result getter/setter
 
205
 */
 
206
#define SIMCALL_GS_SC_NAME_(n) n
 
207
#define SIMCALL_GS_SC_NAME(n) SIMCALL_GS_SC_NAME_ n
 
208
#define SIMCALL_GS_ARG_NAME(n) SIMCALL_NAME_ n
 
209
#define JOIN2(_0, _1) _0 ##__## _1
 
210
#define JOIN3(_0, _1, _2) JOIN2(_0 ##__## _1, _2)
 
211
#define JOIN4(_0, _1, _2, _3) JOIN3(_0 ##_## _1, _2, _3)
 
212
#define SIMCALL_GS_FUNC(scname, setget, vname) \
 
213
   JOIN4(simcall, scname, setget, vname)
 
214
 
 
215
/* generate the simcalls args getter/setter */
 
216
#define SIMCALL_ARG_GETSET_(i, name, v) \
 
217
  static inline SIMCALL_FUNC_RETURN_TYPE(v) SIMCALL_GS_FUNC(SIMCALL_GS_SC_NAME(name), get, SIMCALL_GS_ARG_NAME(v))(smx_simcall_t simcall){\
 
218
    return simcall->args[i].SIMCALL_FIELD_ v ;\
 
219
  }\
 
220
  static inline void SIMCALL_GS_FUNC(SIMCALL_GS_SC_NAME(name), set, SIMCALL_GS_ARG_NAME(v))(smx_simcall_t simcall, SIMCALL_ARG_ v){\
 
221
    simcall->args[i].SIMCALL_FIELD_ v = SIMCALL_NAME_ v ;\
 
222
  }
 
223
 
 
224
#define SIMCALL_ARG_GETSET(type, name, answer, res, ...)\
 
225
    MAP_WITH_DEFAULT_ARGS(SIMCALL_ARG_GETSET_, (name), ##__VA_ARGS__)
 
226
 
 
227
/* generate the simcalls result getter/setter */
 
228
#define SIMCALL_WITH_RES_GETSET(name, v) \
 
229
  static inline SIMCALL_FUNC_RETURN_TYPE(v) SIMCALL_GS_FUNC(SIMCALL_GS_SC_NAME((name)), get, SIMCALL_GS_ARG_NAME(v))(smx_simcall_t simcall){\
 
230
    return simcall->result.SIMCALL_FIELD_ v ;\
 
231
  }\
 
232
  static inline void SIMCALL_GS_FUNC(SIMCALL_GS_SC_NAME((name)), set, SIMCALL_GS_ARG_NAME(v))(smx_simcall_t simcall, SIMCALL_ARG_ v){\
 
233
    simcall->result.SIMCALL_FIELD_ v = SIMCALL_NAME_ v ;\
 
234
  }
 
235
#define SIMCALL_WITHOUT_RES_GETSET(name, v)
 
236
#define SIMCALL_RES_GETSET__(name, type, ...)\
 
237
        MAYBE2(,##__VA_ARGS__, SIMCALL_WITH_RES_GETSET, SIMCALL_WITHOUT_RES_GETSET)
 
238
#define SIMCALL_RES_GETSET_(scname, v)\
 
239
        SIMCALL_RES_GETSET__ v (scname, v)
 
240
#define SIMCALL_RES_GETSET(type, name, answer, res, ...)\
 
241
  SIMCALL_RES_GETSET_(name, res)
 
242
 
 
243
/* generate the simcalls result getter/setter protos*/
 
244
#define SIMCALL_WITH_RES_GETSET_PROTO(name, v) \
 
245
  inline SIMCALL_FUNC_RETURN_TYPE(v) SIMCALL_GS_FUNC(SIMCALL_GS_SC_NAME((name)), get, SIMCALL_GS_ARG_NAME(v))(smx_simcall_t simcall);\
 
246
  inline void SIMCALL_GS_FUNC(SIMCALL_GS_SC_NAME((name)), set, SIMCALL_GS_ARG_NAME(v))(smx_simcall_t simcall, SIMCALL_ARG_ v);
 
247
#define SIMCALL_WITHOUT_RES_GETSET_PROTO(name, v)
 
248
#define SIMCALL_RES_GETSET_PROTO__(name, type, ...)\
 
249
        MAYBE2(,##__VA_ARGS__, SIMCALL_WITH_RES_GETSET_PROTO, SIMCALL_WITHOUT_RES_GETSET_PROTO)
 
250
#define SIMCALL_RES_GETSET_PROTO_(scname, v)\
 
251
        SIMCALL_RES_GETSET_PROTO__ v (scname, v)
 
252
#define SIMCALL_RES_GETSET_PROTO(type, name, answer, res, ...)\
 
253
  SIMCALL_RES_GETSET_PROTO_(name, res)
 
254
 
 
255
/* stringify arguments */
 
256
#define STRINGIFY_(...) #__VA_ARGS__
 
257
#define STRINGIFY(...) STRINGIFY_(__VA_ARGS__)
 
258
 
 
259
/* the list of simcalls definitions */
 
260
#define SIMCALL_LIST1(ACTION, sep) \
 
261
ACTION(SIMCALL_HOST_GET_BY_NAME, host_get_by_name, WITH_ANSWER, TSPEC(result, smx_host_t), TSTRING(name)) sep \
 
262
ACTION(SIMCALL_HOST_GET_NAME, host_get_name, WITH_ANSWER, TSTRING(result), TSPEC(host, smx_host_t)) sep \
 
263
ACTION(SIMCALL_HOST_GET_PROPERTIES, host_get_properties, WITH_ANSWER, TSPEC(result, xbt_dict_t), TSPEC(host, smx_host_t)) sep \
 
264
ACTION(SIMCALL_HOST_GET_SPEED, host_get_speed, WITH_ANSWER, TDOUBLE(result), TSPEC(host, smx_host_t)) sep \
 
265
ACTION(SIMCALL_HOST_GET_AVAILABLE_SPEED, host_get_available_speed, WITH_ANSWER, TDOUBLE(result), TSPEC(host, smx_host_t)) sep \
 
266
ACTION(SIMCALL_HOST_GET_STATE, host_get_state, WITH_ANSWER, TINT(result), TSPEC(host, smx_host_t)) sep \
 
267
ACTION(SIMCALL_HOST_GET_DATA, host_get_data, WITH_ANSWER, TPTR(result), TSPEC(host, smx_host_t)) sep \
 
268
ACTION(SIMCALL_HOST_SET_DATA, host_set_data, WITH_ANSWER, TVOID(result), TSPEC(host, smx_host_t), TPTR(data)) sep \
 
269
ACTION(SIMCALL_HOST_EXECUTE, host_execute, WITH_ANSWER, TSPEC(result, smx_action_t), TSTRING(name), TSPEC(host, smx_host_t), TDOUBLE(computation_amount), TDOUBLE(priority)) sep \
 
270
ACTION(SIMCALL_HOST_PARALLEL_EXECUTE, host_parallel_execute, WITH_ANSWER, TSPEC(result, smx_action_t), TSTRING(name), TINT(host_nb), TSPEC(host_list, smx_host_t*), TSPEC(computation_amount, double*), TSPEC(communication_amount, double*), TDOUBLE(amount), TDOUBLE(rate)) sep \
 
271
ACTION(SIMCALL_HOST_EXECUTION_DESTROY, host_execution_destroy, WITH_ANSWER, TVOID(result), TSPEC(execution, smx_action_t)) sep \
 
272
ACTION(SIMCALL_HOST_EXECUTION_CANCEL, host_execution_cancel, WITH_ANSWER, TVOID(result), TSPEC(execution, smx_action_t)) sep \
 
273
ACTION(SIMCALL_HOST_EXECUTION_GET_REMAINS, host_execution_get_remains, WITH_ANSWER, TDOUBLE(result), TSPEC(execution, smx_action_t)) sep \
 
274
ACTION(SIMCALL_HOST_EXECUTION_GET_STATE, host_execution_get_state, WITH_ANSWER, TINT(result), TSPEC(execution, smx_action_t)) sep \
 
275
ACTION(SIMCALL_HOST_EXECUTION_SET_PRIORITY, host_execution_set_priority, WITH_ANSWER, TVOID(result), TSPEC(execution, smx_action_t), TDOUBLE(priority)) sep \
 
276
ACTION(SIMCALL_HOST_EXECUTION_WAIT, host_execution_wait, WITHOUT_ANSWER, TINT(result), TSPEC(execution, smx_action_t)) sep \
 
277
ACTION(SIMCALL_PROCESS_CREATE, process_create, WITH_ANSWER, TVOID(result), TSPEC(process, smx_process_t*), TSTRING(name), TSPEC(code, xbt_main_func_t), TPTR(data), TSTRING(hostname), TDOUBLE(kill_time), TINT(argc), TSPEC(argv, char**), TSPEC(properties, xbt_dict_t), TINT(auto_restart)) sep \
 
278
ACTION(SIMCALL_PROCESS_KILL, process_kill, WITH_ANSWER, TVOID(result), TSPEC(process, smx_process_t)) sep \
 
279
ACTION(SIMCALL_PROCESS_KILLALL, process_killall, WITH_ANSWER, TVOID(result)) sep \
 
280
ACTION(SIMCALL_PROCESS_CLEANUP, process_cleanup, WITH_ANSWER, TVOID(result), TSPEC(process, smx_process_t)) sep \
 
281
ACTION(SIMCALL_PROCESS_CHANGE_HOST, process_change_host, WITH_ANSWER, TVOID(result), TSPEC(process, smx_process_t), TSPEC(dest, smx_host_t)) sep \
 
282
ACTION(SIMCALL_PROCESS_SUSPEND, process_suspend, WITHOUT_ANSWER, TVOID(result), TSPEC(process, smx_process_t)) sep \
 
283
ACTION(SIMCALL_PROCESS_RESUME, process_resume, WITH_ANSWER, TVOID(result), TSPEC(process, smx_process_t)) sep \
 
284
ACTION(SIMCALL_PROCESS_COUNT, process_count, WITH_ANSWER, TINT(result)) sep \
 
285
ACTION(SIMCALL_PROCESS_GET_DATA, process_get_data, WITH_ANSWER, TPTR(result), TSPEC(process, smx_process_t)) sep \
 
286
ACTION(SIMCALL_PROCESS_SET_DATA, process_set_data, WITH_ANSWER, TVOID(result), TSPEC(process, smx_process_t), TPTR(data)) sep \
 
287
ACTION(SIMCALL_PROCESS_GET_HOST, process_get_host, WITH_ANSWER, TSPEC(result, smx_host_t), TSPEC(process, smx_process_t)) sep \
 
288
ACTION(SIMCALL_PROCESS_GET_NAME, process_get_name, WITH_ANSWER, TSTRING(result), TSPEC(process, smx_process_t)) sep \
 
289
ACTION(SIMCALL_PROCESS_IS_SUSPENDED, process_is_suspended, WITH_ANSWER, TINT(result), TSPEC(process, smx_process_t)) sep \
 
290
ACTION(SIMCALL_PROCESS_GET_PROPERTIES, process_get_properties, WITH_ANSWER, TSPEC(result, xbt_dict_t), TSPEC(process, smx_process_t)) sep \
 
291
ACTION(SIMCALL_PROCESS_SLEEP, process_sleep, WITHOUT_ANSWER, TINT(result), TDOUBLE(duration)) sep \
 
292
ACTION(SIMCALL_PROCESS_ON_EXIT, process_on_exit, WITH_ANSWER, TVOID(result), TSPEC(process, smx_process_t), TSPEC(fun, int_f_pvoid_t), TPTR(data)) sep \
 
293
ACTION(SIMCALL_PROCESS_AUTO_RESTART_SET, process_auto_restart_set, WITH_ANSWER, TVOID(result), TSPEC(process, smx_process_t), TINT(auto_restart)) sep \
 
294
ACTION(SIMCALL_PROCESS_RESTART, process_restart, WITH_ANSWER, TSPEC(result, smx_process_t), TSPEC(process, smx_process_t)) sep \
 
295
ACTION(SIMCALL_RDV_CREATE, rdv_create, WITH_ANSWER, TSPEC(result, smx_rdv_t), TSTRING(name)) sep \
 
296
ACTION(SIMCALL_RDV_DESTROY, rdv_destroy, WITH_ANSWER, TVOID(result), TSPEC(rdv, smx_rdv_t)) sep \
 
297
ACTION(SIMCALL_RDV_GET_BY_NAME, rdv_get_by_name, WITH_ANSWER, TSPEC(result, smx_host_t), TSTRING(name)) sep \
 
298
ACTION(SIMCALL_RDV_COMM_COUNT_BY_HOST, rdv_comm_count_by_host, WITH_ANSWER, TUINT(result), TSPEC(rdv, smx_rdv_t), TSPEC(host, smx_host_t)) sep \
 
299
ACTION(SIMCALL_RDV_GET_HEAD, rdv_get_head, WITH_ANSWER, TSPEC(result, smx_action_t), TSPEC(rdv, smx_rdv_t)) sep \
 
300
ACTION(SIMCALL_RDV_SET_RECV, rdv_set_receiver, WITH_ANSWER, TVOID(result), TSPEC(rdv, smx_rdv_t), TSPEC(receiver, smx_process_t)) sep \
 
301
ACTION(SIMCALL_RDV_GET_RECV, rdv_get_receiver, WITH_ANSWER, TSPEC(result, smx_process_t), TSPEC(rdv, smx_rdv_t)) sep \
 
302
ACTION(SIMCALL_COMM_IPROBE, comm_iprobe, WITH_ANSWER, TSPEC(result, smx_action_t), TSPEC(rdv, smx_rdv_t), TINT(src), TINT(tag), TSPEC(match_fun, simix_match_func_t), TPTR(data)) sep \
 
303
ACTION(SIMCALL_COMM_SEND, comm_send, WITHOUT_ANSWER, TVOID(result), TSPEC(rdv, smx_rdv_t), TDOUBLE(task_size), TDOUBLE(rate), TPTR(src_buff), TSIZE(src_buff_size), TSPEC(match_fun, simix_match_func_t), TPTR(data), TDOUBLE(timeout)) sep \
 
304
ACTION(SIMCALL_COMM_ISEND, comm_isend, WITH_ANSWER, TSPEC(result, smx_action_t), TSPEC(rdv, smx_rdv_t), TDOUBLE(task_size), TDOUBLE(rate), TPTR(src_buff), TSIZE(src_buff_size), TSPEC(match_fun, simix_match_func_t), TSPEC(clean_fun, simix_clean_func_t), TPTR(data), TINT(detached)) sep \
 
305
ACTION(SIMCALL_COMM_RECV, comm_recv, WITHOUT_ANSWER, TVOID(result), TSPEC(rdv, smx_rdv_t), TPTR(dst_buff), TSPEC(dst_buff_size, size_t*), TSPEC(match_fun, simix_match_func_t), TPTR(data), TDOUBLE(timeout)) sep \
 
306
ACTION(SIMCALL_COMM_IRECV, comm_irecv, WITH_ANSWER, TSPEC(result, smx_action_t), TSPEC(rdv, smx_rdv_t), TPTR(dst_buff), TSPEC(dst_buff_size, size_t*), TSPEC(match_fun, simix_match_func_t), TPTR(data)) sep \
 
307
ACTION(SIMCALL_COMM_DESTROY, comm_destroy, WITH_ANSWER, TVOID(result), TSPEC(comm, smx_action_t)) sep \
 
308
ACTION(SIMCALL_COMM_CANCEL, comm_cancel, WITH_ANSWER, TVOID(result), TSPEC(comm, smx_action_t)) sep \
 
309
ACTION(SIMCALL_COMM_WAITANY, comm_waitany, WITHOUT_ANSWER, TINT(result), TSPEC(comms, xbt_dynar_t)) sep \
 
310
ACTION(SIMCALL_COMM_WAIT, comm_wait, WITHOUT_ANSWER, TVOID(result), TSPEC(comm, smx_action_t), TDOUBLE(timeout)) sep \
 
311
ACTION(SIMCALL_COMM_TEST, comm_test, WITHOUT_ANSWER, TINT(result), TSPEC(comm, smx_action_t)) sep \
 
312
ACTION(SIMCALL_COMM_TESTANY, comm_testany, WITHOUT_ANSWER, TINT(result), TSPEC(comms, xbt_dynar_t)) sep \
 
313
ACTION(SIMCALL_COMM_GET_REMAINS, comm_get_remains, WITH_ANSWER, TDOUBLE(result), TSPEC(comm, smx_action_t)) sep \
 
314
ACTION(SIMCALL_COMM_GET_STATE, comm_get_state, WITH_ANSWER, TINT(result), TSPEC(comm, smx_action_t)) sep \
 
315
ACTION(SIMCALL_COMM_GET_SRC_DATA, comm_get_src_data, WITH_ANSWER, TPTR(result), TSPEC(comm, smx_action_t)) sep \
 
316
ACTION(SIMCALL_COMM_GET_DST_DATA, comm_get_dst_data, WITH_ANSWER, TPTR(result), TSPEC(comm, smx_action_t)) sep \
 
317
ACTION(SIMCALL_COMM_GET_SRC_PROC, comm_get_src_proc, WITH_ANSWER, TSPEC(result, smx_process_t), TSPEC(comm, smx_action_t)) sep \
 
318
ACTION(SIMCALL_COMM_GET_DST_PROC, comm_get_dst_proc, WITH_ANSWER, TSPEC(result, smx_process_t), TSPEC(comm, smx_action_t)) sep \
 
319
ACTION(SIMCALL_MUTEX_INIT, mutex_init, WITH_ANSWER, TSPEC(result, smx_mutex_t)) sep \
 
320
ACTION(SIMCALL_MUTEX_DESTROY, mutex_destroy, WITH_ANSWER, TVOID(result), TSPEC(mutex, smx_mutex_t)) sep \
 
321
ACTION(SIMCALL_MUTEX_LOCK, mutex_lock, WITHOUT_ANSWER, TVOID(result), TSPEC(mutex, smx_mutex_t)) sep \
 
322
ACTION(SIMCALL_MUTEX_TRYLOCK, mutex_trylock, WITH_ANSWER, TINT(result), TSPEC(mutex, smx_mutex_t)) sep \
 
323
ACTION(SIMCALL_MUTEX_UNLOCK, mutex_unlock, WITH_ANSWER, TVOID(result), TSPEC(mutex, smx_mutex_t)) sep \
 
324
ACTION(SIMCALL_COND_INIT, cond_init, WITH_ANSWER, TSPEC(result, smx_cond_t)) sep \
 
325
ACTION(SIMCALL_COND_DESTROY, cond_destroy, WITH_ANSWER, TVOID(result), TSPEC(cond, smx_cond_t)) sep \
 
326
ACTION(SIMCALL_COND_SIGNAL, cond_signal, WITH_ANSWER, TVOID(result), TSPEC(cond, smx_cond_t)) sep \
 
327
ACTION(SIMCALL_COND_WAIT, cond_wait, WITHOUT_ANSWER, TVOID(result), TSPEC(cond, smx_cond_t), TSPEC(mutex, smx_mutex_t)) sep \
 
328
ACTION(SIMCALL_COND_WAIT_TIMEOUT, cond_wait_timeout, WITHOUT_ANSWER, TVOID(result), TSPEC(cond, smx_cond_t), TSPEC(mutex, smx_mutex_t), TDOUBLE(timeout)) sep \
 
329
ACTION(SIMCALL_COND_BROADCAST, cond_broadcast, WITH_ANSWER, TVOID(result), TSPEC(cond, smx_cond_t)) sep \
 
330
ACTION(SIMCALL_SEM_INIT, sem_init, WITH_ANSWER, TSPEC(result, smx_sem_t), TINT(capacity)) sep \
 
331
ACTION(SIMCALL_SEM_DESTROY, sem_destroy, WITH_ANSWER, TVOID(result), TSPEC(sem, smx_sem_t)) sep \
 
332
ACTION(SIMCALL_SEM_RELEASE, sem_release, WITH_ANSWER, TVOID(result), TSPEC(sem, smx_sem_t)) sep \
 
333
ACTION(SIMCALL_SEM_WOULD_BLOCK, sem_would_block, WITH_ANSWER, TINT(result), TSPEC(sem, smx_sem_t)) sep \
 
334
ACTION(SIMCALL_SEM_ACQUIRE, sem_acquire, WITHOUT_ANSWER, TVOID(result), TSPEC(sem, smx_sem_t)) sep \
 
335
ACTION(SIMCALL_SEM_ACQUIRE_TIMEOUT, sem_acquire_timeout, WITHOUT_ANSWER, TVOID(result), TSPEC(sem, smx_sem_t), TDOUBLE(timeout)) sep \
 
336
ACTION(SIMCALL_SEM_GET_CAPACITY, sem_get_capacity, WITH_ANSWER, TINT(result), TSPEC(sem, smx_sem_t)) sep \
 
337
ACTION(SIMCALL_FILE_READ, file_read, WITHOUT_ANSWER, TDOUBLE(result), TPTR(ptr), TSIZE(size), TSIZE(nmemb), TSPEC(stream, smx_file_t)) sep \
 
338
ACTION(SIMCALL_FILE_WRITE, file_write, WITHOUT_ANSWER, TSIZE(result), TCPTR(ptr), TSIZE(size), TSIZE(nmemb), TSPEC(stream, smx_file_t)) sep \
 
339
ACTION(SIMCALL_FILE_OPEN, file_open, WITHOUT_ANSWER, TSPEC(result, smx_file_t), TSTRING(mount), TSTRING(path), TSTRING(mode)) sep \
 
340
ACTION(SIMCALL_FILE_CLOSE, file_close, WITHOUT_ANSWER, TINT(result), TSPEC(fp, smx_file_t)) sep \
 
341
ACTION(SIMCALL_FILE_STAT, file_stat, WITHOUT_ANSWER, TINT(result), TSPEC(fd, smx_file_t), TSPEC(buf, s_file_stat_t*)) sep \
 
342
ACTION(SIMCALL_FILE_UNLINK, file_unlink, WITHOUT_ANSWER, TINT(result), TSPEC(fd, smx_file_t)) sep \
 
343
ACTION(SIMCALL_FILE_LS, file_ls, WITHOUT_ANSWER, TSPEC(result, xbt_dict_t), TSTRING(mount), TSTRING(path)) sep \
 
344
ACTION(SIMCALL_ASR_GET_PROPERTIES, asr_get_properties, WITH_ANSWER, TSPEC(result, xbt_dict_t), TSTRING(name)) sep 
93
345
 
94
346
/* SIMCALL_COMM_IS_LATENCY_BOUNDED and SIMCALL_SET_CATEGORY make things complicated
95
347
 * because they are not always present */
96
348
#ifdef HAVE_LATENCY_BOUND_TRACKING
97
 
#define SIMCALL_LIST2 \
98
 
,SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_IS_LATENCY_BOUNDED)
 
349
#define SIMCALL_LIST2(ACTION, sep) \
 
350
ACTION(SIMCALL_COMM_IS_LATENCY_BOUNDED, comm_is_latency_bounded, WITH_ANSWER, TINT(result), TSPEC(comm, smx_action_t)) sep
99
351
#else
100
 
#define SIMCALL_LIST2
 
352
#define SIMCALL_LIST2(ACTION, sep)
101
353
#endif
102
354
 
103
355
#ifdef HAVE_TRACING
104
 
#define SIMCALL_LIST3 \
105
 
,SIMCALL_ENUM_ELEMENT(SIMCALL_SET_CATEGORY)
106
 
#else
107
 
#define SIMCALL_LIST3
 
356
#define SIMCALL_LIST3(ACTION, sep) \
 
357
ACTION(SIMCALL_SET_CATEGORY, set_category, WITH_ANSWER, TVOID(result), TSPEC(action, smx_action_t), TSTRING(category)) sep
 
358
#else
 
359
#define SIMCALL_LIST3(ACTION, sep)
 
360
#endif
 
361
 
 
362
#ifdef HAVE_MC
 
363
#define SIMCALL_LIST4(ACTION, sep) \
 
364
ACTION(SIMCALL_MC_SNAPSHOT, mc_snapshot, WITH_ANSWER, TPTR(result)) sep \
 
365
ACTION(SIMCALL_MC_COMPARE_SNAPSHOTS, mc_compare_snapshots, WITH_ANSWER, TINT(result), TPTR(s1), TPTR(s2)) sep 
 
366
#else
 
367
#define SIMCALL_LIST4(ACTION, sep)
108
368
#endif
109
369
 
110
370
/* SIMCALL_LIST is the final macro to use */
111
 
#define SIMCALL_LIST SIMCALL_LIST1 SIMCALL_LIST2 SIMCALL_LIST3
 
371
#define SIMCALL_LIST(ACTION, ...) \
 
372
  SIMCALL_LIST1(ACTION, ##__VA_ARGS__)\
 
373
  SIMCALL_LIST2(ACTION, ##__VA_ARGS__)\
 
374
  SIMCALL_LIST3(ACTION, ##__VA_ARGS__)\
 
375
  SIMCALL_LIST4(ACTION, ##__VA_ARGS__)
 
376
 
112
377
 
113
378
/* you can redefine the following macro differently to generate something else
114
379
 * with the list of enumeration values (e.g. a table of strings or a table of function pointers) */
115
 
#define SIMCALL_ENUM_ELEMENT(x) x
 
380
#define SIMCALL_ENUM_ELEMENT(x, y) x
116
381
 
117
382
/**
118
383
 * \brief All possible simcalls.
119
384
 */
120
385
typedef enum {
121
 
SIMCALL_LIST
 
386
SIMCALL_NONE,
 
387
SIMCALL_LIST(SIMCALL_ENUM, SIMCALL_SEP_COMMA)
 
388
SIMCALL_NEW_API_INIT,
 
389
NUM_SIMCALLS
122
390
} e_smx_simcall_t;
123
391
 
 
392
typedef int (*simix_match_func_t)(void *, void *, smx_action_t);
 
393
typedef void (*simix_clean_func_t)(void *);
 
394
 
 
395
/* Pack all possible scalar types in an union */
 
396
union u_smx_scalar {
 
397
  char            c;
 
398
  const char*     cc;
 
399
  short           s;
 
400
  int             i;
 
401
  long            l;
 
402
  unsigned char   uc;
 
403
  unsigned short  us;
 
404
  unsigned int    ui;
 
405
  unsigned long   ul;
 
406
  float           f;
 
407
  double          d;
 
408
  size_t          si;
 
409
  void*           p;
 
410
  const void*     cp;
 
411
};
 
412
 
124
413
/**
125
414
 * \brief Represents a simcall to the kernel.
126
415
 */
127
416
typedef struct s_smx_simcall {
128
417
  e_smx_simcall_t call;
129
418
  smx_process_t issuer;
130
 
 
 
419
  int mc_value;
 
420
  union u_smx_scalar args[10];
 
421
  union u_smx_scalar result;
 
422
  //FIXME: union u_smx_scalar retval;
131
423
  union {
132
 
 
133
 
    struct {
134
 
      const char *name;
135
 
      smx_host_t result;
136
 
    } host_get_by_name;
137
 
 
138
 
    struct {
139
 
      smx_host_t host;
140
 
      const char* result;
141
 
    } host_get_name;
142
 
 
143
 
    struct {
144
 
      smx_host_t host;
145
 
      xbt_dict_t result;
146
 
    } host_get_properties;
147
 
 
148
 
    struct {
149
 
      smx_host_t host;
150
 
      double result;
151
 
    } host_get_speed;
152
 
 
153
 
    struct {
154
 
      smx_host_t host;
155
 
      double result;
156
 
    } host_get_available_speed;
157
 
 
158
 
    struct {
159
 
      smx_host_t host;
160
 
      int result;
161
 
    } host_get_state;
162
 
 
163
 
    struct {
164
 
      smx_host_t host;
165
 
      void* result;
166
 
    } host_get_data;
167
 
 
168
 
    struct {
169
 
      smx_host_t host;
170
 
      void* data;
171
 
    } host_set_data;
172
 
 
173
 
    struct {
174
 
      const char* name;
175
 
      smx_host_t host;
176
 
      double computation_amount;
177
 
      double priority;
178
 
      smx_action_t result;
179
 
    } host_execute;
180
 
 
181
 
    struct {
182
 
      const char *name;
183
 
      int host_nb;
184
 
      smx_host_t *host_list;
185
 
      double *computation_amount;
186
 
      double *communication_amount;
187
 
      double amount;
188
 
      double rate;
189
 
      smx_action_t result;
190
 
    } host_parallel_execute;
191
 
 
192
 
    struct {
193
 
      smx_action_t execution;
194
 
    } host_execution_destroy;
195
 
 
196
 
    struct {
197
 
      smx_action_t execution;
198
 
    } host_execution_cancel;
199
 
 
200
 
    struct {
201
 
      smx_action_t execution;
202
 
      double result;
203
 
    } host_execution_get_remains;
204
 
 
205
 
    struct {
206
 
      smx_action_t execution;
207
 
      e_smx_state_t result;
208
 
    } host_execution_get_state;
209
 
 
210
 
    struct {
211
 
      smx_action_t execution;
212
 
      double priority;
213
 
    } host_execution_set_priority;
214
 
 
215
 
    struct {
216
 
      smx_action_t execution;
217
 
      e_smx_state_t result;
218
 
    } host_execution_wait;
219
 
 
220
 
    struct {
221
 
      smx_process_t *process;
222
 
      const char *name;
223
 
      xbt_main_func_t code;
224
 
      void *data;
225
 
      const char *hostname;
226
 
      double kill_time;
227
 
      int argc;
228
 
      char **argv;
229
 
      xbt_dict_t properties;
230
 
    } process_create;
231
 
 
232
 
    struct {
233
 
      smx_process_t process;
234
 
    } process_kill;
235
 
 
236
 
    struct {
237
 
      smx_process_t process;
238
 
    } process_cleanup;
239
 
 
240
 
    struct {
241
 
      smx_process_t process;
242
 
      smx_host_t dest;
243
 
    } process_change_host;
244
 
 
245
 
    struct {
246
 
      smx_process_t process;
247
 
    } process_suspend;
248
 
 
249
 
    struct {
250
 
      smx_process_t process;
251
 
    } process_resume;
252
 
 
253
 
    struct {
254
 
      int result;
255
 
    } process_count;
256
 
 
257
 
    struct {
258
 
      smx_process_t process;
259
 
      void* result;
260
 
    } process_get_data;
261
 
 
262
 
    struct {
263
 
      smx_process_t process;
264
 
      void* data;
265
 
    } process_set_data;
266
 
 
267
 
    struct {
268
 
      smx_process_t process;
269
 
      smx_host_t result;
270
 
    } process_get_host;
271
 
 
272
 
    struct {
273
 
      smx_process_t process;
274
 
      const char *result;
275
 
    } process_get_name;
276
 
 
277
 
    struct {
278
 
      smx_process_t process;
279
 
      int result;
280
 
    } process_is_suspended;
281
 
 
282
 
    struct {
283
 
      smx_process_t process;
284
 
      xbt_dict_t result;
285
 
    } process_get_properties;
286
 
 
287
 
    struct {
288
 
      double duration;
289
 
      e_smx_state_t result;
290
 
    } process_sleep;
291
 
 
292
 
    struct {
293
 
      const char *name;
294
 
      smx_rdv_t result;
295
 
    } rdv_create;
296
 
 
297
 
    struct {
298
 
      smx_rdv_t rdv;
299
 
    } rdv_destroy;
300
 
 
301
 
    struct {
302
 
      const char* name;
303
 
      smx_rdv_t result;
304
 
    } rdv_get_by_name;
305
 
 
306
 
    struct {
307
 
      smx_rdv_t rdv;
308
 
      smx_host_t host;
309
 
      unsigned int result; 
310
 
    } rdv_comm_count_by_host;
311
 
 
312
 
    struct {
313
 
      smx_rdv_t rdv;
314
 
      smx_action_t result;
315
 
    } rdv_get_head;
316
 
 
317
 
    struct {
318
 
      smx_rdv_t rdv;
319
 
      double task_size;
320
 
      double rate;
321
 
      void *src_buff;
322
 
      size_t src_buff_size;
323
 
      int (*match_fun)(void *, void *, smx_action_t);
324
 
      void *data;
325
 
      double timeout;
326
 
    } comm_send;
327
 
 
328
 
    struct {
329
 
      smx_rdv_t rdv;
330
 
      double task_size;
331
 
      double rate;
332
 
      void *src_buff;
333
 
      size_t src_buff_size;
334
 
      int (*match_fun)(void *, void *, smx_action_t);
335
 
      void (*clean_fun)(void *);
336
 
      void *data;
337
 
      int detached;
338
 
      smx_action_t result;
339
 
    } comm_isend;
340
 
 
341
 
    struct {
342
 
      smx_rdv_t rdv;
343
 
      void *dst_buff;
344
 
      size_t *dst_buff_size;
345
 
      int (*match_fun)(void *, void *, smx_action_t);
346
 
      void *data;
347
 
      double timeout;
348
 
    } comm_recv;
349
 
 
350
 
    struct {
351
 
      smx_rdv_t rdv;
352
 
      void *dst_buff;
353
 
      size_t *dst_buff_size;
354
 
      int (*match_fun)(void *, void *, smx_action_t);
355
 
      void *data;
356
 
      smx_action_t result;
357
 
    } comm_irecv;
358
 
 
359
 
    struct {
360
 
      smx_action_t comm;
361
 
    } comm_destroy;
362
 
 
363
 
    struct {
364
 
      smx_action_t comm;
365
 
    } comm_cancel;
366
 
 
367
 
    struct {
368
 
      xbt_dynar_t comms;
369
 
      unsigned int result;
370
 
    } comm_waitany;
371
 
 
372
 
    struct {
373
 
      smx_action_t comm;
374
 
      double timeout;
375
 
    } comm_wait;
376
 
 
377
 
    struct {
378
 
      smx_action_t comm;
379
 
      int result;
380
 
    } comm_test;
381
 
 
382
 
    struct {
383
 
      xbt_dynar_t comms;
384
 
      int result;
385
 
    } comm_testany;
386
 
 
387
 
    struct {
388
 
      smx_action_t comm;
389
 
      double result;
390
 
    } comm_get_remains;
391
 
 
392
 
    struct {
393
 
      smx_action_t comm;
394
 
      e_smx_state_t result;
395
 
    } comm_get_state;
396
 
 
397
 
    struct {
398
 
      smx_action_t comm;
399
 
      void *result;
400
 
    } comm_get_src_data;
401
 
 
402
 
    struct {
403
 
      smx_action_t comm;
404
 
      void *result;
405
 
    } comm_get_dst_data;
406
 
 
407
 
    struct {
408
 
      smx_action_t comm;
409
 
      smx_process_t result;
410
 
    } comm_get_src_proc;
411
 
 
412
 
    struct {
413
 
      smx_action_t comm;
414
 
      smx_process_t result;
415
 
    } comm_get_dst_proc;
416
 
 
417
 
#ifdef HAVE_LATENCY_BOUND_TRACKING
418
 
    struct {
419
 
      smx_action_t comm;
420
 
      int result;
421
 
    } comm_is_latency_bounded;
422
 
#endif
423
 
 
424
 
#ifdef HAVE_TRACING
425
 
    struct {
426
 
      smx_action_t action;
427
 
      const char *category;
428
 
    } set_category;
429
 
#endif
430
 
 
431
 
    struct {
432
 
      smx_mutex_t result;
433
 
    } mutex_init;
434
 
 
435
 
    struct {
436
 
      smx_mutex_t mutex;
437
 
    } mutex_lock;
438
 
 
439
 
    struct {
440
 
      smx_mutex_t mutex;
441
 
      int result;
442
 
    } mutex_trylock;
443
 
 
444
 
    struct {
445
 
      smx_mutex_t mutex;
446
 
    } mutex_unlock;
447
 
 
448
 
    struct {
449
 
      smx_mutex_t mutex;
450
 
    } mutex_destroy;
451
 
 
452
 
    struct {
453
 
      smx_cond_t result;
454
 
    } cond_init;
455
 
 
456
 
    struct {
457
 
      smx_cond_t cond;
458
 
    } cond_destroy;
459
 
 
460
 
    struct {
461
 
      smx_cond_t cond;
462
 
    } cond_signal;
463
 
 
464
 
    struct {
465
 
      smx_cond_t cond;
466
 
      smx_mutex_t mutex;
467
 
    } cond_wait;
468
 
 
469
 
    struct {
470
 
      smx_cond_t cond;
471
 
      smx_mutex_t mutex;
472
 
      double timeout;
473
 
    } cond_wait_timeout;
474
 
 
475
 
    struct {
476
 
      smx_cond_t cond;
477
 
    } cond_broadcast;
478
 
 
479
 
    struct {
480
 
      int capacity;
481
 
      smx_sem_t result;
482
 
    } sem_init;
483
 
 
484
 
    struct {
485
 
      smx_sem_t sem;
486
 
    } sem_destroy;
487
 
 
488
 
    struct {
489
 
      smx_sem_t sem;
490
 
    } sem_release;
491
 
 
492
 
    struct {
493
 
      smx_sem_t sem;
494
 
      int result;
495
 
    } sem_would_block;
496
 
 
497
 
    struct {
498
 
      smx_sem_t sem;
499
 
    } sem_acquire;
500
 
 
501
 
    struct {
502
 
      smx_sem_t sem;
503
 
      double timeout;
504
 
    } sem_acquire_timeout;
505
 
 
506
 
    struct {
507
 
      smx_sem_t sem;
508
 
      int result;
509
 
    } sem_get_capacity;
510
 
 
511
 
    struct {
512
 
      const char* storage;
513
 
      void *ptr;
514
 
      size_t size;
515
 
      size_t nmemb;
516
 
      smx_file_t stream;
517
 
      size_t result;
518
 
    } file_read;
519
 
 
520
 
    struct {
521
 
      const char* storage;
522
 
      const void *ptr;
523
 
      size_t size;
524
 
      size_t nmemb;
525
 
      smx_file_t stream;
526
 
      size_t result;
527
 
    } file_write;
528
 
 
529
 
    struct {
530
 
      const char* storage;
531
 
      const char* path;
532
 
      const char* mode;
533
 
      smx_file_t result;
534
 
    } file_open;
535
 
 
536
 
    struct {
537
 
      const char* storage;
538
 
      smx_file_t fp;
539
 
      int result;
540
 
    } file_close;
541
 
 
542
 
    struct {
543
 
      const char* storage;
544
 
      smx_file_t fd;
545
 
      s_file_stat_t buf;
546
 
      int result;
547
 
    } file_stat;
 
424
    struct {
 
425
      const char* param1;
 
426
      double param2;
 
427
      int result;
 
428
    } new_api;
548
429
 
549
430
  };
550
431
} s_smx_simcall_t, *smx_simcall_t;
551
432
 
 
433
SIMCALL_LIST(SIMCALL_RES_GETSET, SIMCALL_SEP_NOTHING)
 
434
SIMCALL_LIST(SIMCALL_ARG_GETSET, SIMCALL_SEP_NOTHING)
 
435
 
552
436
/******************************** General *************************************/
553
437
 
554
438
void SIMIX_simcall_push(smx_process_t self);
557
441
void SIMIX_simcall_post(smx_action_t);
558
442
smx_simcall_t SIMIX_simcall_mine(void);
559
443
const char *SIMIX_simcall_name(e_smx_simcall_t kind);
 
444
//TOFIX put it in a better place
 
445
xbt_dict_t SIMIX_pre_asr_get_properties(smx_simcall_t simcall, const char *name);
 
446
 
 
447
/*************************** New simcall interface ****************************/
 
448
 
 
449
smx_simcall_t __SIMIX_simcall(e_smx_simcall_t simcall_id, u_smx_scalar_t *args);
 
450
 
 
451
typedef smx_action_t (*simcall_handler_t)(u_smx_scalar_t *);
 
452
 
 
453
extern const char *simcall_types[];
 
454
extern simcall_handler_t simcall_table[];
560
455
 
561
456
#endif
562
457