Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
[popping] allow to omit the handler
[simgrid.git] / src / simix / popping_accessors.h
1 /**********************************************************************/
2 /* File generated by src/simix/simcalls.py from src/simix/simcalls.in */
3 /*                                                                    */
4 /*                    DO NOT EVER CHANGE THIS FILE                    */
5 /*                                                                    */
6 /* change simcalls specification in src/simix/simcalls.in             */
7 /**********************************************************************/
8
9 /*
10  * Note that the name comes from http://en.wikipedia.org/wiki/Popping
11  * Indeed, the control flow is doing a strange dance in there.
12  *
13  * That's not about http://en.wikipedia.org/wiki/Poop, despite the odor :)
14  */
15
16
17 static inline const char* simcall_host_get_by_name__get__name(smx_simcall_t simcall) {
18   return  simcall->args[0].cc;
19 }
20 static inline void simcall_host_get_by_name__set__name(smx_simcall_t simcall, const char* arg) {
21     simcall->args[0].cc = arg;
22 }
23 static inline smx_host_t simcall_host_get_by_name__get__result(smx_simcall_t simcall){
24     return (smx_host_t) simcall->result.dp;
25 }
26 static inline void simcall_host_get_by_name__set__result(smx_simcall_t simcall, void* result){
27     simcall->result.dp = result;
28 }
29
30 static inline smx_host_t simcall_host_get_name__get__host(smx_simcall_t simcall) {
31   return (smx_host_t) simcall->args[0].dp;
32 }
33 static inline void simcall_host_get_name__set__host(smx_simcall_t simcall, void* arg) {
34     simcall->args[0].dp = arg;
35 }
36 static inline const char* simcall_host_get_name__get__result(smx_simcall_t simcall){
37     return  simcall->result.cc;
38 }
39 static inline void simcall_host_get_name__set__result(smx_simcall_t simcall, const char* result){
40     simcall->result.cc = result;
41 }
42
43 static inline smx_host_t simcall_host_on__get__host(smx_simcall_t simcall) {
44   return (smx_host_t) simcall->args[0].dp;
45 }
46 static inline void simcall_host_on__set__host(smx_simcall_t simcall, void* arg) {
47     simcall->args[0].dp = arg;
48 }
49
50 static inline smx_host_t simcall_host_off__get__host(smx_simcall_t simcall) {
51   return (smx_host_t) simcall->args[0].dp;
52 }
53 static inline void simcall_host_off__set__host(smx_simcall_t simcall, void* arg) {
54     simcall->args[0].dp = arg;
55 }
56
57 static inline smx_host_t simcall_host_get_properties__get__host(smx_simcall_t simcall) {
58   return (smx_host_t) simcall->args[0].dp;
59 }
60 static inline void simcall_host_get_properties__set__host(smx_simcall_t simcall, void* arg) {
61     simcall->args[0].dp = arg;
62 }
63 static inline xbt_dict_t simcall_host_get_properties__get__result(smx_simcall_t simcall){
64     return (xbt_dict_t) simcall->result.dp;
65 }
66 static inline void simcall_host_get_properties__set__result(smx_simcall_t simcall, void* result){
67     simcall->result.dp = result;
68 }
69
70 static inline smx_host_t simcall_host_get_core__get__host(smx_simcall_t simcall) {
71   return (smx_host_t) simcall->args[0].dp;
72 }
73 static inline void simcall_host_get_core__set__host(smx_simcall_t simcall, void* arg) {
74     simcall->args[0].dp = arg;
75 }
76 static inline int simcall_host_get_core__get__result(smx_simcall_t simcall){
77     return  simcall->result.i;
78 }
79 static inline void simcall_host_get_core__set__result(smx_simcall_t simcall, int result){
80     simcall->result.i = result;
81 }
82
83 static inline smx_host_t simcall_host_get_process_list__get__host(smx_simcall_t simcall) {
84   return (smx_host_t) simcall->args[0].dp;
85 }
86 static inline void simcall_host_get_process_list__set__host(smx_simcall_t simcall, void* arg) {
87     simcall->args[0].dp = arg;
88 }
89 static inline xbt_swag_t simcall_host_get_process_list__get__result(smx_simcall_t simcall){
90     return (xbt_swag_t) simcall->result.dp;
91 }
92 static inline void simcall_host_get_process_list__set__result(smx_simcall_t simcall, void* result){
93     simcall->result.dp = result;
94 }
95
96 static inline smx_host_t simcall_host_get_speed__get__host(smx_simcall_t simcall) {
97   return (smx_host_t) simcall->args[0].dp;
98 }
99 static inline void simcall_host_get_speed__set__host(smx_simcall_t simcall, void* arg) {
100     simcall->args[0].dp = arg;
101 }
102 static inline double simcall_host_get_speed__get__result(smx_simcall_t simcall){
103     return  simcall->result.d;
104 }
105 static inline void simcall_host_get_speed__set__result(smx_simcall_t simcall, double result){
106     simcall->result.d = result;
107 }
108
109 static inline smx_host_t simcall_host_get_available_speed__get__host(smx_simcall_t simcall) {
110   return (smx_host_t) simcall->args[0].dp;
111 }
112 static inline void simcall_host_get_available_speed__set__host(smx_simcall_t simcall, void* arg) {
113     simcall->args[0].dp = arg;
114 }
115 static inline double simcall_host_get_available_speed__get__result(smx_simcall_t simcall){
116     return  simcall->result.d;
117 }
118 static inline void simcall_host_get_available_speed__set__result(smx_simcall_t simcall, double result){
119     simcall->result.d = result;
120 }
121
122 static inline smx_host_t simcall_host_get_state__get__host(smx_simcall_t simcall) {
123   return (smx_host_t) simcall->args[0].dp;
124 }
125 static inline void simcall_host_get_state__set__host(smx_simcall_t simcall, void* arg) {
126     simcall->args[0].dp = arg;
127 }
128 static inline int simcall_host_get_state__get__result(smx_simcall_t simcall){
129     return  simcall->result.i;
130 }
131 static inline void simcall_host_get_state__set__result(smx_simcall_t simcall, int result){
132     simcall->result.i = result;
133 }
134
135 static inline smx_host_t simcall_host_get_current_power_peak__get__host(smx_simcall_t simcall) {
136   return (smx_host_t) simcall->args[0].dp;
137 }
138 static inline void simcall_host_get_current_power_peak__set__host(smx_simcall_t simcall, void* arg) {
139     simcall->args[0].dp = arg;
140 }
141 static inline double simcall_host_get_current_power_peak__get__result(smx_simcall_t simcall){
142     return  simcall->result.d;
143 }
144 static inline void simcall_host_get_current_power_peak__set__result(smx_simcall_t simcall, double result){
145     simcall->result.d = result;
146 }
147
148 static inline smx_host_t simcall_host_get_power_peak_at__get__host(smx_simcall_t simcall) {
149   return (smx_host_t) simcall->args[0].dp;
150 }
151 static inline void simcall_host_get_power_peak_at__set__host(smx_simcall_t simcall, void* arg) {
152     simcall->args[0].dp = arg;
153 }
154 static inline int simcall_host_get_power_peak_at__get__pstate_index(smx_simcall_t simcall) {
155   return  simcall->args[1].i;
156 }
157 static inline void simcall_host_get_power_peak_at__set__pstate_index(smx_simcall_t simcall, int arg) {
158     simcall->args[1].i = arg;
159 }
160 static inline double simcall_host_get_power_peak_at__get__result(smx_simcall_t simcall){
161     return  simcall->result.d;
162 }
163 static inline void simcall_host_get_power_peak_at__set__result(smx_simcall_t simcall, double result){
164     simcall->result.d = result;
165 }
166
167 static inline smx_host_t simcall_host_get_nb_pstates__get__host(smx_simcall_t simcall) {
168   return (smx_host_t) simcall->args[0].dp;
169 }
170 static inline void simcall_host_get_nb_pstates__set__host(smx_simcall_t simcall, void* arg) {
171     simcall->args[0].dp = arg;
172 }
173 static inline int simcall_host_get_nb_pstates__get__result(smx_simcall_t simcall){
174     return  simcall->result.i;
175 }
176 static inline void simcall_host_get_nb_pstates__set__result(smx_simcall_t simcall, int result){
177     simcall->result.i = result;
178 }
179
180 static inline smx_host_t simcall_host_set_power_peak_at__get__host(smx_simcall_t simcall) {
181   return (smx_host_t) simcall->args[0].dp;
182 }
183 static inline void simcall_host_set_power_peak_at__set__host(smx_simcall_t simcall, void* arg) {
184     simcall->args[0].dp = arg;
185 }
186 static inline int simcall_host_set_power_peak_at__get__pstate_index(smx_simcall_t simcall) {
187   return  simcall->args[1].i;
188 }
189 static inline void simcall_host_set_power_peak_at__set__pstate_index(smx_simcall_t simcall, int arg) {
190     simcall->args[1].i = arg;
191 }
192
193 static inline smx_host_t simcall_host_get_consumed_energy__get__host(smx_simcall_t simcall) {
194   return (smx_host_t) simcall->args[0].dp;
195 }
196 static inline void simcall_host_get_consumed_energy__set__host(smx_simcall_t simcall, void* arg) {
197     simcall->args[0].dp = arg;
198 }
199 static inline double simcall_host_get_consumed_energy__get__result(smx_simcall_t simcall){
200     return  simcall->result.d;
201 }
202 static inline void simcall_host_get_consumed_energy__set__result(smx_simcall_t simcall, double result){
203     simcall->result.d = result;
204 }
205
206 static inline const char* simcall_host_execute__get__name(smx_simcall_t simcall) {
207   return  simcall->args[0].cc;
208 }
209 static inline void simcall_host_execute__set__name(smx_simcall_t simcall, const char* arg) {
210     simcall->args[0].cc = arg;
211 }
212 static inline smx_host_t simcall_host_execute__get__host(smx_simcall_t simcall) {
213   return (smx_host_t) simcall->args[1].dp;
214 }
215 static inline void simcall_host_execute__set__host(smx_simcall_t simcall, void* arg) {
216     simcall->args[1].dp = arg;
217 }
218 static inline double simcall_host_execute__get__computation_amount(smx_simcall_t simcall) {
219   return  simcall->args[2].d;
220 }
221 static inline void simcall_host_execute__set__computation_amount(smx_simcall_t simcall, double arg) {
222     simcall->args[2].d = arg;
223 }
224 static inline double simcall_host_execute__get__priority(smx_simcall_t simcall) {
225   return  simcall->args[3].d;
226 }
227 static inline void simcall_host_execute__set__priority(smx_simcall_t simcall, double arg) {
228     simcall->args[3].d = arg;
229 }
230 static inline double simcall_host_execute__get__bound(smx_simcall_t simcall) {
231   return  simcall->args[4].d;
232 }
233 static inline void simcall_host_execute__set__bound(smx_simcall_t simcall, double arg) {
234     simcall->args[4].d = arg;
235 }
236 static inline unsigned long simcall_host_execute__get__affinity_mask(smx_simcall_t simcall) {
237   return  simcall->args[5].ul;
238 }
239 static inline void simcall_host_execute__set__affinity_mask(smx_simcall_t simcall, unsigned long arg) {
240     simcall->args[5].ul = arg;
241 }
242 static inline smx_synchro_t simcall_host_execute__get__result(smx_simcall_t simcall){
243     return (smx_synchro_t) simcall->result.dp;
244 }
245 static inline void simcall_host_execute__set__result(smx_simcall_t simcall, void* result){
246     simcall->result.dp = result;
247 }
248
249 static inline const char* simcall_host_parallel_execute__get__name(smx_simcall_t simcall) {
250   return  simcall->args[0].cc;
251 }
252 static inline void simcall_host_parallel_execute__set__name(smx_simcall_t simcall, const char* arg) {
253     simcall->args[0].cc = arg;
254 }
255 static inline int simcall_host_parallel_execute__get__host_nb(smx_simcall_t simcall) {
256   return  simcall->args[1].i;
257 }
258 static inline void simcall_host_parallel_execute__set__host_nb(smx_simcall_t simcall, int arg) {
259     simcall->args[1].i = arg;
260 }
261 static inline smx_host_t* simcall_host_parallel_execute__get__host_list(smx_simcall_t simcall) {
262   return (smx_host_t*) simcall->args[2].dp;
263 }
264 static inline void simcall_host_parallel_execute__set__host_list(smx_simcall_t simcall, void* arg) {
265     simcall->args[2].dp = arg;
266 }
267 static inline double* simcall_host_parallel_execute__get__computation_amount(smx_simcall_t simcall) {
268   return (double*) simcall->args[3].dp;
269 }
270 static inline void simcall_host_parallel_execute__set__computation_amount(smx_simcall_t simcall, void* arg) {
271     simcall->args[3].dp = arg;
272 }
273 static inline double* simcall_host_parallel_execute__get__communication_amount(smx_simcall_t simcall) {
274   return (double*) simcall->args[4].dp;
275 }
276 static inline void simcall_host_parallel_execute__set__communication_amount(smx_simcall_t simcall, void* arg) {
277     simcall->args[4].dp = arg;
278 }
279 static inline double simcall_host_parallel_execute__get__amount(smx_simcall_t simcall) {
280   return  simcall->args[5].d;
281 }
282 static inline void simcall_host_parallel_execute__set__amount(smx_simcall_t simcall, double arg) {
283     simcall->args[5].d = arg;
284 }
285 static inline double simcall_host_parallel_execute__get__rate(smx_simcall_t simcall) {
286   return  simcall->args[6].d;
287 }
288 static inline void simcall_host_parallel_execute__set__rate(smx_simcall_t simcall, double arg) {
289     simcall->args[6].d = arg;
290 }
291 static inline smx_synchro_t simcall_host_parallel_execute__get__result(smx_simcall_t simcall){
292     return (smx_synchro_t) simcall->result.dp;
293 }
294 static inline void simcall_host_parallel_execute__set__result(smx_simcall_t simcall, void* result){
295     simcall->result.dp = result;
296 }
297
298 static inline smx_synchro_t simcall_host_execution_destroy__get__execution(smx_simcall_t simcall) {
299   return (smx_synchro_t) simcall->args[0].dp;
300 }
301 static inline void simcall_host_execution_destroy__set__execution(smx_simcall_t simcall, void* arg) {
302     simcall->args[0].dp = arg;
303 }
304
305 static inline smx_synchro_t simcall_host_execution_cancel__get__execution(smx_simcall_t simcall) {
306   return (smx_synchro_t) simcall->args[0].dp;
307 }
308 static inline void simcall_host_execution_cancel__set__execution(smx_simcall_t simcall, void* arg) {
309     simcall->args[0].dp = arg;
310 }
311
312 static inline smx_synchro_t simcall_host_execution_get_remains__get__execution(smx_simcall_t simcall) {
313   return (smx_synchro_t) simcall->args[0].dp;
314 }
315 static inline void simcall_host_execution_get_remains__set__execution(smx_simcall_t simcall, void* arg) {
316     simcall->args[0].dp = arg;
317 }
318 static inline double simcall_host_execution_get_remains__get__result(smx_simcall_t simcall){
319     return  simcall->result.d;
320 }
321 static inline void simcall_host_execution_get_remains__set__result(smx_simcall_t simcall, double result){
322     simcall->result.d = result;
323 }
324
325 static inline smx_synchro_t simcall_host_execution_get_state__get__execution(smx_simcall_t simcall) {
326   return (smx_synchro_t) simcall->args[0].dp;
327 }
328 static inline void simcall_host_execution_get_state__set__execution(smx_simcall_t simcall, void* arg) {
329     simcall->args[0].dp = arg;
330 }
331 static inline e_smx_state_t simcall_host_execution_get_state__get__result(smx_simcall_t simcall){
332     return (e_smx_state_t) simcall->result.i;
333 }
334 static inline void simcall_host_execution_get_state__set__result(smx_simcall_t simcall, int result){
335     simcall->result.i = result;
336 }
337
338 static inline smx_synchro_t simcall_host_execution_set_priority__get__execution(smx_simcall_t simcall) {
339   return (smx_synchro_t) simcall->args[0].dp;
340 }
341 static inline void simcall_host_execution_set_priority__set__execution(smx_simcall_t simcall, void* arg) {
342     simcall->args[0].dp = arg;
343 }
344 static inline double simcall_host_execution_set_priority__get__priority(smx_simcall_t simcall) {
345   return  simcall->args[1].d;
346 }
347 static inline void simcall_host_execution_set_priority__set__priority(smx_simcall_t simcall, double arg) {
348     simcall->args[1].d = arg;
349 }
350
351 static inline smx_synchro_t simcall_host_execution_set_bound__get__execution(smx_simcall_t simcall) {
352   return (smx_synchro_t) simcall->args[0].dp;
353 }
354 static inline void simcall_host_execution_set_bound__set__execution(smx_simcall_t simcall, void* arg) {
355     simcall->args[0].dp = arg;
356 }
357 static inline double simcall_host_execution_set_bound__get__bound(smx_simcall_t simcall) {
358   return  simcall->args[1].d;
359 }
360 static inline void simcall_host_execution_set_bound__set__bound(smx_simcall_t simcall, double arg) {
361     simcall->args[1].d = arg;
362 }
363
364 static inline smx_synchro_t simcall_host_execution_set_affinity__get__execution(smx_simcall_t simcall) {
365   return (smx_synchro_t) simcall->args[0].dp;
366 }
367 static inline void simcall_host_execution_set_affinity__set__execution(smx_simcall_t simcall, void* arg) {
368     simcall->args[0].dp = arg;
369 }
370 static inline smx_host_t simcall_host_execution_set_affinity__get__ws(smx_simcall_t simcall) {
371   return (smx_host_t) simcall->args[1].dp;
372 }
373 static inline void simcall_host_execution_set_affinity__set__ws(smx_simcall_t simcall, void* arg) {
374     simcall->args[1].dp = arg;
375 }
376 static inline unsigned long simcall_host_execution_set_affinity__get__mask(smx_simcall_t simcall) {
377   return  simcall->args[2].ul;
378 }
379 static inline void simcall_host_execution_set_affinity__set__mask(smx_simcall_t simcall, unsigned long arg) {
380     simcall->args[2].ul = arg;
381 }
382
383 static inline smx_synchro_t simcall_host_execution_wait__get__execution(smx_simcall_t simcall) {
384   return (smx_synchro_t) simcall->args[0].dp;
385 }
386 static inline void simcall_host_execution_wait__set__execution(smx_simcall_t simcall, void* arg) {
387     simcall->args[0].dp = arg;
388 }
389 static inline int simcall_host_execution_wait__get__result(smx_simcall_t simcall){
390     return  simcall->result.i;
391 }
392 static inline void simcall_host_execution_wait__set__result(smx_simcall_t simcall, int result){
393     simcall->result.i = result;
394 }
395
396 static inline smx_host_t simcall_host_get_mounted_storage_list__get__host(smx_simcall_t simcall) {
397   return (smx_host_t) simcall->args[0].dp;
398 }
399 static inline void simcall_host_get_mounted_storage_list__set__host(smx_simcall_t simcall, void* arg) {
400     simcall->args[0].dp = arg;
401 }
402 static inline xbt_dict_t simcall_host_get_mounted_storage_list__get__result(smx_simcall_t simcall){
403     return (xbt_dict_t) simcall->result.dp;
404 }
405 static inline void simcall_host_get_mounted_storage_list__set__result(smx_simcall_t simcall, void* result){
406     simcall->result.dp = result;
407 }
408
409 static inline smx_host_t simcall_host_get_attached_storage_list__get__host(smx_simcall_t simcall) {
410   return (smx_host_t) simcall->args[0].dp;
411 }
412 static inline void simcall_host_get_attached_storage_list__set__host(smx_simcall_t simcall, void* arg) {
413     simcall->args[0].dp = arg;
414 }
415 static inline xbt_dynar_t simcall_host_get_attached_storage_list__get__result(smx_simcall_t simcall){
416     return (xbt_dynar_t) simcall->result.dp;
417 }
418 static inline void simcall_host_get_attached_storage_list__set__result(smx_simcall_t simcall, void* result){
419     simcall->result.dp = result;
420 }
421
422 static inline smx_host_t simcall_host_get_params__get__ind_vm(smx_simcall_t simcall) {
423   return (smx_host_t) simcall->args[0].dp;
424 }
425 static inline void simcall_host_get_params__set__ind_vm(smx_simcall_t simcall, void* arg) {
426     simcall->args[0].dp = arg;
427 }
428 static inline ws_params_t simcall_host_get_params__get__params(smx_simcall_t simcall) {
429   return (ws_params_t) simcall->args[1].dp;
430 }
431 static inline void simcall_host_get_params__set__params(smx_simcall_t simcall, void* arg) {
432     simcall->args[1].dp = arg;
433 }
434
435 static inline smx_host_t simcall_host_set_params__get__ind_vm(smx_simcall_t simcall) {
436   return (smx_host_t) simcall->args[0].dp;
437 }
438 static inline void simcall_host_set_params__set__ind_vm(smx_simcall_t simcall, void* arg) {
439     simcall->args[0].dp = arg;
440 }
441 static inline ws_params_t simcall_host_set_params__get__params(smx_simcall_t simcall) {
442   return (ws_params_t) simcall->args[1].dp;
443 }
444 static inline void simcall_host_set_params__set__params(smx_simcall_t simcall, void* arg) {
445     simcall->args[1].dp = arg;
446 }
447
448 static inline const char* simcall_vm_create__get__name(smx_simcall_t simcall) {
449   return  simcall->args[0].cc;
450 }
451 static inline void simcall_vm_create__set__name(smx_simcall_t simcall, const char* arg) {
452     simcall->args[0].cc = arg;
453 }
454 static inline smx_host_t simcall_vm_create__get__ind_pm(smx_simcall_t simcall) {
455   return (smx_host_t) simcall->args[1].dp;
456 }
457 static inline void simcall_vm_create__set__ind_pm(smx_simcall_t simcall, void* arg) {
458     simcall->args[1].dp = arg;
459 }
460 static inline smx_host_t simcall_vm_create__get__result(smx_simcall_t simcall){
461     return (smx_host_t) simcall->result.dp;
462 }
463 static inline void simcall_vm_create__set__result(smx_simcall_t simcall, void* result){
464     simcall->result.dp = result;
465 }
466
467 static inline smx_host_t simcall_vm_start__get__ind_vm(smx_simcall_t simcall) {
468   return (smx_host_t) simcall->args[0].dp;
469 }
470 static inline void simcall_vm_start__set__ind_vm(smx_simcall_t simcall, void* arg) {
471     simcall->args[0].dp = arg;
472 }
473
474 static inline smx_host_t simcall_vm_get_state__get__ind_vm(smx_simcall_t simcall) {
475   return (smx_host_t) simcall->args[0].dp;
476 }
477 static inline void simcall_vm_get_state__set__ind_vm(smx_simcall_t simcall, void* arg) {
478     simcall->args[0].dp = arg;
479 }
480 static inline int simcall_vm_get_state__get__result(smx_simcall_t simcall){
481     return  simcall->result.i;
482 }
483 static inline void simcall_vm_get_state__set__result(smx_simcall_t simcall, int result){
484     simcall->result.i = result;
485 }
486
487 static inline smx_host_t simcall_vm_migrate__get__ind_vm(smx_simcall_t simcall) {
488   return (smx_host_t) simcall->args[0].dp;
489 }
490 static inline void simcall_vm_migrate__set__ind_vm(smx_simcall_t simcall, void* arg) {
491     simcall->args[0].dp = arg;
492 }
493 static inline smx_host_t simcall_vm_migrate__get__ind_dst_pm(smx_simcall_t simcall) {
494   return (smx_host_t) simcall->args[1].dp;
495 }
496 static inline void simcall_vm_migrate__set__ind_dst_pm(smx_simcall_t simcall, void* arg) {
497     simcall->args[1].dp = arg;
498 }
499
500 static inline smx_host_t simcall_vm_get_pm__get__ind_vm(smx_simcall_t simcall) {
501   return (smx_host_t) simcall->args[0].dp;
502 }
503 static inline void simcall_vm_get_pm__set__ind_vm(smx_simcall_t simcall, void* arg) {
504     simcall->args[0].dp = arg;
505 }
506 static inline void* simcall_vm_get_pm__get__result(smx_simcall_t simcall){
507     return  simcall->result.dp;
508 }
509 static inline void simcall_vm_get_pm__set__result(smx_simcall_t simcall, void* result){
510     simcall->result.dp = result;
511 }
512
513 static inline smx_host_t simcall_vm_set_bound__get__ind_vm(smx_simcall_t simcall) {
514   return (smx_host_t) simcall->args[0].dp;
515 }
516 static inline void simcall_vm_set_bound__set__ind_vm(smx_simcall_t simcall, void* arg) {
517     simcall->args[0].dp = arg;
518 }
519 static inline double simcall_vm_set_bound__get__bound(smx_simcall_t simcall) {
520   return  simcall->args[1].d;
521 }
522 static inline void simcall_vm_set_bound__set__bound(smx_simcall_t simcall, double arg) {
523     simcall->args[1].d = arg;
524 }
525
526 static inline smx_host_t simcall_vm_set_affinity__get__ind_vm(smx_simcall_t simcall) {
527   return (smx_host_t) simcall->args[0].dp;
528 }
529 static inline void simcall_vm_set_affinity__set__ind_vm(smx_simcall_t simcall, void* arg) {
530     simcall->args[0].dp = arg;
531 }
532 static inline smx_host_t simcall_vm_set_affinity__get__ind_pm(smx_simcall_t simcall) {
533   return (smx_host_t) simcall->args[1].dp;
534 }
535 static inline void simcall_vm_set_affinity__set__ind_pm(smx_simcall_t simcall, void* arg) {
536     simcall->args[1].dp = arg;
537 }
538 static inline unsigned long simcall_vm_set_affinity__get__mask(smx_simcall_t simcall) {
539   return  simcall->args[2].ul;
540 }
541 static inline void simcall_vm_set_affinity__set__mask(smx_simcall_t simcall, unsigned long arg) {
542     simcall->args[2].ul = arg;
543 }
544
545 static inline smx_host_t simcall_vm_destroy__get__ind_vm(smx_simcall_t simcall) {
546   return (smx_host_t) simcall->args[0].dp;
547 }
548 static inline void simcall_vm_destroy__set__ind_vm(smx_simcall_t simcall, void* arg) {
549     simcall->args[0].dp = arg;
550 }
551
552 static inline smx_host_t simcall_vm_suspend__get__ind_vm(smx_simcall_t simcall) {
553   return (smx_host_t) simcall->args[0].dp;
554 }
555 static inline void simcall_vm_suspend__set__ind_vm(smx_simcall_t simcall, void* arg) {
556     simcall->args[0].dp = arg;
557 }
558
559 static inline smx_host_t simcall_vm_resume__get__ind_vm(smx_simcall_t simcall) {
560   return (smx_host_t) simcall->args[0].dp;
561 }
562 static inline void simcall_vm_resume__set__ind_vm(smx_simcall_t simcall, void* arg) {
563     simcall->args[0].dp = arg;
564 }
565
566 static inline smx_host_t simcall_vm_shutdown__get__ind_vm(smx_simcall_t simcall) {
567   return (smx_host_t) simcall->args[0].dp;
568 }
569 static inline void simcall_vm_shutdown__set__ind_vm(smx_simcall_t simcall, void* arg) {
570     simcall->args[0].dp = arg;
571 }
572
573 static inline smx_host_t simcall_vm_save__get__ind_vm(smx_simcall_t simcall) {
574   return (smx_host_t) simcall->args[0].dp;
575 }
576 static inline void simcall_vm_save__set__ind_vm(smx_simcall_t simcall, void* arg) {
577     simcall->args[0].dp = arg;
578 }
579
580 static inline smx_host_t simcall_vm_restore__get__ind_vm(smx_simcall_t simcall) {
581   return (smx_host_t) simcall->args[0].dp;
582 }
583 static inline void simcall_vm_restore__set__ind_vm(smx_simcall_t simcall, void* arg) {
584     simcall->args[0].dp = arg;
585 }
586
587 static inline smx_process_t* simcall_process_create__get__process(smx_simcall_t simcall) {
588   return (smx_process_t*) simcall->args[0].dp;
589 }
590 static inline void simcall_process_create__set__process(smx_simcall_t simcall, void* arg) {
591     simcall->args[0].dp = arg;
592 }
593 static inline const char* simcall_process_create__get__name(smx_simcall_t simcall) {
594   return  simcall->args[1].cc;
595 }
596 static inline void simcall_process_create__set__name(smx_simcall_t simcall, const char* arg) {
597     simcall->args[1].cc = arg;
598 }
599 static inline xbt_main_func_t simcall_process_create__get__code(smx_simcall_t simcall) {
600   return (xbt_main_func_t) simcall->args[2].fp;
601 }
602 static inline void simcall_process_create__set__code(smx_simcall_t simcall, FPtr arg) {
603     simcall->args[2].fp = arg;
604 }
605 static inline void* simcall_process_create__get__data(smx_simcall_t simcall) {
606   return  simcall->args[3].dp;
607 }
608 static inline void simcall_process_create__set__data(smx_simcall_t simcall, void* arg) {
609     simcall->args[3].dp = arg;
610 }
611 static inline const char* simcall_process_create__get__hostname(smx_simcall_t simcall) {
612   return  simcall->args[4].cc;
613 }
614 static inline void simcall_process_create__set__hostname(smx_simcall_t simcall, const char* arg) {
615     simcall->args[4].cc = arg;
616 }
617 static inline double simcall_process_create__get__kill_time(smx_simcall_t simcall) {
618   return  simcall->args[5].d;
619 }
620 static inline void simcall_process_create__set__kill_time(smx_simcall_t simcall, double arg) {
621     simcall->args[5].d = arg;
622 }
623 static inline int simcall_process_create__get__argc(smx_simcall_t simcall) {
624   return  simcall->args[6].i;
625 }
626 static inline void simcall_process_create__set__argc(smx_simcall_t simcall, int arg) {
627     simcall->args[6].i = arg;
628 }
629 static inline char** simcall_process_create__get__argv(smx_simcall_t simcall) {
630   return (char**) simcall->args[7].dp;
631 }
632 static inline void simcall_process_create__set__argv(smx_simcall_t simcall, void* arg) {
633     simcall->args[7].dp = arg;
634 }
635 static inline xbt_dict_t simcall_process_create__get__properties(smx_simcall_t simcall) {
636   return (xbt_dict_t) simcall->args[8].dp;
637 }
638 static inline void simcall_process_create__set__properties(smx_simcall_t simcall, void* arg) {
639     simcall->args[8].dp = arg;
640 }
641 static inline int simcall_process_create__get__auto_restart(smx_simcall_t simcall) {
642   return  simcall->args[9].i;
643 }
644 static inline void simcall_process_create__set__auto_restart(smx_simcall_t simcall, int arg) {
645     simcall->args[9].i = arg;
646 }
647
648 static inline smx_process_t simcall_process_kill__get__process(smx_simcall_t simcall) {
649   return (smx_process_t) simcall->args[0].dp;
650 }
651 static inline void simcall_process_kill__set__process(smx_simcall_t simcall, void* arg) {
652     simcall->args[0].dp = arg;
653 }
654
655 static inline int simcall_process_killall__get__reset_pid(smx_simcall_t simcall) {
656   return  simcall->args[0].i;
657 }
658 static inline void simcall_process_killall__set__reset_pid(smx_simcall_t simcall, int arg) {
659     simcall->args[0].i = arg;
660 }
661
662 static inline smx_process_t simcall_process_cleanup__get__process(smx_simcall_t simcall) {
663   return (smx_process_t) simcall->args[0].dp;
664 }
665 static inline void simcall_process_cleanup__set__process(smx_simcall_t simcall, void* arg) {
666     simcall->args[0].dp = arg;
667 }
668
669 static inline smx_process_t simcall_process_change_host__get__process(smx_simcall_t simcall) {
670   return (smx_process_t) simcall->args[0].dp;
671 }
672 static inline void simcall_process_change_host__set__process(smx_simcall_t simcall, void* arg) {
673     simcall->args[0].dp = arg;
674 }
675 static inline smx_host_t simcall_process_change_host__get__dest(smx_simcall_t simcall) {
676   return (smx_host_t) simcall->args[1].dp;
677 }
678 static inline void simcall_process_change_host__set__dest(smx_simcall_t simcall, void* arg) {
679     simcall->args[1].dp = arg;
680 }
681
682 static inline smx_process_t simcall_process_suspend__get__process(smx_simcall_t simcall) {
683   return (smx_process_t) simcall->args[0].dp;
684 }
685 static inline void simcall_process_suspend__set__process(smx_simcall_t simcall, void* arg) {
686     simcall->args[0].dp = arg;
687 }
688
689 static inline smx_process_t simcall_process_resume__get__process(smx_simcall_t simcall) {
690   return (smx_process_t) simcall->args[0].dp;
691 }
692 static inline void simcall_process_resume__set__process(smx_simcall_t simcall, void* arg) {
693     simcall->args[0].dp = arg;
694 }
695
696 static inline int simcall_process_count__get__result(smx_simcall_t simcall){
697     return  simcall->result.i;
698 }
699 static inline void simcall_process_count__set__result(smx_simcall_t simcall, int result){
700     simcall->result.i = result;
701 }
702
703 static inline smx_process_t simcall_process_get_PID__get__process(smx_simcall_t simcall) {
704   return (smx_process_t) simcall->args[0].dp;
705 }
706 static inline void simcall_process_get_PID__set__process(smx_simcall_t simcall, void* arg) {
707     simcall->args[0].dp = arg;
708 }
709 static inline int simcall_process_get_PID__get__result(smx_simcall_t simcall){
710     return  simcall->result.i;
711 }
712 static inline void simcall_process_get_PID__set__result(smx_simcall_t simcall, int result){
713     simcall->result.i = result;
714 }
715
716 static inline smx_process_t simcall_process_get_PPID__get__process(smx_simcall_t simcall) {
717   return (smx_process_t) simcall->args[0].dp;
718 }
719 static inline void simcall_process_get_PPID__set__process(smx_simcall_t simcall, void* arg) {
720     simcall->args[0].dp = arg;
721 }
722 static inline int simcall_process_get_PPID__get__result(smx_simcall_t simcall){
723     return  simcall->result.i;
724 }
725 static inline void simcall_process_get_PPID__set__result(smx_simcall_t simcall, int result){
726     simcall->result.i = result;
727 }
728
729 static inline smx_process_t simcall_process_get_data__get__process(smx_simcall_t simcall) {
730   return (smx_process_t) simcall->args[0].dp;
731 }
732 static inline void simcall_process_get_data__set__process(smx_simcall_t simcall, void* arg) {
733     simcall->args[0].dp = arg;
734 }
735 static inline void* simcall_process_get_data__get__result(smx_simcall_t simcall){
736     return  simcall->result.dp;
737 }
738 static inline void simcall_process_get_data__set__result(smx_simcall_t simcall, void* result){
739     simcall->result.dp = result;
740 }
741
742 static inline smx_process_t simcall_process_set_data__get__process(smx_simcall_t simcall) {
743   return (smx_process_t) simcall->args[0].dp;
744 }
745 static inline void simcall_process_set_data__set__process(smx_simcall_t simcall, void* arg) {
746     simcall->args[0].dp = arg;
747 }
748 static inline void* simcall_process_set_data__get__data(smx_simcall_t simcall) {
749   return  simcall->args[1].dp;
750 }
751 static inline void simcall_process_set_data__set__data(smx_simcall_t simcall, void* arg) {
752     simcall->args[1].dp = arg;
753 }
754
755 static inline smx_process_t simcall_process_get_host__get__process(smx_simcall_t simcall) {
756   return (smx_process_t) simcall->args[0].dp;
757 }
758 static inline void simcall_process_get_host__set__process(smx_simcall_t simcall, void* arg) {
759     simcall->args[0].dp = arg;
760 }
761 static inline smx_host_t simcall_process_get_host__get__result(smx_simcall_t simcall){
762     return (smx_host_t) simcall->result.dp;
763 }
764 static inline void simcall_process_get_host__set__result(smx_simcall_t simcall, void* result){
765     simcall->result.dp = result;
766 }
767
768 static inline smx_process_t simcall_process_get_name__get__process(smx_simcall_t simcall) {
769   return (smx_process_t) simcall->args[0].dp;
770 }
771 static inline void simcall_process_get_name__set__process(smx_simcall_t simcall, void* arg) {
772     simcall->args[0].dp = arg;
773 }
774 static inline const char* simcall_process_get_name__get__result(smx_simcall_t simcall){
775     return  simcall->result.cc;
776 }
777 static inline void simcall_process_get_name__set__result(smx_simcall_t simcall, const char* result){
778     simcall->result.cc = result;
779 }
780
781 static inline smx_process_t simcall_process_is_suspended__get__process(smx_simcall_t simcall) {
782   return (smx_process_t) simcall->args[0].dp;
783 }
784 static inline void simcall_process_is_suspended__set__process(smx_simcall_t simcall, void* arg) {
785     simcall->args[0].dp = arg;
786 }
787 static inline int simcall_process_is_suspended__get__result(smx_simcall_t simcall){
788     return  simcall->result.i;
789 }
790 static inline void simcall_process_is_suspended__set__result(smx_simcall_t simcall, int result){
791     simcall->result.i = result;
792 }
793
794 static inline smx_process_t simcall_process_get_properties__get__process(smx_simcall_t simcall) {
795   return (smx_process_t) simcall->args[0].dp;
796 }
797 static inline void simcall_process_get_properties__set__process(smx_simcall_t simcall, void* arg) {
798     simcall->args[0].dp = arg;
799 }
800 static inline xbt_dict_t simcall_process_get_properties__get__result(smx_simcall_t simcall){
801     return (xbt_dict_t) simcall->result.dp;
802 }
803 static inline void simcall_process_get_properties__set__result(smx_simcall_t simcall, void* result){
804     simcall->result.dp = result;
805 }
806
807 static inline smx_process_t simcall_process_join__get__process(smx_simcall_t simcall) {
808   return (smx_process_t) simcall->args[0].dp;
809 }
810 static inline void simcall_process_join__set__process(smx_simcall_t simcall, void* arg) {
811     simcall->args[0].dp = arg;
812 }
813 static inline double simcall_process_join__get__timeout(smx_simcall_t simcall) {
814   return  simcall->args[1].d;
815 }
816 static inline void simcall_process_join__set__timeout(smx_simcall_t simcall, double arg) {
817     simcall->args[1].d = arg;
818 }
819 static inline int simcall_process_join__get__result(smx_simcall_t simcall){
820     return  simcall->result.i;
821 }
822 static inline void simcall_process_join__set__result(smx_simcall_t simcall, int result){
823     simcall->result.i = result;
824 }
825
826 static inline double simcall_process_sleep__get__duration(smx_simcall_t simcall) {
827   return  simcall->args[0].d;
828 }
829 static inline void simcall_process_sleep__set__duration(smx_simcall_t simcall, double arg) {
830     simcall->args[0].d = arg;
831 }
832 static inline int simcall_process_sleep__get__result(smx_simcall_t simcall){
833     return  simcall->result.i;
834 }
835 static inline void simcall_process_sleep__set__result(smx_simcall_t simcall, int result){
836     simcall->result.i = result;
837 }
838
839 static inline smx_process_t simcall_process_on_exit__get__process(smx_simcall_t simcall) {
840   return (smx_process_t) simcall->args[0].dp;
841 }
842 static inline void simcall_process_on_exit__set__process(smx_simcall_t simcall, void* arg) {
843     simcall->args[0].dp = arg;
844 }
845 static inline int_f_pvoid_pvoid_t simcall_process_on_exit__get__fun(smx_simcall_t simcall) {
846   return (int_f_pvoid_pvoid_t) simcall->args[1].fp;
847 }
848 static inline void simcall_process_on_exit__set__fun(smx_simcall_t simcall, FPtr arg) {
849     simcall->args[1].fp = arg;
850 }
851 static inline void* simcall_process_on_exit__get__data(smx_simcall_t simcall) {
852   return  simcall->args[2].dp;
853 }
854 static inline void simcall_process_on_exit__set__data(smx_simcall_t simcall, void* arg) {
855     simcall->args[2].dp = arg;
856 }
857
858 static inline smx_process_t simcall_process_auto_restart_set__get__process(smx_simcall_t simcall) {
859   return (smx_process_t) simcall->args[0].dp;
860 }
861 static inline void simcall_process_auto_restart_set__set__process(smx_simcall_t simcall, void* arg) {
862     simcall->args[0].dp = arg;
863 }
864 static inline int simcall_process_auto_restart_set__get__auto_restart(smx_simcall_t simcall) {
865   return  simcall->args[1].i;
866 }
867 static inline void simcall_process_auto_restart_set__set__auto_restart(smx_simcall_t simcall, int arg) {
868     simcall->args[1].i = arg;
869 }
870
871 static inline smx_process_t simcall_process_restart__get__process(smx_simcall_t simcall) {
872   return (smx_process_t) simcall->args[0].dp;
873 }
874 static inline void simcall_process_restart__set__process(smx_simcall_t simcall, void* arg) {
875     simcall->args[0].dp = arg;
876 }
877 static inline smx_process_t simcall_process_restart__get__result(smx_simcall_t simcall){
878     return (smx_process_t) simcall->result.dp;
879 }
880 static inline void simcall_process_restart__set__result(smx_simcall_t simcall, void* result){
881     simcall->result.dp = result;
882 }
883
884 static inline const char* simcall_rdv_create__get__name(smx_simcall_t simcall) {
885   return  simcall->args[0].cc;
886 }
887 static inline void simcall_rdv_create__set__name(smx_simcall_t simcall, const char* arg) {
888     simcall->args[0].cc = arg;
889 }
890 static inline smx_rdv_t simcall_rdv_create__get__result(smx_simcall_t simcall){
891     return (smx_rdv_t) simcall->result.dp;
892 }
893 static inline void simcall_rdv_create__set__result(smx_simcall_t simcall, void* result){
894     simcall->result.dp = result;
895 }
896
897 static inline smx_rdv_t simcall_rdv_destroy__get__rdv(smx_simcall_t simcall) {
898   return (smx_rdv_t) simcall->args[0].dp;
899 }
900 static inline void simcall_rdv_destroy__set__rdv(smx_simcall_t simcall, void* arg) {
901     simcall->args[0].dp = arg;
902 }
903
904 static inline smx_rdv_t simcall_rdv_comm_count_by_host__get__rdv(smx_simcall_t simcall) {
905   return (smx_rdv_t) simcall->args[0].dp;
906 }
907 static inline void simcall_rdv_comm_count_by_host__set__rdv(smx_simcall_t simcall, void* arg) {
908     simcall->args[0].dp = arg;
909 }
910 static inline smx_host_t simcall_rdv_comm_count_by_host__get__host(smx_simcall_t simcall) {
911   return (smx_host_t) simcall->args[1].dp;
912 }
913 static inline void simcall_rdv_comm_count_by_host__set__host(smx_simcall_t simcall, void* arg) {
914     simcall->args[1].dp = arg;
915 }
916 static inline unsigned int simcall_rdv_comm_count_by_host__get__result(smx_simcall_t simcall){
917     return  simcall->result.ui;
918 }
919 static inline void simcall_rdv_comm_count_by_host__set__result(smx_simcall_t simcall, unsigned int result){
920     simcall->result.ui = result;
921 }
922
923 static inline smx_rdv_t simcall_rdv_get_head__get__rdv(smx_simcall_t simcall) {
924   return (smx_rdv_t) simcall->args[0].dp;
925 }
926 static inline void simcall_rdv_get_head__set__rdv(smx_simcall_t simcall, void* arg) {
927     simcall->args[0].dp = arg;
928 }
929 static inline smx_synchro_t simcall_rdv_get_head__get__result(smx_simcall_t simcall){
930     return (smx_synchro_t) simcall->result.dp;
931 }
932 static inline void simcall_rdv_get_head__set__result(smx_simcall_t simcall, void* result){
933     simcall->result.dp = result;
934 }
935
936 static inline smx_rdv_t simcall_rdv_set_receiver__get__rdv(smx_simcall_t simcall) {
937   return (smx_rdv_t) simcall->args[0].dp;
938 }
939 static inline void simcall_rdv_set_receiver__set__rdv(smx_simcall_t simcall, void* arg) {
940     simcall->args[0].dp = arg;
941 }
942 static inline smx_process_t simcall_rdv_set_receiver__get__receiver(smx_simcall_t simcall) {
943   return (smx_process_t) simcall->args[1].dp;
944 }
945 static inline void simcall_rdv_set_receiver__set__receiver(smx_simcall_t simcall, void* arg) {
946     simcall->args[1].dp = arg;
947 }
948
949 static inline smx_rdv_t simcall_rdv_get_receiver__get__rdv(smx_simcall_t simcall) {
950   return (smx_rdv_t) simcall->args[0].dp;
951 }
952 static inline void simcall_rdv_get_receiver__set__rdv(smx_simcall_t simcall, void* arg) {
953     simcall->args[0].dp = arg;
954 }
955 static inline smx_process_t simcall_rdv_get_receiver__get__result(smx_simcall_t simcall){
956     return (smx_process_t) simcall->result.dp;
957 }
958 static inline void simcall_rdv_get_receiver__set__result(smx_simcall_t simcall, void* result){
959     simcall->result.dp = result;
960 }
961
962 static inline smx_rdv_t simcall_comm_iprobe__get__rdv(smx_simcall_t simcall) {
963   return (smx_rdv_t) simcall->args[0].dp;
964 }
965 static inline void simcall_comm_iprobe__set__rdv(smx_simcall_t simcall, void* arg) {
966     simcall->args[0].dp = arg;
967 }
968 static inline int simcall_comm_iprobe__get__type(smx_simcall_t simcall) {
969   return  simcall->args[1].i;
970 }
971 static inline void simcall_comm_iprobe__set__type(smx_simcall_t simcall, int arg) {
972     simcall->args[1].i = arg;
973 }
974 static inline int simcall_comm_iprobe__get__src(smx_simcall_t simcall) {
975   return  simcall->args[2].i;
976 }
977 static inline void simcall_comm_iprobe__set__src(smx_simcall_t simcall, int arg) {
978     simcall->args[2].i = arg;
979 }
980 static inline int simcall_comm_iprobe__get__tag(smx_simcall_t simcall) {
981   return  simcall->args[3].i;
982 }
983 static inline void simcall_comm_iprobe__set__tag(smx_simcall_t simcall, int arg) {
984     simcall->args[3].i = arg;
985 }
986 static inline simix_match_func_t simcall_comm_iprobe__get__match_fun(smx_simcall_t simcall) {
987   return (simix_match_func_t) simcall->args[4].fp;
988 }
989 static inline void simcall_comm_iprobe__set__match_fun(smx_simcall_t simcall, FPtr arg) {
990     simcall->args[4].fp = arg;
991 }
992 static inline void* simcall_comm_iprobe__get__data(smx_simcall_t simcall) {
993   return  simcall->args[5].dp;
994 }
995 static inline void simcall_comm_iprobe__set__data(smx_simcall_t simcall, void* arg) {
996     simcall->args[5].dp = arg;
997 }
998 static inline smx_synchro_t simcall_comm_iprobe__get__result(smx_simcall_t simcall){
999     return (smx_synchro_t) simcall->result.dp;
1000 }
1001 static inline void simcall_comm_iprobe__set__result(smx_simcall_t simcall, void* result){
1002     simcall->result.dp = result;
1003 }
1004
1005 static inline smx_process_t simcall_comm_send__get__src(smx_simcall_t simcall) {
1006   return (smx_process_t) simcall->args[0].dp;
1007 }
1008 static inline void simcall_comm_send__set__src(smx_simcall_t simcall, void* arg) {
1009     simcall->args[0].dp = arg;
1010 }
1011 static inline smx_rdv_t simcall_comm_send__get__rdv(smx_simcall_t simcall) {
1012   return (smx_rdv_t) simcall->args[1].dp;
1013 }
1014 static inline void simcall_comm_send__set__rdv(smx_simcall_t simcall, void* arg) {
1015     simcall->args[1].dp = arg;
1016 }
1017 static inline double simcall_comm_send__get__task_size(smx_simcall_t simcall) {
1018   return  simcall->args[2].d;
1019 }
1020 static inline void simcall_comm_send__set__task_size(smx_simcall_t simcall, double arg) {
1021     simcall->args[2].d = arg;
1022 }
1023 static inline double simcall_comm_send__get__rate(smx_simcall_t simcall) {
1024   return  simcall->args[3].d;
1025 }
1026 static inline void simcall_comm_send__set__rate(smx_simcall_t simcall, double arg) {
1027     simcall->args[3].d = arg;
1028 }
1029 static inline void* simcall_comm_send__get__src_buff(smx_simcall_t simcall) {
1030   return  simcall->args[4].dp;
1031 }
1032 static inline void simcall_comm_send__set__src_buff(smx_simcall_t simcall, void* arg) {
1033     simcall->args[4].dp = arg;
1034 }
1035 static inline size_t simcall_comm_send__get__src_buff_size(smx_simcall_t simcall) {
1036   return  simcall->args[5].sz;
1037 }
1038 static inline void simcall_comm_send__set__src_buff_size(smx_simcall_t simcall, size_t arg) {
1039     simcall->args[5].sz = arg;
1040 }
1041 static inline simix_match_func_t simcall_comm_send__get__match_fun(smx_simcall_t simcall) {
1042   return (simix_match_func_t) simcall->args[6].fp;
1043 }
1044 static inline void simcall_comm_send__set__match_fun(smx_simcall_t simcall, FPtr arg) {
1045     simcall->args[6].fp = arg;
1046 }
1047 static inline simix_copy_data_func_t simcall_comm_send__get__copy_data_fun(smx_simcall_t simcall) {
1048   return (simix_copy_data_func_t) simcall->args[7].fp;
1049 }
1050 static inline void simcall_comm_send__set__copy_data_fun(smx_simcall_t simcall, FPtr arg) {
1051     simcall->args[7].fp = arg;
1052 }
1053 static inline void* simcall_comm_send__get__data(smx_simcall_t simcall) {
1054   return  simcall->args[8].dp;
1055 }
1056 static inline void simcall_comm_send__set__data(smx_simcall_t simcall, void* arg) {
1057     simcall->args[8].dp = arg;
1058 }
1059 static inline double simcall_comm_send__get__timeout(smx_simcall_t simcall) {
1060   return  simcall->args[9].d;
1061 }
1062 static inline void simcall_comm_send__set__timeout(smx_simcall_t simcall, double arg) {
1063     simcall->args[9].d = arg;
1064 }
1065
1066 static inline smx_process_t simcall_comm_isend__get__src(smx_simcall_t simcall) {
1067   return (smx_process_t) simcall->args[0].dp;
1068 }
1069 static inline void simcall_comm_isend__set__src(smx_simcall_t simcall, void* arg) {
1070     simcall->args[0].dp = arg;
1071 }
1072 static inline smx_rdv_t simcall_comm_isend__get__rdv(smx_simcall_t simcall) {
1073   return (smx_rdv_t) simcall->args[1].dp;
1074 }
1075 static inline void simcall_comm_isend__set__rdv(smx_simcall_t simcall, void* arg) {
1076     simcall->args[1].dp = arg;
1077 }
1078 static inline double simcall_comm_isend__get__task_size(smx_simcall_t simcall) {
1079   return  simcall->args[2].d;
1080 }
1081 static inline void simcall_comm_isend__set__task_size(smx_simcall_t simcall, double arg) {
1082     simcall->args[2].d = arg;
1083 }
1084 static inline double simcall_comm_isend__get__rate(smx_simcall_t simcall) {
1085   return  simcall->args[3].d;
1086 }
1087 static inline void simcall_comm_isend__set__rate(smx_simcall_t simcall, double arg) {
1088     simcall->args[3].d = arg;
1089 }
1090 static inline void* simcall_comm_isend__get__src_buff(smx_simcall_t simcall) {
1091   return  simcall->args[4].dp;
1092 }
1093 static inline void simcall_comm_isend__set__src_buff(smx_simcall_t simcall, void* arg) {
1094     simcall->args[4].dp = arg;
1095 }
1096 static inline size_t simcall_comm_isend__get__src_buff_size(smx_simcall_t simcall) {
1097   return  simcall->args[5].sz;
1098 }
1099 static inline void simcall_comm_isend__set__src_buff_size(smx_simcall_t simcall, size_t arg) {
1100     simcall->args[5].sz = arg;
1101 }
1102 static inline simix_match_func_t simcall_comm_isend__get__match_fun(smx_simcall_t simcall) {
1103   return (simix_match_func_t) simcall->args[6].fp;
1104 }
1105 static inline void simcall_comm_isend__set__match_fun(smx_simcall_t simcall, FPtr arg) {
1106     simcall->args[6].fp = arg;
1107 }
1108 static inline simix_clean_func_t simcall_comm_isend__get__clean_fun(smx_simcall_t simcall) {
1109   return (simix_clean_func_t) simcall->args[7].fp;
1110 }
1111 static inline void simcall_comm_isend__set__clean_fun(smx_simcall_t simcall, FPtr arg) {
1112     simcall->args[7].fp = arg;
1113 }
1114 static inline simix_copy_data_func_t simcall_comm_isend__get__copy_data_fun(smx_simcall_t simcall) {
1115   return (simix_copy_data_func_t) simcall->args[8].fp;
1116 }
1117 static inline void simcall_comm_isend__set__copy_data_fun(smx_simcall_t simcall, FPtr arg) {
1118     simcall->args[8].fp = arg;
1119 }
1120 static inline void* simcall_comm_isend__get__data(smx_simcall_t simcall) {
1121   return  simcall->args[9].dp;
1122 }
1123 static inline void simcall_comm_isend__set__data(smx_simcall_t simcall, void* arg) {
1124     simcall->args[9].dp = arg;
1125 }
1126 static inline int simcall_comm_isend__get__detached(smx_simcall_t simcall) {
1127   return  simcall->args[10].i;
1128 }
1129 static inline void simcall_comm_isend__set__detached(smx_simcall_t simcall, int arg) {
1130     simcall->args[10].i = arg;
1131 }
1132 static inline smx_synchro_t simcall_comm_isend__get__result(smx_simcall_t simcall){
1133     return (smx_synchro_t) simcall->result.dp;
1134 }
1135 static inline void simcall_comm_isend__set__result(smx_simcall_t simcall, void* result){
1136     simcall->result.dp = result;
1137 }
1138
1139 static inline smx_rdv_t simcall_comm_recv__get__rdv(smx_simcall_t simcall) {
1140   return (smx_rdv_t) simcall->args[0].dp;
1141 }
1142 static inline void simcall_comm_recv__set__rdv(smx_simcall_t simcall, void* arg) {
1143     simcall->args[0].dp = arg;
1144 }
1145 static inline void* simcall_comm_recv__get__dst_buff(smx_simcall_t simcall) {
1146   return  simcall->args[1].dp;
1147 }
1148 static inline void simcall_comm_recv__set__dst_buff(smx_simcall_t simcall, void* arg) {
1149     simcall->args[1].dp = arg;
1150 }
1151 static inline size_t* simcall_comm_recv__get__dst_buff_size(smx_simcall_t simcall) {
1152   return (size_t*) simcall->args[2].dp;
1153 }
1154 static inline void simcall_comm_recv__set__dst_buff_size(smx_simcall_t simcall, void* arg) {
1155     simcall->args[2].dp = arg;
1156 }
1157 static inline simix_match_func_t simcall_comm_recv__get__match_fun(smx_simcall_t simcall) {
1158   return (simix_match_func_t) simcall->args[3].fp;
1159 }
1160 static inline void simcall_comm_recv__set__match_fun(smx_simcall_t simcall, FPtr arg) {
1161     simcall->args[3].fp = arg;
1162 }
1163 static inline simix_copy_data_func_t simcall_comm_recv__get__copy_data_fun(smx_simcall_t simcall) {
1164   return (simix_copy_data_func_t) simcall->args[4].fp;
1165 }
1166 static inline void simcall_comm_recv__set__copy_data_fun(smx_simcall_t simcall, FPtr arg) {
1167     simcall->args[4].fp = arg;
1168 }
1169 static inline void* simcall_comm_recv__get__data(smx_simcall_t simcall) {
1170   return  simcall->args[5].dp;
1171 }
1172 static inline void simcall_comm_recv__set__data(smx_simcall_t simcall, void* arg) {
1173     simcall->args[5].dp = arg;
1174 }
1175 static inline double simcall_comm_recv__get__timeout(smx_simcall_t simcall) {
1176   return  simcall->args[6].d;
1177 }
1178 static inline void simcall_comm_recv__set__timeout(smx_simcall_t simcall, double arg) {
1179     simcall->args[6].d = arg;
1180 }
1181 static inline double simcall_comm_recv__get__rate(smx_simcall_t simcall) {
1182   return  simcall->args[7].d;
1183 }
1184 static inline void simcall_comm_recv__set__rate(smx_simcall_t simcall, double arg) {
1185     simcall->args[7].d = arg;
1186 }
1187
1188 static inline smx_rdv_t simcall_comm_irecv__get__rdv(smx_simcall_t simcall) {
1189   return (smx_rdv_t) simcall->args[0].dp;
1190 }
1191 static inline void simcall_comm_irecv__set__rdv(smx_simcall_t simcall, void* arg) {
1192     simcall->args[0].dp = arg;
1193 }
1194 static inline void* simcall_comm_irecv__get__dst_buff(smx_simcall_t simcall) {
1195   return  simcall->args[1].dp;
1196 }
1197 static inline void simcall_comm_irecv__set__dst_buff(smx_simcall_t simcall, void* arg) {
1198     simcall->args[1].dp = arg;
1199 }
1200 static inline size_t* simcall_comm_irecv__get__dst_buff_size(smx_simcall_t simcall) {
1201   return (size_t*) simcall->args[2].dp;
1202 }
1203 static inline void simcall_comm_irecv__set__dst_buff_size(smx_simcall_t simcall, void* arg) {
1204     simcall->args[2].dp = arg;
1205 }
1206 static inline simix_match_func_t simcall_comm_irecv__get__match_fun(smx_simcall_t simcall) {
1207   return (simix_match_func_t) simcall->args[3].fp;
1208 }
1209 static inline void simcall_comm_irecv__set__match_fun(smx_simcall_t simcall, FPtr arg) {
1210     simcall->args[3].fp = arg;
1211 }
1212 static inline simix_copy_data_func_t simcall_comm_irecv__get__copy_data_fun(smx_simcall_t simcall) {
1213   return (simix_copy_data_func_t) simcall->args[4].fp;
1214 }
1215 static inline void simcall_comm_irecv__set__copy_data_fun(smx_simcall_t simcall, FPtr arg) {
1216     simcall->args[4].fp = arg;
1217 }
1218 static inline void* simcall_comm_irecv__get__data(smx_simcall_t simcall) {
1219   return  simcall->args[5].dp;
1220 }
1221 static inline void simcall_comm_irecv__set__data(smx_simcall_t simcall, void* arg) {
1222     simcall->args[5].dp = arg;
1223 }
1224 static inline double simcall_comm_irecv__get__rate(smx_simcall_t simcall) {
1225   return  simcall->args[6].d;
1226 }
1227 static inline void simcall_comm_irecv__set__rate(smx_simcall_t simcall, double arg) {
1228     simcall->args[6].d = arg;
1229 }
1230 static inline smx_synchro_t simcall_comm_irecv__get__result(smx_simcall_t simcall){
1231     return (smx_synchro_t) simcall->result.dp;
1232 }
1233 static inline void simcall_comm_irecv__set__result(smx_simcall_t simcall, void* result){
1234     simcall->result.dp = result;
1235 }
1236
1237 static inline smx_synchro_t simcall_comm_cancel__get__comm(smx_simcall_t simcall) {
1238   return (smx_synchro_t) simcall->args[0].dp;
1239 }
1240 static inline void simcall_comm_cancel__set__comm(smx_simcall_t simcall, void* arg) {
1241     simcall->args[0].dp = arg;
1242 }
1243
1244 static inline xbt_dynar_t simcall_comm_waitany__get__comms(smx_simcall_t simcall) {
1245   return (xbt_dynar_t) simcall->args[0].dp;
1246 }
1247 static inline void simcall_comm_waitany__set__comms(smx_simcall_t simcall, void* arg) {
1248     simcall->args[0].dp = arg;
1249 }
1250 static inline int simcall_comm_waitany__get__result(smx_simcall_t simcall){
1251     return  simcall->result.i;
1252 }
1253 static inline void simcall_comm_waitany__set__result(smx_simcall_t simcall, int result){
1254     simcall->result.i = result;
1255 }
1256
1257 static inline smx_synchro_t simcall_comm_wait__get__comm(smx_simcall_t simcall) {
1258   return (smx_synchro_t) simcall->args[0].dp;
1259 }
1260 static inline void simcall_comm_wait__set__comm(smx_simcall_t simcall, void* arg) {
1261     simcall->args[0].dp = arg;
1262 }
1263 static inline double simcall_comm_wait__get__timeout(smx_simcall_t simcall) {
1264   return  simcall->args[1].d;
1265 }
1266 static inline void simcall_comm_wait__set__timeout(smx_simcall_t simcall, double arg) {
1267     simcall->args[1].d = arg;
1268 }
1269
1270 static inline smx_synchro_t simcall_comm_test__get__comm(smx_simcall_t simcall) {
1271   return (smx_synchro_t) simcall->args[0].dp;
1272 }
1273 static inline void simcall_comm_test__set__comm(smx_simcall_t simcall, void* arg) {
1274     simcall->args[0].dp = arg;
1275 }
1276 static inline int simcall_comm_test__get__result(smx_simcall_t simcall){
1277     return  simcall->result.i;
1278 }
1279 static inline void simcall_comm_test__set__result(smx_simcall_t simcall, int result){
1280     simcall->result.i = result;
1281 }
1282
1283 static inline xbt_dynar_t simcall_comm_testany__get__comms(smx_simcall_t simcall) {
1284   return (xbt_dynar_t) simcall->args[0].dp;
1285 }
1286 static inline void simcall_comm_testany__set__comms(smx_simcall_t simcall, void* arg) {
1287     simcall->args[0].dp = arg;
1288 }
1289 static inline int simcall_comm_testany__get__result(smx_simcall_t simcall){
1290     return  simcall->result.i;
1291 }
1292 static inline void simcall_comm_testany__set__result(smx_simcall_t simcall, int result){
1293     simcall->result.i = result;
1294 }
1295
1296 static inline smx_synchro_t simcall_comm_get_remains__get__comm(smx_simcall_t simcall) {
1297   return (smx_synchro_t) simcall->args[0].dp;
1298 }
1299 static inline void simcall_comm_get_remains__set__comm(smx_simcall_t simcall, void* arg) {
1300     simcall->args[0].dp = arg;
1301 }
1302 static inline double simcall_comm_get_remains__get__result(smx_simcall_t simcall){
1303     return  simcall->result.d;
1304 }
1305 static inline void simcall_comm_get_remains__set__result(smx_simcall_t simcall, double result){
1306     simcall->result.d = result;
1307 }
1308
1309 static inline smx_synchro_t simcall_comm_get_state__get__comm(smx_simcall_t simcall) {
1310   return (smx_synchro_t) simcall->args[0].dp;
1311 }
1312 static inline void simcall_comm_get_state__set__comm(smx_simcall_t simcall, void* arg) {
1313     simcall->args[0].dp = arg;
1314 }
1315 static inline e_smx_state_t simcall_comm_get_state__get__result(smx_simcall_t simcall){
1316     return (e_smx_state_t) simcall->result.i;
1317 }
1318 static inline void simcall_comm_get_state__set__result(smx_simcall_t simcall, int result){
1319     simcall->result.i = result;
1320 }
1321
1322 static inline smx_synchro_t simcall_comm_get_src_data__get__comm(smx_simcall_t simcall) {
1323   return (smx_synchro_t) simcall->args[0].dp;
1324 }
1325 static inline void simcall_comm_get_src_data__set__comm(smx_simcall_t simcall, void* arg) {
1326     simcall->args[0].dp = arg;
1327 }
1328 static inline void* simcall_comm_get_src_data__get__result(smx_simcall_t simcall){
1329     return  simcall->result.dp;
1330 }
1331 static inline void simcall_comm_get_src_data__set__result(smx_simcall_t simcall, void* result){
1332     simcall->result.dp = result;
1333 }
1334
1335 static inline smx_synchro_t simcall_comm_get_dst_data__get__comm(smx_simcall_t simcall) {
1336   return (smx_synchro_t) simcall->args[0].dp;
1337 }
1338 static inline void simcall_comm_get_dst_data__set__comm(smx_simcall_t simcall, void* arg) {
1339     simcall->args[0].dp = arg;
1340 }
1341 static inline void* simcall_comm_get_dst_data__get__result(smx_simcall_t simcall){
1342     return  simcall->result.dp;
1343 }
1344 static inline void simcall_comm_get_dst_data__set__result(smx_simcall_t simcall, void* result){
1345     simcall->result.dp = result;
1346 }
1347
1348 static inline smx_synchro_t simcall_comm_get_src_proc__get__comm(smx_simcall_t simcall) {
1349   return (smx_synchro_t) simcall->args[0].dp;
1350 }
1351 static inline void simcall_comm_get_src_proc__set__comm(smx_simcall_t simcall, void* arg) {
1352     simcall->args[0].dp = arg;
1353 }
1354 static inline smx_process_t simcall_comm_get_src_proc__get__result(smx_simcall_t simcall){
1355     return (smx_process_t) simcall->result.dp;
1356 }
1357 static inline void simcall_comm_get_src_proc__set__result(smx_simcall_t simcall, void* result){
1358     simcall->result.dp = result;
1359 }
1360
1361 static inline smx_synchro_t simcall_comm_get_dst_proc__get__comm(smx_simcall_t simcall) {
1362   return (smx_synchro_t) simcall->args[0].dp;
1363 }
1364 static inline void simcall_comm_get_dst_proc__set__comm(smx_simcall_t simcall, void* arg) {
1365     simcall->args[0].dp = arg;
1366 }
1367 static inline smx_process_t simcall_comm_get_dst_proc__get__result(smx_simcall_t simcall){
1368     return (smx_process_t) simcall->result.dp;
1369 }
1370 static inline void simcall_comm_get_dst_proc__set__result(smx_simcall_t simcall, void* result){
1371     simcall->result.dp = result;
1372 }
1373
1374 static inline smx_mutex_t simcall_mutex_init__get__result(smx_simcall_t simcall){
1375     return (smx_mutex_t) simcall->result.dp;
1376 }
1377 static inline void simcall_mutex_init__set__result(smx_simcall_t simcall, void* result){
1378     simcall->result.dp = result;
1379 }
1380
1381 static inline smx_mutex_t simcall_mutex_destroy__get__mutex(smx_simcall_t simcall) {
1382   return (smx_mutex_t) simcall->args[0].dp;
1383 }
1384 static inline void simcall_mutex_destroy__set__mutex(smx_simcall_t simcall, void* arg) {
1385     simcall->args[0].dp = arg;
1386 }
1387
1388 static inline smx_mutex_t simcall_mutex_lock__get__mutex(smx_simcall_t simcall) {
1389   return (smx_mutex_t) simcall->args[0].dp;
1390 }
1391 static inline void simcall_mutex_lock__set__mutex(smx_simcall_t simcall, void* arg) {
1392     simcall->args[0].dp = arg;
1393 }
1394
1395 static inline smx_mutex_t simcall_mutex_trylock__get__mutex(smx_simcall_t simcall) {
1396   return (smx_mutex_t) simcall->args[0].dp;
1397 }
1398 static inline void simcall_mutex_trylock__set__mutex(smx_simcall_t simcall, void* arg) {
1399     simcall->args[0].dp = arg;
1400 }
1401 static inline int simcall_mutex_trylock__get__result(smx_simcall_t simcall){
1402     return  simcall->result.i;
1403 }
1404 static inline void simcall_mutex_trylock__set__result(smx_simcall_t simcall, int result){
1405     simcall->result.i = result;
1406 }
1407
1408 static inline smx_mutex_t simcall_mutex_unlock__get__mutex(smx_simcall_t simcall) {
1409   return (smx_mutex_t) simcall->args[0].dp;
1410 }
1411 static inline void simcall_mutex_unlock__set__mutex(smx_simcall_t simcall, void* arg) {
1412     simcall->args[0].dp = arg;
1413 }
1414
1415 static inline smx_cond_t simcall_cond_init__get__result(smx_simcall_t simcall){
1416     return (smx_cond_t) simcall->result.dp;
1417 }
1418 static inline void simcall_cond_init__set__result(smx_simcall_t simcall, void* result){
1419     simcall->result.dp = result;
1420 }
1421
1422 static inline smx_cond_t simcall_cond_destroy__get__cond(smx_simcall_t simcall) {
1423   return (smx_cond_t) simcall->args[0].dp;
1424 }
1425 static inline void simcall_cond_destroy__set__cond(smx_simcall_t simcall, void* arg) {
1426     simcall->args[0].dp = arg;
1427 }
1428
1429 static inline smx_cond_t simcall_cond_signal__get__cond(smx_simcall_t simcall) {
1430   return (smx_cond_t) simcall->args[0].dp;
1431 }
1432 static inline void simcall_cond_signal__set__cond(smx_simcall_t simcall, void* arg) {
1433     simcall->args[0].dp = arg;
1434 }
1435
1436 static inline smx_cond_t simcall_cond_wait__get__cond(smx_simcall_t simcall) {
1437   return (smx_cond_t) simcall->args[0].dp;
1438 }
1439 static inline void simcall_cond_wait__set__cond(smx_simcall_t simcall, void* arg) {
1440     simcall->args[0].dp = arg;
1441 }
1442 static inline smx_mutex_t simcall_cond_wait__get__mutex(smx_simcall_t simcall) {
1443   return (smx_mutex_t) simcall->args[1].dp;
1444 }
1445 static inline void simcall_cond_wait__set__mutex(smx_simcall_t simcall, void* arg) {
1446     simcall->args[1].dp = arg;
1447 }
1448
1449 static inline smx_cond_t simcall_cond_wait_timeout__get__cond(smx_simcall_t simcall) {
1450   return (smx_cond_t) simcall->args[0].dp;
1451 }
1452 static inline void simcall_cond_wait_timeout__set__cond(smx_simcall_t simcall, void* arg) {
1453     simcall->args[0].dp = arg;
1454 }
1455 static inline smx_mutex_t simcall_cond_wait_timeout__get__mutex(smx_simcall_t simcall) {
1456   return (smx_mutex_t) simcall->args[1].dp;
1457 }
1458 static inline void simcall_cond_wait_timeout__set__mutex(smx_simcall_t simcall, void* arg) {
1459     simcall->args[1].dp = arg;
1460 }
1461 static inline double simcall_cond_wait_timeout__get__timeout(smx_simcall_t simcall) {
1462   return  simcall->args[2].d;
1463 }
1464 static inline void simcall_cond_wait_timeout__set__timeout(smx_simcall_t simcall, double arg) {
1465     simcall->args[2].d = arg;
1466 }
1467
1468 static inline smx_cond_t simcall_cond_broadcast__get__cond(smx_simcall_t simcall) {
1469   return (smx_cond_t) simcall->args[0].dp;
1470 }
1471 static inline void simcall_cond_broadcast__set__cond(smx_simcall_t simcall, void* arg) {
1472     simcall->args[0].dp = arg;
1473 }
1474
1475 static inline unsigned int simcall_sem_init__get__capacity(smx_simcall_t simcall) {
1476   return  simcall->args[0].ui;
1477 }
1478 static inline void simcall_sem_init__set__capacity(smx_simcall_t simcall, unsigned int arg) {
1479     simcall->args[0].ui = arg;
1480 }
1481 static inline smx_sem_t simcall_sem_init__get__result(smx_simcall_t simcall){
1482     return (smx_sem_t) simcall->result.dp;
1483 }
1484 static inline void simcall_sem_init__set__result(smx_simcall_t simcall, void* result){
1485     simcall->result.dp = result;
1486 }
1487
1488 static inline smx_sem_t simcall_sem_destroy__get__sem(smx_simcall_t simcall) {
1489   return (smx_sem_t) simcall->args[0].dp;
1490 }
1491 static inline void simcall_sem_destroy__set__sem(smx_simcall_t simcall, void* arg) {
1492     simcall->args[0].dp = arg;
1493 }
1494
1495 static inline smx_sem_t simcall_sem_release__get__sem(smx_simcall_t simcall) {
1496   return (smx_sem_t) simcall->args[0].dp;
1497 }
1498 static inline void simcall_sem_release__set__sem(smx_simcall_t simcall, void* arg) {
1499     simcall->args[0].dp = arg;
1500 }
1501
1502 static inline smx_sem_t simcall_sem_would_block__get__sem(smx_simcall_t simcall) {
1503   return (smx_sem_t) simcall->args[0].dp;
1504 }
1505 static inline void simcall_sem_would_block__set__sem(smx_simcall_t simcall, void* arg) {
1506     simcall->args[0].dp = arg;
1507 }
1508 static inline int simcall_sem_would_block__get__result(smx_simcall_t simcall){
1509     return  simcall->result.i;
1510 }
1511 static inline void simcall_sem_would_block__set__result(smx_simcall_t simcall, int result){
1512     simcall->result.i = result;
1513 }
1514
1515 static inline smx_sem_t simcall_sem_acquire__get__sem(smx_simcall_t simcall) {
1516   return (smx_sem_t) simcall->args[0].dp;
1517 }
1518 static inline void simcall_sem_acquire__set__sem(smx_simcall_t simcall, void* arg) {
1519     simcall->args[0].dp = arg;
1520 }
1521
1522 static inline smx_sem_t simcall_sem_acquire_timeout__get__sem(smx_simcall_t simcall) {
1523   return (smx_sem_t) simcall->args[0].dp;
1524 }
1525 static inline void simcall_sem_acquire_timeout__set__sem(smx_simcall_t simcall, void* arg) {
1526     simcall->args[0].dp = arg;
1527 }
1528 static inline double simcall_sem_acquire_timeout__get__timeout(smx_simcall_t simcall) {
1529   return  simcall->args[1].d;
1530 }
1531 static inline void simcall_sem_acquire_timeout__set__timeout(smx_simcall_t simcall, double arg) {
1532     simcall->args[1].d = arg;
1533 }
1534
1535 static inline smx_sem_t simcall_sem_get_capacity__get__sem(smx_simcall_t simcall) {
1536   return (smx_sem_t) simcall->args[0].dp;
1537 }
1538 static inline void simcall_sem_get_capacity__set__sem(smx_simcall_t simcall, void* arg) {
1539     simcall->args[0].dp = arg;
1540 }
1541 static inline int simcall_sem_get_capacity__get__result(smx_simcall_t simcall){
1542     return  simcall->result.i;
1543 }
1544 static inline void simcall_sem_get_capacity__set__result(smx_simcall_t simcall, int result){
1545     simcall->result.i = result;
1546 }
1547
1548 static inline smx_file_t simcall_file_read__get__fd(smx_simcall_t simcall) {
1549   return (smx_file_t) simcall->args[0].dp;
1550 }
1551 static inline void simcall_file_read__set__fd(smx_simcall_t simcall, void* arg) {
1552     simcall->args[0].dp = arg;
1553 }
1554 static inline sg_size_t simcall_file_read__get__size(smx_simcall_t simcall) {
1555   return  simcall->args[1].sgsz;
1556 }
1557 static inline void simcall_file_read__set__size(smx_simcall_t simcall, sg_size_t arg) {
1558     simcall->args[1].sgsz = arg;
1559 }
1560 static inline smx_host_t simcall_file_read__get__host(smx_simcall_t simcall) {
1561   return (smx_host_t) simcall->args[2].dp;
1562 }
1563 static inline void simcall_file_read__set__host(smx_simcall_t simcall, void* arg) {
1564     simcall->args[2].dp = arg;
1565 }
1566 static inline sg_size_t simcall_file_read__get__result(smx_simcall_t simcall){
1567     return  simcall->result.sgsz;
1568 }
1569 static inline void simcall_file_read__set__result(smx_simcall_t simcall, sg_size_t result){
1570     simcall->result.sgsz = result;
1571 }
1572
1573 static inline smx_file_t simcall_file_write__get__fd(smx_simcall_t simcall) {
1574   return (smx_file_t) simcall->args[0].dp;
1575 }
1576 static inline void simcall_file_write__set__fd(smx_simcall_t simcall, void* arg) {
1577     simcall->args[0].dp = arg;
1578 }
1579 static inline sg_size_t simcall_file_write__get__size(smx_simcall_t simcall) {
1580   return  simcall->args[1].sgsz;
1581 }
1582 static inline void simcall_file_write__set__size(smx_simcall_t simcall, sg_size_t arg) {
1583     simcall->args[1].sgsz = arg;
1584 }
1585 static inline smx_host_t simcall_file_write__get__host(smx_simcall_t simcall) {
1586   return (smx_host_t) simcall->args[2].dp;
1587 }
1588 static inline void simcall_file_write__set__host(smx_simcall_t simcall, void* arg) {
1589     simcall->args[2].dp = arg;
1590 }
1591 static inline sg_size_t simcall_file_write__get__result(smx_simcall_t simcall){
1592     return  simcall->result.sgsz;
1593 }
1594 static inline void simcall_file_write__set__result(smx_simcall_t simcall, sg_size_t result){
1595     simcall->result.sgsz = result;
1596 }
1597
1598 static inline const char* simcall_file_open__get__fullpath(smx_simcall_t simcall) {
1599   return  simcall->args[0].cc;
1600 }
1601 static inline void simcall_file_open__set__fullpath(smx_simcall_t simcall, const char* arg) {
1602     simcall->args[0].cc = arg;
1603 }
1604 static inline smx_host_t simcall_file_open__get__host(smx_simcall_t simcall) {
1605   return (smx_host_t) simcall->args[1].dp;
1606 }
1607 static inline void simcall_file_open__set__host(smx_simcall_t simcall, void* arg) {
1608     simcall->args[1].dp = arg;
1609 }
1610 static inline smx_file_t simcall_file_open__get__result(smx_simcall_t simcall){
1611     return (smx_file_t) simcall->result.dp;
1612 }
1613 static inline void simcall_file_open__set__result(smx_simcall_t simcall, void* result){
1614     simcall->result.dp = result;
1615 }
1616
1617 static inline smx_file_t simcall_file_close__get__fd(smx_simcall_t simcall) {
1618   return (smx_file_t) simcall->args[0].dp;
1619 }
1620 static inline void simcall_file_close__set__fd(smx_simcall_t simcall, void* arg) {
1621     simcall->args[0].dp = arg;
1622 }
1623 static inline smx_host_t simcall_file_close__get__host(smx_simcall_t simcall) {
1624   return (smx_host_t) simcall->args[1].dp;
1625 }
1626 static inline void simcall_file_close__set__host(smx_simcall_t simcall, void* arg) {
1627     simcall->args[1].dp = arg;
1628 }
1629 static inline int simcall_file_close__get__result(smx_simcall_t simcall){
1630     return  simcall->result.i;
1631 }
1632 static inline void simcall_file_close__set__result(smx_simcall_t simcall, int result){
1633     simcall->result.i = result;
1634 }
1635
1636 static inline smx_file_t simcall_file_unlink__get__fd(smx_simcall_t simcall) {
1637   return (smx_file_t) simcall->args[0].dp;
1638 }
1639 static inline void simcall_file_unlink__set__fd(smx_simcall_t simcall, void* arg) {
1640     simcall->args[0].dp = arg;
1641 }
1642 static inline smx_host_t simcall_file_unlink__get__host(smx_simcall_t simcall) {
1643   return (smx_host_t) simcall->args[1].dp;
1644 }
1645 static inline void simcall_file_unlink__set__host(smx_simcall_t simcall, void* arg) {
1646     simcall->args[1].dp = arg;
1647 }
1648 static inline int simcall_file_unlink__get__result(smx_simcall_t simcall){
1649     return  simcall->result.i;
1650 }
1651 static inline void simcall_file_unlink__set__result(smx_simcall_t simcall, int result){
1652     simcall->result.i = result;
1653 }
1654
1655 static inline smx_file_t simcall_file_get_size__get__fd(smx_simcall_t simcall) {
1656   return (smx_file_t) simcall->args[0].dp;
1657 }
1658 static inline void simcall_file_get_size__set__fd(smx_simcall_t simcall, void* arg) {
1659     simcall->args[0].dp = arg;
1660 }
1661 static inline sg_size_t simcall_file_get_size__get__result(smx_simcall_t simcall){
1662     return  simcall->result.sgsz;
1663 }
1664 static inline void simcall_file_get_size__set__result(smx_simcall_t simcall, sg_size_t result){
1665     simcall->result.sgsz = result;
1666 }
1667
1668 static inline smx_file_t simcall_file_tell__get__fd(smx_simcall_t simcall) {
1669   return (smx_file_t) simcall->args[0].dp;
1670 }
1671 static inline void simcall_file_tell__set__fd(smx_simcall_t simcall, void* arg) {
1672     simcall->args[0].dp = arg;
1673 }
1674 static inline sg_size_t simcall_file_tell__get__result(smx_simcall_t simcall){
1675     return  simcall->result.sgsz;
1676 }
1677 static inline void simcall_file_tell__set__result(smx_simcall_t simcall, sg_size_t result){
1678     simcall->result.sgsz = result;
1679 }
1680
1681 static inline smx_file_t simcall_file_seek__get__fd(smx_simcall_t simcall) {
1682   return (smx_file_t) simcall->args[0].dp;
1683 }
1684 static inline void simcall_file_seek__set__fd(smx_simcall_t simcall, void* arg) {
1685     simcall->args[0].dp = arg;
1686 }
1687 static inline sg_offset_t simcall_file_seek__get__offset(smx_simcall_t simcall) {
1688   return  simcall->args[1].sgoff;
1689 }
1690 static inline void simcall_file_seek__set__offset(smx_simcall_t simcall, sg_offset_t arg) {
1691     simcall->args[1].sgoff = arg;
1692 }
1693 static inline int simcall_file_seek__get__origin(smx_simcall_t simcall) {
1694   return  simcall->args[2].i;
1695 }
1696 static inline void simcall_file_seek__set__origin(smx_simcall_t simcall, int arg) {
1697     simcall->args[2].i = arg;
1698 }
1699 static inline int simcall_file_seek__get__result(smx_simcall_t simcall){
1700     return  simcall->result.i;
1701 }
1702 static inline void simcall_file_seek__set__result(smx_simcall_t simcall, int result){
1703     simcall->result.i = result;
1704 }
1705
1706 static inline smx_file_t simcall_file_get_info__get__fd(smx_simcall_t simcall) {
1707   return (smx_file_t) simcall->args[0].dp;
1708 }
1709 static inline void simcall_file_get_info__set__fd(smx_simcall_t simcall, void* arg) {
1710     simcall->args[0].dp = arg;
1711 }
1712 static inline xbt_dynar_t simcall_file_get_info__get__result(smx_simcall_t simcall){
1713     return (xbt_dynar_t) simcall->result.dp;
1714 }
1715 static inline void simcall_file_get_info__set__result(smx_simcall_t simcall, void* result){
1716     simcall->result.dp = result;
1717 }
1718
1719 static inline smx_file_t simcall_file_move__get__fd(smx_simcall_t simcall) {
1720   return (smx_file_t) simcall->args[0].dp;
1721 }
1722 static inline void simcall_file_move__set__fd(smx_simcall_t simcall, void* arg) {
1723     simcall->args[0].dp = arg;
1724 }
1725 static inline const char* simcall_file_move__get__fullpath(smx_simcall_t simcall) {
1726   return  simcall->args[1].cc;
1727 }
1728 static inline void simcall_file_move__set__fullpath(smx_simcall_t simcall, const char* arg) {
1729     simcall->args[1].cc = arg;
1730 }
1731 static inline int simcall_file_move__get__result(smx_simcall_t simcall){
1732     return  simcall->result.i;
1733 }
1734 static inline void simcall_file_move__set__result(smx_simcall_t simcall, int result){
1735     simcall->result.i = result;
1736 }
1737
1738 static inline smx_storage_t simcall_storage_get_free_size__get__storage(smx_simcall_t simcall) {
1739   return (smx_storage_t) simcall->args[0].dp;
1740 }
1741 static inline void simcall_storage_get_free_size__set__storage(smx_simcall_t simcall, void* arg) {
1742     simcall->args[0].dp = arg;
1743 }
1744 static inline sg_size_t simcall_storage_get_free_size__get__result(smx_simcall_t simcall){
1745     return  simcall->result.sgsz;
1746 }
1747 static inline void simcall_storage_get_free_size__set__result(smx_simcall_t simcall, sg_size_t result){
1748     simcall->result.sgsz = result;
1749 }
1750
1751 static inline smx_storage_t simcall_storage_get_used_size__get__name(smx_simcall_t simcall) {
1752   return (smx_storage_t) simcall->args[0].dp;
1753 }
1754 static inline void simcall_storage_get_used_size__set__name(smx_simcall_t simcall, void* arg) {
1755     simcall->args[0].dp = arg;
1756 }
1757 static inline sg_size_t simcall_storage_get_used_size__get__result(smx_simcall_t simcall){
1758     return  simcall->result.sgsz;
1759 }
1760 static inline void simcall_storage_get_used_size__set__result(smx_simcall_t simcall, sg_size_t result){
1761     simcall->result.sgsz = result;
1762 }
1763
1764 static inline smx_storage_t simcall_storage_get_properties__get__storage(smx_simcall_t simcall) {
1765   return (smx_storage_t) simcall->args[0].dp;
1766 }
1767 static inline void simcall_storage_get_properties__set__storage(smx_simcall_t simcall, void* arg) {
1768     simcall->args[0].dp = arg;
1769 }
1770 static inline xbt_dict_t simcall_storage_get_properties__get__result(smx_simcall_t simcall){
1771     return (xbt_dict_t) simcall->result.dp;
1772 }
1773 static inline void simcall_storage_get_properties__set__result(smx_simcall_t simcall, void* result){
1774     simcall->result.dp = result;
1775 }
1776
1777 static inline smx_storage_t simcall_storage_get_content__get__storage(smx_simcall_t simcall) {
1778   return (smx_storage_t) simcall->args[0].dp;
1779 }
1780 static inline void simcall_storage_get_content__set__storage(smx_simcall_t simcall, void* arg) {
1781     simcall->args[0].dp = arg;
1782 }
1783 static inline xbt_dict_t simcall_storage_get_content__get__result(smx_simcall_t simcall){
1784     return (xbt_dict_t) simcall->result.dp;
1785 }
1786 static inline void simcall_storage_get_content__set__result(smx_simcall_t simcall, void* result){
1787     simcall->result.dp = result;
1788 }
1789
1790 static inline const char* simcall_asr_get_properties__get__name(smx_simcall_t simcall) {
1791   return  simcall->args[0].cc;
1792 }
1793 static inline void simcall_asr_get_properties__set__name(smx_simcall_t simcall, const char* arg) {
1794     simcall->args[0].cc = arg;
1795 }
1796 static inline xbt_dict_t simcall_asr_get_properties__get__result(smx_simcall_t simcall){
1797     return (xbt_dict_t) simcall->result.dp;
1798 }
1799 static inline void simcall_asr_get_properties__set__result(smx_simcall_t simcall, void* result){
1800     simcall->result.dp = result;
1801 }
1802 #ifdef HAVE_LATENCY_BOUND_TRACKING
1803
1804 static inline smx_synchro_t simcall_comm_is_latency_bounded__get__comm(smx_simcall_t simcall) {
1805   return (smx_synchro_t) simcall->args[0].dp;
1806 }
1807 static inline void simcall_comm_is_latency_bounded__set__comm(smx_simcall_t simcall, void* arg) {
1808     simcall->args[0].dp = arg;
1809 }
1810 static inline int simcall_comm_is_latency_bounded__get__result(smx_simcall_t simcall){
1811     return  simcall->result.i;
1812 }
1813 static inline void simcall_comm_is_latency_bounded__set__result(smx_simcall_t simcall, int result){
1814     simcall->result.i = result;
1815 }
1816 #endif
1817
1818 #ifdef HAVE_TRACING
1819
1820 static inline smx_synchro_t simcall_set_category__get__synchro(smx_simcall_t simcall) {
1821   return (smx_synchro_t) simcall->args[0].dp;
1822 }
1823 static inline void simcall_set_category__set__synchro(smx_simcall_t simcall, void* arg) {
1824     simcall->args[0].dp = arg;
1825 }
1826 static inline const char* simcall_set_category__get__category(smx_simcall_t simcall) {
1827   return  simcall->args[1].cc;
1828 }
1829 static inline void simcall_set_category__set__category(smx_simcall_t simcall, const char* arg) {
1830     simcall->args[1].cc = arg;
1831 }
1832 #endif
1833
1834 #ifdef HAVE_MC
1835
1836 static inline mc_snapshot_t simcall_mc_snapshot__get__result(smx_simcall_t simcall){
1837     return (mc_snapshot_t) simcall->result.dp;
1838 }
1839 static inline void simcall_mc_snapshot__set__result(smx_simcall_t simcall, void* result){
1840     simcall->result.dp = result;
1841 }
1842
1843 static inline mc_snapshot_t simcall_mc_compare_snapshots__get__s1(smx_simcall_t simcall) {
1844   return (mc_snapshot_t) simcall->args[0].dp;
1845 }
1846 static inline void simcall_mc_compare_snapshots__set__s1(smx_simcall_t simcall, void* arg) {
1847     simcall->args[0].dp = arg;
1848 }
1849 static inline mc_snapshot_t simcall_mc_compare_snapshots__get__s2(smx_simcall_t simcall) {
1850   return (mc_snapshot_t) simcall->args[1].dp;
1851 }
1852 static inline void simcall_mc_compare_snapshots__set__s2(smx_simcall_t simcall, void* arg) {
1853     simcall->args[1].dp = arg;
1854 }
1855 static inline int simcall_mc_compare_snapshots__get__result(smx_simcall_t simcall){
1856     return  simcall->result.i;
1857 }
1858 static inline void simcall_mc_compare_snapshots__set__result(smx_simcall_t simcall, int result){
1859     simcall->result.i = result;
1860 }
1861
1862 static inline int simcall_mc_random__get__min(smx_simcall_t simcall) {
1863   return  simcall->args[0].i;
1864 }
1865 static inline void simcall_mc_random__set__min(smx_simcall_t simcall, int arg) {
1866     simcall->args[0].i = arg;
1867 }
1868 static inline int simcall_mc_random__get__max(smx_simcall_t simcall) {
1869   return  simcall->args[1].i;
1870 }
1871 static inline void simcall_mc_random__set__max(smx_simcall_t simcall, int arg) {
1872     simcall->args[1].i = arg;
1873 }
1874 static inline int simcall_mc_random__get__result(smx_simcall_t simcall){
1875     return  simcall->result.i;
1876 }
1877 static inline void simcall_mc_random__set__result(smx_simcall_t simcall, int result){
1878     simcall->result.i = result;
1879 }
1880 #endif
1881
1882
1883 /* The prototype of all simcall handlers, automatically generated for you */
1884
1885 smx_host_t simcall_HANDLER_host_get_by_name(smx_simcall_t simcall, const char* name);
1886 const char* simcall_HANDLER_host_get_name(smx_simcall_t simcall, smx_host_t host);
1887 void simcall_HANDLER_host_on(smx_simcall_t simcall, smx_host_t host);
1888 void simcall_HANDLER_host_off(smx_simcall_t simcall, smx_host_t host);
1889 xbt_dict_t simcall_HANDLER_host_get_properties(smx_simcall_t simcall, smx_host_t host);
1890 int simcall_HANDLER_host_get_core(smx_simcall_t simcall, smx_host_t host);
1891 xbt_swag_t simcall_HANDLER_host_get_process_list(smx_simcall_t simcall, smx_host_t host);
1892 double simcall_HANDLER_host_get_speed(smx_simcall_t simcall, smx_host_t host);
1893 double simcall_HANDLER_host_get_available_speed(smx_simcall_t simcall, smx_host_t host);
1894 int simcall_HANDLER_host_get_state(smx_simcall_t simcall, smx_host_t host);
1895 double simcall_HANDLER_host_get_current_power_peak(smx_simcall_t simcall, smx_host_t host);
1896 double simcall_HANDLER_host_get_power_peak_at(smx_simcall_t simcall, smx_host_t host, int pstate_index);
1897 int simcall_HANDLER_host_get_nb_pstates(smx_simcall_t simcall, smx_host_t host);
1898 void simcall_HANDLER_host_set_power_peak_at(smx_simcall_t simcall, smx_host_t host, int pstate_index);
1899 double simcall_HANDLER_host_get_consumed_energy(smx_simcall_t simcall, smx_host_t host);
1900 smx_synchro_t simcall_HANDLER_host_execute(smx_simcall_t simcall, const char* name, smx_host_t host, double computation_amount, double priority, double bound, unsigned long affinity_mask);
1901 smx_synchro_t simcall_HANDLER_host_parallel_execute(smx_simcall_t simcall, const char* name, int host_nb, smx_host_t* host_list, double* computation_amount, double* communication_amount, double amount, double rate);
1902 void simcall_HANDLER_host_execution_destroy(smx_simcall_t simcall, smx_synchro_t execution);
1903 void simcall_HANDLER_host_execution_cancel(smx_simcall_t simcall, smx_synchro_t execution);
1904 double simcall_HANDLER_host_execution_get_remains(smx_simcall_t simcall, smx_synchro_t execution);
1905 e_smx_state_t simcall_HANDLER_host_execution_get_state(smx_simcall_t simcall, smx_synchro_t execution);
1906 void simcall_HANDLER_host_execution_set_priority(smx_simcall_t simcall, smx_synchro_t execution, double priority);
1907 void simcall_HANDLER_host_execution_set_bound(smx_simcall_t simcall, smx_synchro_t execution, double bound);
1908 void simcall_HANDLER_host_execution_set_affinity(smx_simcall_t simcall, smx_synchro_t execution, smx_host_t ws, unsigned long mask);
1909 void simcall_HANDLER_host_execution_wait(smx_simcall_t simcall, smx_synchro_t execution);
1910 xbt_dict_t simcall_HANDLER_host_get_mounted_storage_list(smx_simcall_t simcall, smx_host_t host);
1911 xbt_dynar_t simcall_HANDLER_host_get_attached_storage_list(smx_simcall_t simcall, smx_host_t host);
1912 void simcall_HANDLER_host_get_params(smx_simcall_t simcall, smx_host_t ind_vm, ws_params_t params);
1913 void simcall_HANDLER_host_set_params(smx_simcall_t simcall, smx_host_t ind_vm, ws_params_t params);
1914 smx_host_t simcall_HANDLER_vm_create(smx_simcall_t simcall, const char* name, smx_host_t ind_pm);
1915 void simcall_HANDLER_vm_start(smx_simcall_t simcall, smx_host_t ind_vm);
1916 int simcall_HANDLER_vm_get_state(smx_simcall_t simcall, smx_host_t ind_vm);
1917 void simcall_HANDLER_vm_migrate(smx_simcall_t simcall, smx_host_t ind_vm, smx_host_t ind_dst_pm);
1918 void* simcall_HANDLER_vm_get_pm(smx_simcall_t simcall, smx_host_t ind_vm);
1919 void simcall_HANDLER_vm_set_bound(smx_simcall_t simcall, smx_host_t ind_vm, double bound);
1920 void simcall_HANDLER_vm_set_affinity(smx_simcall_t simcall, smx_host_t ind_vm, smx_host_t ind_pm, unsigned long mask);
1921 void simcall_HANDLER_vm_destroy(smx_simcall_t simcall, smx_host_t ind_vm);
1922 void simcall_HANDLER_vm_suspend(smx_simcall_t simcall, smx_host_t ind_vm);
1923 void simcall_HANDLER_vm_resume(smx_simcall_t simcall, smx_host_t ind_vm);
1924 void simcall_HANDLER_vm_shutdown(smx_simcall_t simcall, smx_host_t ind_vm);
1925 void simcall_HANDLER_vm_save(smx_simcall_t simcall, smx_host_t ind_vm);
1926 void simcall_HANDLER_vm_restore(smx_simcall_t simcall, smx_host_t ind_vm);
1927 void simcall_HANDLER_process_create(smx_simcall_t simcall, smx_process_t* process, const char* name, xbt_main_func_t code, void* data, const char* hostname, double kill_time, int argc, char** argv, xbt_dict_t properties, int auto_restart);
1928 void simcall_HANDLER_process_kill(smx_simcall_t simcall, smx_process_t process);
1929 void simcall_HANDLER_process_killall(smx_simcall_t simcall, int reset_pid);
1930 void simcall_HANDLER_process_cleanup(smx_simcall_t simcall, smx_process_t process);
1931 void simcall_HANDLER_process_change_host(smx_simcall_t simcall, smx_process_t process, smx_host_t dest);
1932 void simcall_HANDLER_process_suspend(smx_simcall_t simcall, smx_process_t process);
1933 void simcall_HANDLER_process_resume(smx_simcall_t simcall, smx_process_t process);
1934 int simcall_HANDLER_process_count(smx_simcall_t simcall);
1935 int simcall_HANDLER_process_get_PID(smx_simcall_t simcall, smx_process_t process);
1936 int simcall_HANDLER_process_get_PPID(smx_simcall_t simcall, smx_process_t process);
1937 void* simcall_HANDLER_process_get_data(smx_simcall_t simcall, smx_process_t process);
1938 void simcall_HANDLER_process_set_data(smx_simcall_t simcall, smx_process_t process, void* data);
1939 smx_host_t simcall_HANDLER_process_get_host(smx_simcall_t simcall, smx_process_t process);
1940 const char* simcall_HANDLER_process_get_name(smx_simcall_t simcall, smx_process_t process);
1941 int simcall_HANDLER_process_is_suspended(smx_simcall_t simcall, smx_process_t process);
1942 xbt_dict_t simcall_HANDLER_process_get_properties(smx_simcall_t simcall, smx_process_t process);
1943 void simcall_HANDLER_process_join(smx_simcall_t simcall, smx_process_t process, double timeout);
1944 void simcall_HANDLER_process_sleep(smx_simcall_t simcall, double duration);
1945 void simcall_HANDLER_process_on_exit(smx_simcall_t simcall, smx_process_t process, int_f_pvoid_pvoid_t fun, void* data);
1946 void simcall_HANDLER_process_auto_restart_set(smx_simcall_t simcall, smx_process_t process, int auto_restart);
1947 smx_process_t simcall_HANDLER_process_restart(smx_simcall_t simcall, smx_process_t process);
1948 smx_rdv_t simcall_HANDLER_rdv_create(smx_simcall_t simcall, const char* name);
1949 void simcall_HANDLER_rdv_destroy(smx_simcall_t simcall, smx_rdv_t rdv);
1950 unsigned int simcall_HANDLER_rdv_comm_count_by_host(smx_simcall_t simcall, smx_rdv_t rdv, smx_host_t host);
1951 smx_synchro_t simcall_HANDLER_rdv_get_head(smx_simcall_t simcall, smx_rdv_t rdv);
1952 void simcall_HANDLER_rdv_set_receiver(smx_simcall_t simcall, smx_rdv_t rdv, smx_process_t receiver);
1953 smx_process_t simcall_HANDLER_rdv_get_receiver(smx_simcall_t simcall, smx_rdv_t rdv);
1954 smx_synchro_t simcall_HANDLER_comm_iprobe(smx_simcall_t simcall, smx_rdv_t rdv, int type, int src, int tag, simix_match_func_t match_fun, void* data);
1955 void simcall_HANDLER_comm_send(smx_simcall_t simcall, smx_process_t src, smx_rdv_t rdv, double task_size, double rate, void* src_buff, size_t src_buff_size, simix_match_func_t match_fun, simix_copy_data_func_t copy_data_fun, void* data, double timeout);
1956 smx_synchro_t simcall_HANDLER_comm_isend(smx_simcall_t simcall, smx_process_t src, smx_rdv_t rdv, double task_size, double rate, void* src_buff, size_t src_buff_size, simix_match_func_t match_fun, simix_clean_func_t clean_fun, simix_copy_data_func_t copy_data_fun, void* data, int detached);
1957 void simcall_HANDLER_comm_recv(smx_simcall_t simcall, smx_rdv_t rdv, void* dst_buff, size_t* dst_buff_size, simix_match_func_t match_fun, simix_copy_data_func_t copy_data_fun, void* data, double timeout, double rate);
1958 smx_synchro_t simcall_HANDLER_comm_irecv(smx_simcall_t simcall, smx_rdv_t rdv, void* dst_buff, size_t* dst_buff_size, simix_match_func_t match_fun, simix_copy_data_func_t copy_data_fun, void* data, double rate);
1959 void simcall_HANDLER_comm_cancel(smx_simcall_t simcall, smx_synchro_t comm);
1960 void simcall_HANDLER_comm_waitany(smx_simcall_t simcall, xbt_dynar_t comms);
1961 void simcall_HANDLER_comm_wait(smx_simcall_t simcall, smx_synchro_t comm, double timeout);
1962 void simcall_HANDLER_comm_test(smx_simcall_t simcall, smx_synchro_t comm);
1963 void simcall_HANDLER_comm_testany(smx_simcall_t simcall, xbt_dynar_t comms);
1964 double simcall_HANDLER_comm_get_remains(smx_simcall_t simcall, smx_synchro_t comm);
1965 e_smx_state_t simcall_HANDLER_comm_get_state(smx_simcall_t simcall, smx_synchro_t comm);
1966 void* simcall_HANDLER_comm_get_src_data(smx_simcall_t simcall, smx_synchro_t comm);
1967 void* simcall_HANDLER_comm_get_dst_data(smx_simcall_t simcall, smx_synchro_t comm);
1968 smx_process_t simcall_HANDLER_comm_get_src_proc(smx_simcall_t simcall, smx_synchro_t comm);
1969 smx_process_t simcall_HANDLER_comm_get_dst_proc(smx_simcall_t simcall, smx_synchro_t comm);
1970 smx_mutex_t simcall_HANDLER_mutex_init(smx_simcall_t simcall);
1971 void simcall_HANDLER_mutex_destroy(smx_simcall_t simcall, smx_mutex_t mutex);
1972 void simcall_HANDLER_mutex_lock(smx_simcall_t simcall, smx_mutex_t mutex);
1973
1974 void simcall_HANDLER_mutex_unlock(smx_simcall_t simcall, smx_mutex_t mutex);
1975 smx_cond_t simcall_HANDLER_cond_init(smx_simcall_t simcall);
1976 void simcall_HANDLER_cond_destroy(smx_simcall_t simcall, smx_cond_t cond);
1977 void simcall_HANDLER_cond_signal(smx_simcall_t simcall, smx_cond_t cond);
1978 void simcall_HANDLER_cond_wait(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex);
1979 void simcall_HANDLER_cond_wait_timeout(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex, double timeout);
1980 void simcall_HANDLER_cond_broadcast(smx_simcall_t simcall, smx_cond_t cond);
1981 smx_sem_t simcall_HANDLER_sem_init(smx_simcall_t simcall, unsigned int capacity);
1982 void simcall_HANDLER_sem_destroy(smx_simcall_t simcall, smx_sem_t sem);
1983 void simcall_HANDLER_sem_release(smx_simcall_t simcall, smx_sem_t sem);
1984 int simcall_HANDLER_sem_would_block(smx_simcall_t simcall, smx_sem_t sem);
1985 void simcall_HANDLER_sem_acquire(smx_simcall_t simcall, smx_sem_t sem);
1986 void simcall_HANDLER_sem_acquire_timeout(smx_simcall_t simcall, smx_sem_t sem, double timeout);
1987 int simcall_HANDLER_sem_get_capacity(smx_simcall_t simcall, smx_sem_t sem);
1988 void simcall_HANDLER_file_read(smx_simcall_t simcall, smx_file_t fd, sg_size_t size, smx_host_t host);
1989 void simcall_HANDLER_file_write(smx_simcall_t simcall, smx_file_t fd, sg_size_t size, smx_host_t host);
1990 void simcall_HANDLER_file_open(smx_simcall_t simcall, const char* fullpath, smx_host_t host);
1991 void simcall_HANDLER_file_close(smx_simcall_t simcall, smx_file_t fd, smx_host_t host);
1992 int simcall_HANDLER_file_unlink(smx_simcall_t simcall, smx_file_t fd, smx_host_t host);
1993 sg_size_t simcall_HANDLER_file_get_size(smx_simcall_t simcall, smx_file_t fd);
1994 sg_size_t simcall_HANDLER_file_tell(smx_simcall_t simcall, smx_file_t fd);
1995 int simcall_HANDLER_file_seek(smx_simcall_t simcall, smx_file_t fd, sg_offset_t offset, int origin);
1996 xbt_dynar_t simcall_HANDLER_file_get_info(smx_simcall_t simcall, smx_file_t fd);
1997 int simcall_HANDLER_file_move(smx_simcall_t simcall, smx_file_t fd, const char* fullpath);
1998 sg_size_t simcall_HANDLER_storage_get_free_size(smx_simcall_t simcall, smx_storage_t storage);
1999 sg_size_t simcall_HANDLER_storage_get_used_size(smx_simcall_t simcall, smx_storage_t name);
2000 xbt_dict_t simcall_HANDLER_storage_get_properties(smx_simcall_t simcall, smx_storage_t storage);
2001 xbt_dict_t simcall_HANDLER_storage_get_content(smx_simcall_t simcall, smx_storage_t storage);
2002 xbt_dict_t simcall_HANDLER_asr_get_properties(smx_simcall_t simcall, const char* name);
2003 #ifdef HAVE_LATENCY_BOUND_TRACKING
2004 int simcall_HANDLER_comm_is_latency_bounded(smx_simcall_t simcall, smx_synchro_t comm);
2005 #endif
2006
2007 #ifdef HAVE_TRACING
2008 void simcall_HANDLER_set_category(smx_simcall_t simcall, smx_synchro_t synchro, const char* category);
2009 #endif
2010
2011 #ifdef HAVE_MC
2012 mc_snapshot_t simcall_HANDLER_mc_snapshot(smx_simcall_t simcall);
2013 int simcall_HANDLER_mc_compare_snapshots(smx_simcall_t simcall, mc_snapshot_t s1, mc_snapshot_t s2);
2014 int simcall_HANDLER_mc_random(smx_simcall_t simcall, int min, int max);
2015 #endif