Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
inline 2 more VM functions, and kill a simcall
[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 #include "src/simix/popping_private.h"
17 static inline sg_host_t simcall_vm_suspend__get__ind_vm(smx_simcall_t simcall) {
18   return simgrid::simix::unmarshal<sg_host_t>(simcall->args[0]);
19 }
20 static inline void simcall_vm_suspend__set__ind_vm(smx_simcall_t simcall, sg_host_t arg) {
21     simgrid::simix::marshal<sg_host_t>(simcall->args[0], arg);
22 }
23
24 static inline sg_host_t simcall_vm_resume__get__ind_vm(smx_simcall_t simcall) {
25   return simgrid::simix::unmarshal<sg_host_t>(simcall->args[0]);
26 }
27 static inline void simcall_vm_resume__set__ind_vm(smx_simcall_t simcall, sg_host_t arg) {
28     simgrid::simix::marshal<sg_host_t>(simcall->args[0], arg);
29 }
30
31 static inline sg_host_t simcall_vm_shutdown__get__ind_vm(smx_simcall_t simcall) {
32   return simgrid::simix::unmarshal<sg_host_t>(simcall->args[0]);
33 }
34 static inline void simcall_vm_shutdown__set__ind_vm(smx_simcall_t simcall, sg_host_t arg) {
35     simgrid::simix::marshal<sg_host_t>(simcall->args[0], arg);
36 }
37
38 static inline sg_host_t simcall_vm_save__get__ind_vm(smx_simcall_t simcall) {
39   return simgrid::simix::unmarshal<sg_host_t>(simcall->args[0]);
40 }
41 static inline void simcall_vm_save__set__ind_vm(smx_simcall_t simcall, sg_host_t arg) {
42     simgrid::simix::marshal<sg_host_t>(simcall->args[0], arg);
43 }
44
45 static inline smx_actor_t simcall_process_kill__get__process(smx_simcall_t simcall) {
46   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
47 }
48 static inline void simcall_process_kill__set__process(smx_simcall_t simcall, smx_actor_t arg) {
49     simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
50 }
51
52 static inline int simcall_process_killall__get__reset_pid(smx_simcall_t simcall) {
53   return simgrid::simix::unmarshal<int>(simcall->args[0]);
54 }
55 static inline void simcall_process_killall__set__reset_pid(smx_simcall_t simcall, int arg) {
56     simgrid::simix::marshal<int>(simcall->args[0], arg);
57 }
58
59 static inline smx_actor_t simcall_process_cleanup__get__process(smx_simcall_t simcall) {
60   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
61 }
62 static inline void simcall_process_cleanup__set__process(smx_simcall_t simcall, smx_actor_t arg) {
63     simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
64 }
65
66 static inline smx_actor_t simcall_process_suspend__get__process(smx_simcall_t simcall) {
67   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
68 }
69 static inline void simcall_process_suspend__set__process(smx_simcall_t simcall, smx_actor_t arg) {
70     simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
71 }
72
73 static inline smx_actor_t simcall_process_resume__get__process(smx_simcall_t simcall) {
74   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
75 }
76 static inline void simcall_process_resume__set__process(smx_simcall_t simcall, smx_actor_t arg) {
77     simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
78 }
79
80 static inline smx_actor_t simcall_process_set_host__get__process(smx_simcall_t simcall) {
81   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
82 }
83 static inline void simcall_process_set_host__set__process(smx_simcall_t simcall, smx_actor_t arg) {
84     simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
85 }
86 static inline sg_host_t simcall_process_set_host__get__dest(smx_simcall_t simcall) {
87   return simgrid::simix::unmarshal<sg_host_t>(simcall->args[1]);
88 }
89 static inline void simcall_process_set_host__set__dest(smx_simcall_t simcall, sg_host_t arg) {
90     simgrid::simix::marshal<sg_host_t>(simcall->args[1], arg);
91 }
92
93 static inline smx_actor_t simcall_process_is_suspended__get__process(smx_simcall_t simcall) {
94   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
95 }
96 static inline void simcall_process_is_suspended__set__process(smx_simcall_t simcall, smx_actor_t arg) {
97     simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
98 }
99 static inline int simcall_process_is_suspended__get__result(smx_simcall_t simcall){
100     return simgrid::simix::unmarshal<int>(simcall->result);
101 }
102 static inline void simcall_process_is_suspended__set__result(smx_simcall_t simcall, int result){
103     simgrid::simix::marshal<int>(simcall->result, result);
104 }
105
106 static inline smx_actor_t simcall_process_join__get__process(smx_simcall_t simcall) {
107   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
108 }
109 static inline void simcall_process_join__set__process(smx_simcall_t simcall, smx_actor_t arg) {
110     simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
111 }
112 static inline double simcall_process_join__get__timeout(smx_simcall_t simcall) {
113   return simgrid::simix::unmarshal<double>(simcall->args[1]);
114 }
115 static inline void simcall_process_join__set__timeout(smx_simcall_t simcall, double arg) {
116     simgrid::simix::marshal<double>(simcall->args[1], arg);
117 }
118 static inline int simcall_process_join__get__result(smx_simcall_t simcall){
119     return simgrid::simix::unmarshal<int>(simcall->result);
120 }
121 static inline void simcall_process_join__set__result(smx_simcall_t simcall, int result){
122     simgrid::simix::marshal<int>(simcall->result, result);
123 }
124
125 static inline double simcall_process_sleep__get__duration(smx_simcall_t simcall) {
126   return simgrid::simix::unmarshal<double>(simcall->args[0]);
127 }
128 static inline void simcall_process_sleep__set__duration(smx_simcall_t simcall, double arg) {
129     simgrid::simix::marshal<double>(simcall->args[0], arg);
130 }
131 static inline int simcall_process_sleep__get__result(smx_simcall_t simcall){
132     return simgrid::simix::unmarshal<int>(simcall->result);
133 }
134 static inline void simcall_process_sleep__set__result(smx_simcall_t simcall, int result){
135     simgrid::simix::marshal<int>(simcall->result, result);
136 }
137
138 static inline const char* simcall_execution_start__get__name(smx_simcall_t simcall) {
139   return simgrid::simix::unmarshal<const char*>(simcall->args[0]);
140 }
141 static inline void simcall_execution_start__set__name(smx_simcall_t simcall, const char* arg) {
142     simgrid::simix::marshal<const char*>(simcall->args[0], arg);
143 }
144 static inline double simcall_execution_start__get__flops_amount(smx_simcall_t simcall) {
145   return simgrid::simix::unmarshal<double>(simcall->args[1]);
146 }
147 static inline void simcall_execution_start__set__flops_amount(smx_simcall_t simcall, double arg) {
148     simgrid::simix::marshal<double>(simcall->args[1], arg);
149 }
150 static inline double simcall_execution_start__get__priority(smx_simcall_t simcall) {
151   return simgrid::simix::unmarshal<double>(simcall->args[2]);
152 }
153 static inline void simcall_execution_start__set__priority(smx_simcall_t simcall, double arg) {
154     simgrid::simix::marshal<double>(simcall->args[2], arg);
155 }
156 static inline double simcall_execution_start__get__bound(smx_simcall_t simcall) {
157   return simgrid::simix::unmarshal<double>(simcall->args[3]);
158 }
159 static inline void simcall_execution_start__set__bound(smx_simcall_t simcall, double arg) {
160     simgrid::simix::marshal<double>(simcall->args[3], arg);
161 }
162 static inline smx_activity_t simcall_execution_start__get__result(smx_simcall_t simcall){
163     return simgrid::simix::unmarshal<smx_activity_t>(simcall->result);
164 }
165 static inline void simcall_execution_start__set__result(smx_simcall_t simcall, smx_activity_t result){
166     simgrid::simix::marshal<smx_activity_t>(simcall->result, result);
167 }
168
169 static inline const char* simcall_execution_parallel_start__get__name(smx_simcall_t simcall) {
170   return simgrid::simix::unmarshal<const char*>(simcall->args[0]);
171 }
172 static inline void simcall_execution_parallel_start__set__name(smx_simcall_t simcall, const char* arg) {
173     simgrid::simix::marshal<const char*>(simcall->args[0], arg);
174 }
175 static inline int simcall_execution_parallel_start__get__host_nb(smx_simcall_t simcall) {
176   return simgrid::simix::unmarshal<int>(simcall->args[1]);
177 }
178 static inline void simcall_execution_parallel_start__set__host_nb(smx_simcall_t simcall, int arg) {
179     simgrid::simix::marshal<int>(simcall->args[1], arg);
180 }
181 static inline sg_host_t* simcall_execution_parallel_start__get__host_list(smx_simcall_t simcall) {
182   return simgrid::simix::unmarshal<sg_host_t*>(simcall->args[2]);
183 }
184 static inline void simcall_execution_parallel_start__set__host_list(smx_simcall_t simcall, sg_host_t* arg) {
185     simgrid::simix::marshal<sg_host_t*>(simcall->args[2], arg);
186 }
187 static inline double* simcall_execution_parallel_start__get__flops_amount(smx_simcall_t simcall) {
188   return simgrid::simix::unmarshal<double*>(simcall->args[3]);
189 }
190 static inline void simcall_execution_parallel_start__set__flops_amount(smx_simcall_t simcall, double* arg) {
191     simgrid::simix::marshal<double*>(simcall->args[3], arg);
192 }
193 static inline double* simcall_execution_parallel_start__get__bytes_amount(smx_simcall_t simcall) {
194   return simgrid::simix::unmarshal<double*>(simcall->args[4]);
195 }
196 static inline void simcall_execution_parallel_start__set__bytes_amount(smx_simcall_t simcall, double* arg) {
197     simgrid::simix::marshal<double*>(simcall->args[4], arg);
198 }
199 static inline double simcall_execution_parallel_start__get__amount(smx_simcall_t simcall) {
200   return simgrid::simix::unmarshal<double>(simcall->args[5]);
201 }
202 static inline void simcall_execution_parallel_start__set__amount(smx_simcall_t simcall, double arg) {
203     simgrid::simix::marshal<double>(simcall->args[5], arg);
204 }
205 static inline double simcall_execution_parallel_start__get__rate(smx_simcall_t simcall) {
206   return simgrid::simix::unmarshal<double>(simcall->args[6]);
207 }
208 static inline void simcall_execution_parallel_start__set__rate(smx_simcall_t simcall, double arg) {
209     simgrid::simix::marshal<double>(simcall->args[6], arg);
210 }
211 static inline double simcall_execution_parallel_start__get__timeout(smx_simcall_t simcall) {
212   return simgrid::simix::unmarshal<double>(simcall->args[7]);
213 }
214 static inline void simcall_execution_parallel_start__set__timeout(smx_simcall_t simcall, double arg) {
215     simgrid::simix::marshal<double>(simcall->args[7], arg);
216 }
217 static inline smx_activity_t simcall_execution_parallel_start__get__result(smx_simcall_t simcall){
218     return simgrid::simix::unmarshal<smx_activity_t>(simcall->result);
219 }
220 static inline void simcall_execution_parallel_start__set__result(smx_simcall_t simcall, smx_activity_t result){
221     simgrid::simix::marshal<smx_activity_t>(simcall->result, result);
222 }
223
224 static inline smx_activity_t simcall_execution_cancel__get__execution(smx_simcall_t simcall) {
225   return simgrid::simix::unmarshal<smx_activity_t>(simcall->args[0]);
226 }
227 static inline void simcall_execution_cancel__set__execution(smx_simcall_t simcall, smx_activity_t arg) {
228     simgrid::simix::marshal<smx_activity_t>(simcall->args[0], arg);
229 }
230
231 static inline smx_activity_t simcall_execution_set_priority__get__execution(smx_simcall_t simcall) {
232   return simgrid::simix::unmarshal<smx_activity_t>(simcall->args[0]);
233 }
234 static inline void simcall_execution_set_priority__set__execution(smx_simcall_t simcall, smx_activity_t arg) {
235     simgrid::simix::marshal<smx_activity_t>(simcall->args[0], arg);
236 }
237 static inline double simcall_execution_set_priority__get__priority(smx_simcall_t simcall) {
238   return simgrid::simix::unmarshal<double>(simcall->args[1]);
239 }
240 static inline void simcall_execution_set_priority__set__priority(smx_simcall_t simcall, double arg) {
241     simgrid::simix::marshal<double>(simcall->args[1], arg);
242 }
243
244 static inline smx_activity_t simcall_execution_set_bound__get__execution(smx_simcall_t simcall) {
245   return simgrid::simix::unmarshal<smx_activity_t>(simcall->args[0]);
246 }
247 static inline void simcall_execution_set_bound__set__execution(smx_simcall_t simcall, smx_activity_t arg) {
248     simgrid::simix::marshal<smx_activity_t>(simcall->args[0], arg);
249 }
250 static inline double simcall_execution_set_bound__get__bound(smx_simcall_t simcall) {
251   return simgrid::simix::unmarshal<double>(simcall->args[1]);
252 }
253 static inline void simcall_execution_set_bound__set__bound(smx_simcall_t simcall, double arg) {
254     simgrid::simix::marshal<double>(simcall->args[1], arg);
255 }
256
257 static inline smx_activity_t simcall_execution_wait__get__execution(smx_simcall_t simcall) {
258   return simgrid::simix::unmarshal<smx_activity_t>(simcall->args[0]);
259 }
260 static inline void simcall_execution_wait__set__execution(smx_simcall_t simcall, smx_activity_t arg) {
261     simgrid::simix::marshal<smx_activity_t>(simcall->args[0], arg);
262 }
263 static inline int simcall_execution_wait__get__result(smx_simcall_t simcall){
264     return simgrid::simix::unmarshal<int>(simcall->result);
265 }
266 static inline void simcall_execution_wait__set__result(smx_simcall_t simcall, int result){
267     simgrid::simix::marshal<int>(simcall->result, result);
268 }
269
270 static inline smx_actor_t simcall_process_on_exit__get__process(smx_simcall_t simcall) {
271   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
272 }
273 static inline void simcall_process_on_exit__set__process(smx_simcall_t simcall, smx_actor_t arg) {
274     simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
275 }
276 static inline int_f_pvoid_pvoid_t simcall_process_on_exit__get__fun(smx_simcall_t simcall) {
277   return simgrid::simix::unmarshal<int_f_pvoid_pvoid_t>(simcall->args[1]);
278 }
279 static inline void simcall_process_on_exit__set__fun(smx_simcall_t simcall, int_f_pvoid_pvoid_t arg) {
280     simgrid::simix::marshal<int_f_pvoid_pvoid_t>(simcall->args[1], arg);
281 }
282 static inline void* simcall_process_on_exit__get__data(smx_simcall_t simcall) {
283   return simgrid::simix::unmarshal<void*>(simcall->args[2]);
284 }
285 static inline void simcall_process_on_exit__set__data(smx_simcall_t simcall, void* arg) {
286     simgrid::simix::marshal<void*>(simcall->args[2], arg);
287 }
288
289 static inline smx_actor_t simcall_process_auto_restart_set__get__process(smx_simcall_t simcall) {
290   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
291 }
292 static inline void simcall_process_auto_restart_set__set__process(smx_simcall_t simcall, smx_actor_t arg) {
293     simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
294 }
295 static inline int simcall_process_auto_restart_set__get__auto_restart(smx_simcall_t simcall) {
296   return simgrid::simix::unmarshal<int>(simcall->args[1]);
297 }
298 static inline void simcall_process_auto_restart_set__set__auto_restart(smx_simcall_t simcall, int arg) {
299     simgrid::simix::marshal<int>(simcall->args[1], arg);
300 }
301
302 static inline smx_actor_t simcall_process_restart__get__process(smx_simcall_t simcall) {
303   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
304 }
305 static inline void simcall_process_restart__set__process(smx_simcall_t simcall, smx_actor_t arg) {
306     simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
307 }
308 static inline smx_actor_t simcall_process_restart__get__result(smx_simcall_t simcall){
309     return simgrid::simix::unmarshal<smx_actor_t>(simcall->result);
310 }
311 static inline void simcall_process_restart__set__result(smx_simcall_t simcall, smx_actor_t result){
312     simgrid::simix::marshal<smx_actor_t>(simcall->result, result);
313 }
314
315 static inline const char* simcall_mbox_create__get__name(smx_simcall_t simcall) {
316   return simgrid::simix::unmarshal<const char*>(simcall->args[0]);
317 }
318 static inline void simcall_mbox_create__set__name(smx_simcall_t simcall, const char* arg) {
319     simgrid::simix::marshal<const char*>(simcall->args[0], arg);
320 }
321 static inline smx_mailbox_t simcall_mbox_create__get__result(smx_simcall_t simcall){
322     return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->result);
323 }
324 static inline void simcall_mbox_create__set__result(smx_simcall_t simcall, smx_mailbox_t result){
325     simgrid::simix::marshal<smx_mailbox_t>(simcall->result, result);
326 }
327
328 static inline smx_mailbox_t simcall_mbox_set_receiver__get__mbox(smx_simcall_t simcall) {
329   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[0]);
330 }
331 static inline void simcall_mbox_set_receiver__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg) {
332     simgrid::simix::marshal<smx_mailbox_t>(simcall->args[0], arg);
333 }
334 static inline smx_actor_t simcall_mbox_set_receiver__get__receiver(smx_simcall_t simcall) {
335   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[1]);
336 }
337 static inline void simcall_mbox_set_receiver__set__receiver(smx_simcall_t simcall, smx_actor_t arg) {
338     simgrid::simix::marshal<smx_actor_t>(simcall->args[1], arg);
339 }
340
341 static inline smx_mailbox_t simcall_comm_iprobe__get__mbox(smx_simcall_t simcall) {
342   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[0]);
343 }
344 static inline void simcall_comm_iprobe__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg) {
345     simgrid::simix::marshal<smx_mailbox_t>(simcall->args[0], arg);
346 }
347 static inline int simcall_comm_iprobe__get__type(smx_simcall_t simcall) {
348   return simgrid::simix::unmarshal<int>(simcall->args[1]);
349 }
350 static inline void simcall_comm_iprobe__set__type(smx_simcall_t simcall, int arg) {
351     simgrid::simix::marshal<int>(simcall->args[1], arg);
352 }
353 static inline int simcall_comm_iprobe__get__src(smx_simcall_t simcall) {
354   return simgrid::simix::unmarshal<int>(simcall->args[2]);
355 }
356 static inline void simcall_comm_iprobe__set__src(smx_simcall_t simcall, int arg) {
357     simgrid::simix::marshal<int>(simcall->args[2], arg);
358 }
359 static inline int simcall_comm_iprobe__get__tag(smx_simcall_t simcall) {
360   return simgrid::simix::unmarshal<int>(simcall->args[3]);
361 }
362 static inline void simcall_comm_iprobe__set__tag(smx_simcall_t simcall, int arg) {
363     simgrid::simix::marshal<int>(simcall->args[3], arg);
364 }
365 static inline simix_match_func_t simcall_comm_iprobe__get__match_fun(smx_simcall_t simcall) {
366   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[4]);
367 }
368 static inline void simcall_comm_iprobe__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg) {
369     simgrid::simix::marshal<simix_match_func_t>(simcall->args[4], arg);
370 }
371 static inline void* simcall_comm_iprobe__get__data(smx_simcall_t simcall) {
372   return simgrid::simix::unmarshal<void*>(simcall->args[5]);
373 }
374 static inline void simcall_comm_iprobe__set__data(smx_simcall_t simcall, void* arg) {
375     simgrid::simix::marshal<void*>(simcall->args[5], arg);
376 }
377 static inline smx_activity_t simcall_comm_iprobe__get__result(smx_simcall_t simcall){
378     return simgrid::simix::unmarshal<smx_activity_t>(simcall->result);
379 }
380 static inline void simcall_comm_iprobe__set__result(smx_simcall_t simcall, smx_activity_t result){
381     simgrid::simix::marshal<smx_activity_t>(simcall->result, result);
382 }
383
384 static inline smx_actor_t simcall_comm_send__get__sender(smx_simcall_t simcall) {
385   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
386 }
387 static inline void simcall_comm_send__set__sender(smx_simcall_t simcall, smx_actor_t arg) {
388     simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
389 }
390 static inline smx_mailbox_t simcall_comm_send__get__mbox(smx_simcall_t simcall) {
391   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[1]);
392 }
393 static inline void simcall_comm_send__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg) {
394     simgrid::simix::marshal<smx_mailbox_t>(simcall->args[1], arg);
395 }
396 static inline double simcall_comm_send__get__task_size(smx_simcall_t simcall) {
397   return simgrid::simix::unmarshal<double>(simcall->args[2]);
398 }
399 static inline void simcall_comm_send__set__task_size(smx_simcall_t simcall, double arg) {
400     simgrid::simix::marshal<double>(simcall->args[2], arg);
401 }
402 static inline double simcall_comm_send__get__rate(smx_simcall_t simcall) {
403   return simgrid::simix::unmarshal<double>(simcall->args[3]);
404 }
405 static inline void simcall_comm_send__set__rate(smx_simcall_t simcall, double arg) {
406     simgrid::simix::marshal<double>(simcall->args[3], arg);
407 }
408 static inline void* simcall_comm_send__get__src_buff(smx_simcall_t simcall) {
409   return simgrid::simix::unmarshal<void*>(simcall->args[4]);
410 }
411 static inline void simcall_comm_send__set__src_buff(smx_simcall_t simcall, void* arg) {
412     simgrid::simix::marshal<void*>(simcall->args[4], arg);
413 }
414 static inline size_t simcall_comm_send__get__src_buff_size(smx_simcall_t simcall) {
415   return simgrid::simix::unmarshal<size_t>(simcall->args[5]);
416 }
417 static inline void simcall_comm_send__set__src_buff_size(smx_simcall_t simcall, size_t arg) {
418     simgrid::simix::marshal<size_t>(simcall->args[5], arg);
419 }
420 static inline simix_match_func_t simcall_comm_send__get__match_fun(smx_simcall_t simcall) {
421   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[6]);
422 }
423 static inline void simcall_comm_send__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg) {
424     simgrid::simix::marshal<simix_match_func_t>(simcall->args[6], arg);
425 }
426 static inline simix_copy_data_func_t simcall_comm_send__get__copy_data_fun(smx_simcall_t simcall) {
427   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[7]);
428 }
429 static inline void simcall_comm_send__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg) {
430     simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[7], arg);
431 }
432 static inline void* simcall_comm_send__get__data(smx_simcall_t simcall) {
433   return simgrid::simix::unmarshal<void*>(simcall->args[8]);
434 }
435 static inline void simcall_comm_send__set__data(smx_simcall_t simcall, void* arg) {
436     simgrid::simix::marshal<void*>(simcall->args[8], arg);
437 }
438 static inline double simcall_comm_send__get__timeout(smx_simcall_t simcall) {
439   return simgrid::simix::unmarshal<double>(simcall->args[9]);
440 }
441 static inline void simcall_comm_send__set__timeout(smx_simcall_t simcall, double arg) {
442     simgrid::simix::marshal<double>(simcall->args[9], arg);
443 }
444
445 static inline smx_actor_t simcall_comm_isend__get__sender(smx_simcall_t simcall) {
446   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
447 }
448 static inline void simcall_comm_isend__set__sender(smx_simcall_t simcall, smx_actor_t arg) {
449     simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
450 }
451 static inline smx_mailbox_t simcall_comm_isend__get__mbox(smx_simcall_t simcall) {
452   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[1]);
453 }
454 static inline void simcall_comm_isend__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg) {
455     simgrid::simix::marshal<smx_mailbox_t>(simcall->args[1], arg);
456 }
457 static inline double simcall_comm_isend__get__task_size(smx_simcall_t simcall) {
458   return simgrid::simix::unmarshal<double>(simcall->args[2]);
459 }
460 static inline void simcall_comm_isend__set__task_size(smx_simcall_t simcall, double arg) {
461     simgrid::simix::marshal<double>(simcall->args[2], arg);
462 }
463 static inline double simcall_comm_isend__get__rate(smx_simcall_t simcall) {
464   return simgrid::simix::unmarshal<double>(simcall->args[3]);
465 }
466 static inline void simcall_comm_isend__set__rate(smx_simcall_t simcall, double arg) {
467     simgrid::simix::marshal<double>(simcall->args[3], arg);
468 }
469 static inline void* simcall_comm_isend__get__src_buff(smx_simcall_t simcall) {
470   return simgrid::simix::unmarshal<void*>(simcall->args[4]);
471 }
472 static inline void simcall_comm_isend__set__src_buff(smx_simcall_t simcall, void* arg) {
473     simgrid::simix::marshal<void*>(simcall->args[4], arg);
474 }
475 static inline size_t simcall_comm_isend__get__src_buff_size(smx_simcall_t simcall) {
476   return simgrid::simix::unmarshal<size_t>(simcall->args[5]);
477 }
478 static inline void simcall_comm_isend__set__src_buff_size(smx_simcall_t simcall, size_t arg) {
479     simgrid::simix::marshal<size_t>(simcall->args[5], arg);
480 }
481 static inline simix_match_func_t simcall_comm_isend__get__match_fun(smx_simcall_t simcall) {
482   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[6]);
483 }
484 static inline void simcall_comm_isend__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg) {
485     simgrid::simix::marshal<simix_match_func_t>(simcall->args[6], arg);
486 }
487 static inline simix_clean_func_t simcall_comm_isend__get__clean_fun(smx_simcall_t simcall) {
488   return simgrid::simix::unmarshal<simix_clean_func_t>(simcall->args[7]);
489 }
490 static inline void simcall_comm_isend__set__clean_fun(smx_simcall_t simcall, simix_clean_func_t arg) {
491     simgrid::simix::marshal<simix_clean_func_t>(simcall->args[7], arg);
492 }
493 static inline simix_copy_data_func_t simcall_comm_isend__get__copy_data_fun(smx_simcall_t simcall) {
494   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[8]);
495 }
496 static inline void simcall_comm_isend__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg) {
497     simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[8], arg);
498 }
499 static inline void* simcall_comm_isend__get__data(smx_simcall_t simcall) {
500   return simgrid::simix::unmarshal<void*>(simcall->args[9]);
501 }
502 static inline void simcall_comm_isend__set__data(smx_simcall_t simcall, void* arg) {
503     simgrid::simix::marshal<void*>(simcall->args[9], arg);
504 }
505 static inline int simcall_comm_isend__get__detached(smx_simcall_t simcall) {
506   return simgrid::simix::unmarshal<int>(simcall->args[10]);
507 }
508 static inline void simcall_comm_isend__set__detached(smx_simcall_t simcall, int arg) {
509     simgrid::simix::marshal<int>(simcall->args[10], arg);
510 }
511 static inline smx_activity_t simcall_comm_isend__get__result(smx_simcall_t simcall){
512     return simgrid::simix::unmarshal<smx_activity_t>(simcall->result);
513 }
514 static inline void simcall_comm_isend__set__result(smx_simcall_t simcall, smx_activity_t result){
515     simgrid::simix::marshal<smx_activity_t>(simcall->result, result);
516 }
517
518 static inline smx_actor_t simcall_comm_recv__get__receiver(smx_simcall_t simcall) {
519   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
520 }
521 static inline void simcall_comm_recv__set__receiver(smx_simcall_t simcall, smx_actor_t arg) {
522     simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
523 }
524 static inline smx_mailbox_t simcall_comm_recv__get__mbox(smx_simcall_t simcall) {
525   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[1]);
526 }
527 static inline void simcall_comm_recv__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg) {
528     simgrid::simix::marshal<smx_mailbox_t>(simcall->args[1], arg);
529 }
530 static inline void* simcall_comm_recv__get__dst_buff(smx_simcall_t simcall) {
531   return simgrid::simix::unmarshal<void*>(simcall->args[2]);
532 }
533 static inline void simcall_comm_recv__set__dst_buff(smx_simcall_t simcall, void* arg) {
534     simgrid::simix::marshal<void*>(simcall->args[2], arg);
535 }
536 static inline size_t* simcall_comm_recv__get__dst_buff_size(smx_simcall_t simcall) {
537   return simgrid::simix::unmarshal<size_t*>(simcall->args[3]);
538 }
539 static inline void simcall_comm_recv__set__dst_buff_size(smx_simcall_t simcall, size_t* arg) {
540     simgrid::simix::marshal<size_t*>(simcall->args[3], arg);
541 }
542 static inline simix_match_func_t simcall_comm_recv__get__match_fun(smx_simcall_t simcall) {
543   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[4]);
544 }
545 static inline void simcall_comm_recv__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg) {
546     simgrid::simix::marshal<simix_match_func_t>(simcall->args[4], arg);
547 }
548 static inline simix_copy_data_func_t simcall_comm_recv__get__copy_data_fun(smx_simcall_t simcall) {
549   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[5]);
550 }
551 static inline void simcall_comm_recv__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg) {
552     simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[5], arg);
553 }
554 static inline void* simcall_comm_recv__get__data(smx_simcall_t simcall) {
555   return simgrid::simix::unmarshal<void*>(simcall->args[6]);
556 }
557 static inline void simcall_comm_recv__set__data(smx_simcall_t simcall, void* arg) {
558     simgrid::simix::marshal<void*>(simcall->args[6], arg);
559 }
560 static inline double simcall_comm_recv__get__timeout(smx_simcall_t simcall) {
561   return simgrid::simix::unmarshal<double>(simcall->args[7]);
562 }
563 static inline void simcall_comm_recv__set__timeout(smx_simcall_t simcall, double arg) {
564     simgrid::simix::marshal<double>(simcall->args[7], arg);
565 }
566 static inline double simcall_comm_recv__get__rate(smx_simcall_t simcall) {
567   return simgrid::simix::unmarshal<double>(simcall->args[8]);
568 }
569 static inline void simcall_comm_recv__set__rate(smx_simcall_t simcall, double arg) {
570     simgrid::simix::marshal<double>(simcall->args[8], arg);
571 }
572
573 static inline smx_actor_t simcall_comm_irecv__get__receiver(smx_simcall_t simcall) {
574   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
575 }
576 static inline void simcall_comm_irecv__set__receiver(smx_simcall_t simcall, smx_actor_t arg) {
577     simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
578 }
579 static inline smx_mailbox_t simcall_comm_irecv__get__mbox(smx_simcall_t simcall) {
580   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[1]);
581 }
582 static inline void simcall_comm_irecv__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg) {
583     simgrid::simix::marshal<smx_mailbox_t>(simcall->args[1], arg);
584 }
585 static inline void* simcall_comm_irecv__get__dst_buff(smx_simcall_t simcall) {
586   return simgrid::simix::unmarshal<void*>(simcall->args[2]);
587 }
588 static inline void simcall_comm_irecv__set__dst_buff(smx_simcall_t simcall, void* arg) {
589     simgrid::simix::marshal<void*>(simcall->args[2], arg);
590 }
591 static inline size_t* simcall_comm_irecv__get__dst_buff_size(smx_simcall_t simcall) {
592   return simgrid::simix::unmarshal<size_t*>(simcall->args[3]);
593 }
594 static inline void simcall_comm_irecv__set__dst_buff_size(smx_simcall_t simcall, size_t* arg) {
595     simgrid::simix::marshal<size_t*>(simcall->args[3], arg);
596 }
597 static inline simix_match_func_t simcall_comm_irecv__get__match_fun(smx_simcall_t simcall) {
598   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[4]);
599 }
600 static inline void simcall_comm_irecv__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg) {
601     simgrid::simix::marshal<simix_match_func_t>(simcall->args[4], arg);
602 }
603 static inline simix_copy_data_func_t simcall_comm_irecv__get__copy_data_fun(smx_simcall_t simcall) {
604   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[5]);
605 }
606 static inline void simcall_comm_irecv__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg) {
607     simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[5], arg);
608 }
609 static inline void* simcall_comm_irecv__get__data(smx_simcall_t simcall) {
610   return simgrid::simix::unmarshal<void*>(simcall->args[6]);
611 }
612 static inline void simcall_comm_irecv__set__data(smx_simcall_t simcall, void* arg) {
613     simgrid::simix::marshal<void*>(simcall->args[6], arg);
614 }
615 static inline double simcall_comm_irecv__get__rate(smx_simcall_t simcall) {
616   return simgrid::simix::unmarshal<double>(simcall->args[7]);
617 }
618 static inline void simcall_comm_irecv__set__rate(smx_simcall_t simcall, double arg) {
619     simgrid::simix::marshal<double>(simcall->args[7], arg);
620 }
621 static inline smx_activity_t simcall_comm_irecv__get__result(smx_simcall_t simcall){
622     return simgrid::simix::unmarshal<smx_activity_t>(simcall->result);
623 }
624 static inline void simcall_comm_irecv__set__result(smx_simcall_t simcall, smx_activity_t result){
625     simgrid::simix::marshal<smx_activity_t>(simcall->result, result);
626 }
627
628 static inline xbt_dynar_t simcall_comm_waitany__get__comms(smx_simcall_t simcall) {
629   return simgrid::simix::unmarshal<xbt_dynar_t>(simcall->args[0]);
630 }
631 static inline void simcall_comm_waitany__set__comms(smx_simcall_t simcall, xbt_dynar_t arg) {
632     simgrid::simix::marshal<xbt_dynar_t>(simcall->args[0], arg);
633 }
634 static inline double simcall_comm_waitany__get__timeout(smx_simcall_t simcall) {
635   return simgrid::simix::unmarshal<double>(simcall->args[1]);
636 }
637 static inline void simcall_comm_waitany__set__timeout(smx_simcall_t simcall, double arg) {
638     simgrid::simix::marshal<double>(simcall->args[1], arg);
639 }
640 static inline int simcall_comm_waitany__get__result(smx_simcall_t simcall){
641     return simgrid::simix::unmarshal<int>(simcall->result);
642 }
643 static inline void simcall_comm_waitany__set__result(smx_simcall_t simcall, int result){
644     simgrid::simix::marshal<int>(simcall->result, result);
645 }
646
647 static inline smx_activity_t simcall_comm_wait__get__comm(smx_simcall_t simcall) {
648   return simgrid::simix::unmarshal<smx_activity_t>(simcall->args[0]);
649 }
650 static inline void simcall_comm_wait__set__comm(smx_simcall_t simcall, smx_activity_t arg) {
651     simgrid::simix::marshal<smx_activity_t>(simcall->args[0], arg);
652 }
653 static inline double simcall_comm_wait__get__timeout(smx_simcall_t simcall) {
654   return simgrid::simix::unmarshal<double>(simcall->args[1]);
655 }
656 static inline void simcall_comm_wait__set__timeout(smx_simcall_t simcall, double arg) {
657     simgrid::simix::marshal<double>(simcall->args[1], arg);
658 }
659
660 static inline smx_activity_t simcall_comm_test__get__comm(smx_simcall_t simcall) {
661   return simgrid::simix::unmarshal<smx_activity_t>(simcall->args[0]);
662 }
663 static inline void simcall_comm_test__set__comm(smx_simcall_t simcall, smx_activity_t arg) {
664     simgrid::simix::marshal<smx_activity_t>(simcall->args[0], arg);
665 }
666 static inline int simcall_comm_test__get__result(smx_simcall_t simcall){
667     return simgrid::simix::unmarshal<int>(simcall->result);
668 }
669 static inline void simcall_comm_test__set__result(smx_simcall_t simcall, int result){
670     simgrid::simix::marshal<int>(simcall->result, result);
671 }
672
673 static inline smx_activity_t* simcall_comm_testany__get__comms(smx_simcall_t simcall) {
674   return simgrid::simix::unmarshal<smx_activity_t*>(simcall->args[0]);
675 }
676 static inline void simcall_comm_testany__set__comms(smx_simcall_t simcall, smx_activity_t* arg) {
677     simgrid::simix::marshal<smx_activity_t*>(simcall->args[0], arg);
678 }
679 static inline size_t simcall_comm_testany__get__count(smx_simcall_t simcall) {
680   return simgrid::simix::unmarshal<size_t>(simcall->args[1]);
681 }
682 static inline void simcall_comm_testany__set__count(smx_simcall_t simcall, size_t arg) {
683     simgrid::simix::marshal<size_t>(simcall->args[1], arg);
684 }
685 static inline int simcall_comm_testany__get__result(smx_simcall_t simcall){
686     return simgrid::simix::unmarshal<int>(simcall->result);
687 }
688 static inline void simcall_comm_testany__set__result(smx_simcall_t simcall, int result){
689     simgrid::simix::marshal<int>(simcall->result, result);
690 }
691
692 static inline smx_mutex_t simcall_mutex_init__get__result(smx_simcall_t simcall){
693     return simgrid::simix::unmarshal<smx_mutex_t>(simcall->result);
694 }
695 static inline void simcall_mutex_init__set__result(smx_simcall_t simcall, smx_mutex_t result){
696     simgrid::simix::marshal<smx_mutex_t>(simcall->result, result);
697 }
698
699 static inline smx_mutex_t simcall_mutex_lock__get__mutex(smx_simcall_t simcall) {
700   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[0]);
701 }
702 static inline void simcall_mutex_lock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg) {
703     simgrid::simix::marshal<smx_mutex_t>(simcall->args[0], arg);
704 }
705
706 static inline smx_mutex_t simcall_mutex_trylock__get__mutex(smx_simcall_t simcall) {
707   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[0]);
708 }
709 static inline void simcall_mutex_trylock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg) {
710     simgrid::simix::marshal<smx_mutex_t>(simcall->args[0], arg);
711 }
712 static inline int simcall_mutex_trylock__get__result(smx_simcall_t simcall){
713     return simgrid::simix::unmarshal<int>(simcall->result);
714 }
715 static inline void simcall_mutex_trylock__set__result(smx_simcall_t simcall, int result){
716     simgrid::simix::marshal<int>(simcall->result, result);
717 }
718
719 static inline smx_mutex_t simcall_mutex_unlock__get__mutex(smx_simcall_t simcall) {
720   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[0]);
721 }
722 static inline void simcall_mutex_unlock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg) {
723     simgrid::simix::marshal<smx_mutex_t>(simcall->args[0], arg);
724 }
725
726 static inline smx_cond_t simcall_cond_init__get__result(smx_simcall_t simcall){
727     return simgrid::simix::unmarshal<smx_cond_t>(simcall->result);
728 }
729 static inline void simcall_cond_init__set__result(smx_simcall_t simcall, smx_cond_t result){
730     simgrid::simix::marshal<smx_cond_t>(simcall->result, result);
731 }
732
733 static inline smx_cond_t simcall_cond_signal__get__cond(smx_simcall_t simcall) {
734   return simgrid::simix::unmarshal<smx_cond_t>(simcall->args[0]);
735 }
736 static inline void simcall_cond_signal__set__cond(smx_simcall_t simcall, smx_cond_t arg) {
737     simgrid::simix::marshal<smx_cond_t>(simcall->args[0], arg);
738 }
739
740 static inline smx_cond_t simcall_cond_wait__get__cond(smx_simcall_t simcall) {
741   return simgrid::simix::unmarshal<smx_cond_t>(simcall->args[0]);
742 }
743 static inline void simcall_cond_wait__set__cond(smx_simcall_t simcall, smx_cond_t arg) {
744     simgrid::simix::marshal<smx_cond_t>(simcall->args[0], arg);
745 }
746 static inline smx_mutex_t simcall_cond_wait__get__mutex(smx_simcall_t simcall) {
747   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[1]);
748 }
749 static inline void simcall_cond_wait__set__mutex(smx_simcall_t simcall, smx_mutex_t arg) {
750     simgrid::simix::marshal<smx_mutex_t>(simcall->args[1], arg);
751 }
752
753 static inline smx_cond_t simcall_cond_wait_timeout__get__cond(smx_simcall_t simcall) {
754   return simgrid::simix::unmarshal<smx_cond_t>(simcall->args[0]);
755 }
756 static inline void simcall_cond_wait_timeout__set__cond(smx_simcall_t simcall, smx_cond_t arg) {
757     simgrid::simix::marshal<smx_cond_t>(simcall->args[0], arg);
758 }
759 static inline smx_mutex_t simcall_cond_wait_timeout__get__mutex(smx_simcall_t simcall) {
760   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[1]);
761 }
762 static inline void simcall_cond_wait_timeout__set__mutex(smx_simcall_t simcall, smx_mutex_t arg) {
763     simgrid::simix::marshal<smx_mutex_t>(simcall->args[1], arg);
764 }
765 static inline double simcall_cond_wait_timeout__get__timeout(smx_simcall_t simcall) {
766   return simgrid::simix::unmarshal<double>(simcall->args[2]);
767 }
768 static inline void simcall_cond_wait_timeout__set__timeout(smx_simcall_t simcall, double arg) {
769     simgrid::simix::marshal<double>(simcall->args[2], arg);
770 }
771
772 static inline smx_cond_t simcall_cond_broadcast__get__cond(smx_simcall_t simcall) {
773   return simgrid::simix::unmarshal<smx_cond_t>(simcall->args[0]);
774 }
775 static inline void simcall_cond_broadcast__set__cond(smx_simcall_t simcall, smx_cond_t arg) {
776     simgrid::simix::marshal<smx_cond_t>(simcall->args[0], arg);
777 }
778
779 static inline unsigned int simcall_sem_init__get__capacity(smx_simcall_t simcall) {
780   return simgrid::simix::unmarshal<unsigned int>(simcall->args[0]);
781 }
782 static inline void simcall_sem_init__set__capacity(smx_simcall_t simcall, unsigned int arg) {
783     simgrid::simix::marshal<unsigned int>(simcall->args[0], arg);
784 }
785 static inline smx_sem_t simcall_sem_init__get__result(smx_simcall_t simcall){
786     return simgrid::simix::unmarshal<smx_sem_t>(simcall->result);
787 }
788 static inline void simcall_sem_init__set__result(smx_simcall_t simcall, smx_sem_t result){
789     simgrid::simix::marshal<smx_sem_t>(simcall->result, result);
790 }
791
792 static inline smx_sem_t simcall_sem_release__get__sem(smx_simcall_t simcall) {
793   return simgrid::simix::unmarshal<smx_sem_t>(simcall->args[0]);
794 }
795 static inline void simcall_sem_release__set__sem(smx_simcall_t simcall, smx_sem_t arg) {
796     simgrid::simix::marshal<smx_sem_t>(simcall->args[0], arg);
797 }
798
799 static inline smx_sem_t simcall_sem_would_block__get__sem(smx_simcall_t simcall) {
800   return simgrid::simix::unmarshal<smx_sem_t>(simcall->args[0]);
801 }
802 static inline void simcall_sem_would_block__set__sem(smx_simcall_t simcall, smx_sem_t arg) {
803     simgrid::simix::marshal<smx_sem_t>(simcall->args[0], arg);
804 }
805 static inline int simcall_sem_would_block__get__result(smx_simcall_t simcall){
806     return simgrid::simix::unmarshal<int>(simcall->result);
807 }
808 static inline void simcall_sem_would_block__set__result(smx_simcall_t simcall, int result){
809     simgrid::simix::marshal<int>(simcall->result, result);
810 }
811
812 static inline smx_sem_t simcall_sem_acquire__get__sem(smx_simcall_t simcall) {
813   return simgrid::simix::unmarshal<smx_sem_t>(simcall->args[0]);
814 }
815 static inline void simcall_sem_acquire__set__sem(smx_simcall_t simcall, smx_sem_t arg) {
816     simgrid::simix::marshal<smx_sem_t>(simcall->args[0], arg);
817 }
818
819 static inline smx_sem_t simcall_sem_acquire_timeout__get__sem(smx_simcall_t simcall) {
820   return simgrid::simix::unmarshal<smx_sem_t>(simcall->args[0]);
821 }
822 static inline void simcall_sem_acquire_timeout__set__sem(smx_simcall_t simcall, smx_sem_t arg) {
823     simgrid::simix::marshal<smx_sem_t>(simcall->args[0], arg);
824 }
825 static inline double simcall_sem_acquire_timeout__get__timeout(smx_simcall_t simcall) {
826   return simgrid::simix::unmarshal<double>(simcall->args[1]);
827 }
828 static inline void simcall_sem_acquire_timeout__set__timeout(smx_simcall_t simcall, double arg) {
829     simgrid::simix::marshal<double>(simcall->args[1], arg);
830 }
831
832 static inline smx_sem_t simcall_sem_get_capacity__get__sem(smx_simcall_t simcall) {
833   return simgrid::simix::unmarshal<smx_sem_t>(simcall->args[0]);
834 }
835 static inline void simcall_sem_get_capacity__set__sem(smx_simcall_t simcall, smx_sem_t arg) {
836     simgrid::simix::marshal<smx_sem_t>(simcall->args[0], arg);
837 }
838 static inline int simcall_sem_get_capacity__get__result(smx_simcall_t simcall){
839     return simgrid::simix::unmarshal<int>(simcall->result);
840 }
841 static inline void simcall_sem_get_capacity__set__result(smx_simcall_t simcall, int result){
842     simgrid::simix::marshal<int>(simcall->result, result);
843 }
844
845 static inline smx_file_t simcall_file_read__get__fd(smx_simcall_t simcall) {
846   return simgrid::simix::unmarshal<smx_file_t>(simcall->args[0]);
847 }
848 static inline void simcall_file_read__set__fd(smx_simcall_t simcall, smx_file_t arg) {
849     simgrid::simix::marshal<smx_file_t>(simcall->args[0], arg);
850 }
851 static inline sg_size_t simcall_file_read__get__size(smx_simcall_t simcall) {
852   return simgrid::simix::unmarshal<sg_size_t>(simcall->args[1]);
853 }
854 static inline void simcall_file_read__set__size(smx_simcall_t simcall, sg_size_t arg) {
855     simgrid::simix::marshal<sg_size_t>(simcall->args[1], arg);
856 }
857 static inline sg_host_t simcall_file_read__get__host(smx_simcall_t simcall) {
858   return simgrid::simix::unmarshal<sg_host_t>(simcall->args[2]);
859 }
860 static inline void simcall_file_read__set__host(smx_simcall_t simcall, sg_host_t arg) {
861     simgrid::simix::marshal<sg_host_t>(simcall->args[2], arg);
862 }
863 static inline sg_size_t simcall_file_read__get__result(smx_simcall_t simcall){
864     return simgrid::simix::unmarshal<sg_size_t>(simcall->result);
865 }
866 static inline void simcall_file_read__set__result(smx_simcall_t simcall, sg_size_t result){
867     simgrid::simix::marshal<sg_size_t>(simcall->result, result);
868 }
869
870 static inline smx_file_t simcall_file_write__get__fd(smx_simcall_t simcall) {
871   return simgrid::simix::unmarshal<smx_file_t>(simcall->args[0]);
872 }
873 static inline void simcall_file_write__set__fd(smx_simcall_t simcall, smx_file_t arg) {
874     simgrid::simix::marshal<smx_file_t>(simcall->args[0], arg);
875 }
876 static inline sg_size_t simcall_file_write__get__size(smx_simcall_t simcall) {
877   return simgrid::simix::unmarshal<sg_size_t>(simcall->args[1]);
878 }
879 static inline void simcall_file_write__set__size(smx_simcall_t simcall, sg_size_t arg) {
880     simgrid::simix::marshal<sg_size_t>(simcall->args[1], arg);
881 }
882 static inline sg_host_t simcall_file_write__get__host(smx_simcall_t simcall) {
883   return simgrid::simix::unmarshal<sg_host_t>(simcall->args[2]);
884 }
885 static inline void simcall_file_write__set__host(smx_simcall_t simcall, sg_host_t arg) {
886     simgrid::simix::marshal<sg_host_t>(simcall->args[2], arg);
887 }
888 static inline sg_size_t simcall_file_write__get__result(smx_simcall_t simcall){
889     return simgrid::simix::unmarshal<sg_size_t>(simcall->result);
890 }
891 static inline void simcall_file_write__set__result(smx_simcall_t simcall, sg_size_t result){
892     simgrid::simix::marshal<sg_size_t>(simcall->result, result);
893 }
894
895 static inline const char* simcall_file_open__get__fullpath(smx_simcall_t simcall) {
896   return simgrid::simix::unmarshal<const char*>(simcall->args[0]);
897 }
898 static inline void simcall_file_open__set__fullpath(smx_simcall_t simcall, const char* arg) {
899     simgrid::simix::marshal<const char*>(simcall->args[0], arg);
900 }
901 static inline sg_host_t simcall_file_open__get__host(smx_simcall_t simcall) {
902   return simgrid::simix::unmarshal<sg_host_t>(simcall->args[1]);
903 }
904 static inline void simcall_file_open__set__host(smx_simcall_t simcall, sg_host_t arg) {
905     simgrid::simix::marshal<sg_host_t>(simcall->args[1], arg);
906 }
907 static inline smx_file_t simcall_file_open__get__result(smx_simcall_t simcall){
908     return simgrid::simix::unmarshal<smx_file_t>(simcall->result);
909 }
910 static inline void simcall_file_open__set__result(smx_simcall_t simcall, smx_file_t result){
911     simgrid::simix::marshal<smx_file_t>(simcall->result, result);
912 }
913
914 static inline smx_file_t simcall_file_close__get__fd(smx_simcall_t simcall) {
915   return simgrid::simix::unmarshal<smx_file_t>(simcall->args[0]);
916 }
917 static inline void simcall_file_close__set__fd(smx_simcall_t simcall, smx_file_t arg) {
918     simgrid::simix::marshal<smx_file_t>(simcall->args[0], arg);
919 }
920 static inline sg_host_t simcall_file_close__get__host(smx_simcall_t simcall) {
921   return simgrid::simix::unmarshal<sg_host_t>(simcall->args[1]);
922 }
923 static inline void simcall_file_close__set__host(smx_simcall_t simcall, sg_host_t arg) {
924     simgrid::simix::marshal<sg_host_t>(simcall->args[1], arg);
925 }
926 static inline int simcall_file_close__get__result(smx_simcall_t simcall){
927     return simgrid::simix::unmarshal<int>(simcall->result);
928 }
929 static inline void simcall_file_close__set__result(smx_simcall_t simcall, int result){
930     simgrid::simix::marshal<int>(simcall->result, result);
931 }
932
933 static inline smx_file_t simcall_file_unlink__get__fd(smx_simcall_t simcall) {
934   return simgrid::simix::unmarshal<smx_file_t>(simcall->args[0]);
935 }
936 static inline void simcall_file_unlink__set__fd(smx_simcall_t simcall, smx_file_t arg) {
937     simgrid::simix::marshal<smx_file_t>(simcall->args[0], arg);
938 }
939 static inline sg_host_t simcall_file_unlink__get__host(smx_simcall_t simcall) {
940   return simgrid::simix::unmarshal<sg_host_t>(simcall->args[1]);
941 }
942 static inline void simcall_file_unlink__set__host(smx_simcall_t simcall, sg_host_t arg) {
943     simgrid::simix::marshal<sg_host_t>(simcall->args[1], arg);
944 }
945 static inline int simcall_file_unlink__get__result(smx_simcall_t simcall){
946     return simgrid::simix::unmarshal<int>(simcall->result);
947 }
948 static inline void simcall_file_unlink__set__result(smx_simcall_t simcall, int result){
949     simgrid::simix::marshal<int>(simcall->result, result);
950 }
951
952 static inline smx_file_t simcall_file_get_size__get__fd(smx_simcall_t simcall) {
953   return simgrid::simix::unmarshal<smx_file_t>(simcall->args[0]);
954 }
955 static inline void simcall_file_get_size__set__fd(smx_simcall_t simcall, smx_file_t arg) {
956     simgrid::simix::marshal<smx_file_t>(simcall->args[0], arg);
957 }
958 static inline sg_size_t simcall_file_get_size__get__result(smx_simcall_t simcall){
959     return simgrid::simix::unmarshal<sg_size_t>(simcall->result);
960 }
961 static inline void simcall_file_get_size__set__result(smx_simcall_t simcall, sg_size_t result){
962     simgrid::simix::marshal<sg_size_t>(simcall->result, result);
963 }
964
965 static inline smx_file_t simcall_file_tell__get__fd(smx_simcall_t simcall) {
966   return simgrid::simix::unmarshal<smx_file_t>(simcall->args[0]);
967 }
968 static inline void simcall_file_tell__set__fd(smx_simcall_t simcall, smx_file_t arg) {
969     simgrid::simix::marshal<smx_file_t>(simcall->args[0], arg);
970 }
971 static inline sg_size_t simcall_file_tell__get__result(smx_simcall_t simcall){
972     return simgrid::simix::unmarshal<sg_size_t>(simcall->result);
973 }
974 static inline void simcall_file_tell__set__result(smx_simcall_t simcall, sg_size_t result){
975     simgrid::simix::marshal<sg_size_t>(simcall->result, result);
976 }
977
978 static inline smx_file_t simcall_file_seek__get__fd(smx_simcall_t simcall) {
979   return simgrid::simix::unmarshal<smx_file_t>(simcall->args[0]);
980 }
981 static inline void simcall_file_seek__set__fd(smx_simcall_t simcall, smx_file_t arg) {
982     simgrid::simix::marshal<smx_file_t>(simcall->args[0], arg);
983 }
984 static inline sg_offset_t simcall_file_seek__get__offset(smx_simcall_t simcall) {
985   return simgrid::simix::unmarshal<sg_offset_t>(simcall->args[1]);
986 }
987 static inline void simcall_file_seek__set__offset(smx_simcall_t simcall, sg_offset_t arg) {
988     simgrid::simix::marshal<sg_offset_t>(simcall->args[1], arg);
989 }
990 static inline int simcall_file_seek__get__origin(smx_simcall_t simcall) {
991   return simgrid::simix::unmarshal<int>(simcall->args[2]);
992 }
993 static inline void simcall_file_seek__set__origin(smx_simcall_t simcall, int arg) {
994     simgrid::simix::marshal<int>(simcall->args[2], arg);
995 }
996 static inline int simcall_file_seek__get__result(smx_simcall_t simcall){
997     return simgrid::simix::unmarshal<int>(simcall->result);
998 }
999 static inline void simcall_file_seek__set__result(smx_simcall_t simcall, int result){
1000     simgrid::simix::marshal<int>(simcall->result, result);
1001 }
1002
1003 static inline smx_file_t simcall_file_get_info__get__fd(smx_simcall_t simcall) {
1004   return simgrid::simix::unmarshal<smx_file_t>(simcall->args[0]);
1005 }
1006 static inline void simcall_file_get_info__set__fd(smx_simcall_t simcall, smx_file_t arg) {
1007     simgrid::simix::marshal<smx_file_t>(simcall->args[0], arg);
1008 }
1009 static inline xbt_dynar_t simcall_file_get_info__get__result(smx_simcall_t simcall){
1010     return simgrid::simix::unmarshal<xbt_dynar_t>(simcall->result);
1011 }
1012 static inline void simcall_file_get_info__set__result(smx_simcall_t simcall, xbt_dynar_t result){
1013     simgrid::simix::marshal<xbt_dynar_t>(simcall->result, result);
1014 }
1015
1016 static inline smx_file_t simcall_file_move__get__fd(smx_simcall_t simcall) {
1017   return simgrid::simix::unmarshal<smx_file_t>(simcall->args[0]);
1018 }
1019 static inline void simcall_file_move__set__fd(smx_simcall_t simcall, smx_file_t arg) {
1020     simgrid::simix::marshal<smx_file_t>(simcall->args[0], arg);
1021 }
1022 static inline const char* simcall_file_move__get__fullpath(smx_simcall_t simcall) {
1023   return simgrid::simix::unmarshal<const char*>(simcall->args[1]);
1024 }
1025 static inline void simcall_file_move__set__fullpath(smx_simcall_t simcall, const char* arg) {
1026     simgrid::simix::marshal<const char*>(simcall->args[1], arg);
1027 }
1028 static inline int simcall_file_move__get__result(smx_simcall_t simcall){
1029     return simgrid::simix::unmarshal<int>(simcall->result);
1030 }
1031 static inline void simcall_file_move__set__result(smx_simcall_t simcall, int result){
1032     simgrid::simix::marshal<int>(simcall->result, result);
1033 }
1034
1035 static inline smx_storage_t simcall_storage_get_free_size__get__storage(smx_simcall_t simcall) {
1036   return simgrid::simix::unmarshal<smx_storage_t>(simcall->args[0]);
1037 }
1038 static inline void simcall_storage_get_free_size__set__storage(smx_simcall_t simcall, smx_storage_t arg) {
1039     simgrid::simix::marshal<smx_storage_t>(simcall->args[0], arg);
1040 }
1041 static inline sg_size_t simcall_storage_get_free_size__get__result(smx_simcall_t simcall){
1042     return simgrid::simix::unmarshal<sg_size_t>(simcall->result);
1043 }
1044 static inline void simcall_storage_get_free_size__set__result(smx_simcall_t simcall, sg_size_t result){
1045     simgrid::simix::marshal<sg_size_t>(simcall->result, result);
1046 }
1047
1048 static inline smx_storage_t simcall_storage_get_used_size__get__name(smx_simcall_t simcall) {
1049   return simgrid::simix::unmarshal<smx_storage_t>(simcall->args[0]);
1050 }
1051 static inline void simcall_storage_get_used_size__set__name(smx_simcall_t simcall, smx_storage_t arg) {
1052     simgrid::simix::marshal<smx_storage_t>(simcall->args[0], arg);
1053 }
1054 static inline sg_size_t simcall_storage_get_used_size__get__result(smx_simcall_t simcall){
1055     return simgrid::simix::unmarshal<sg_size_t>(simcall->result);
1056 }
1057 static inline void simcall_storage_get_used_size__set__result(smx_simcall_t simcall, sg_size_t result){
1058     simgrid::simix::marshal<sg_size_t>(simcall->result, result);
1059 }
1060
1061 static inline smx_storage_t simcall_storage_get_properties__get__storage(smx_simcall_t simcall) {
1062   return simgrid::simix::unmarshal<smx_storage_t>(simcall->args[0]);
1063 }
1064 static inline void simcall_storage_get_properties__set__storage(smx_simcall_t simcall, smx_storage_t arg) {
1065     simgrid::simix::marshal<smx_storage_t>(simcall->args[0], arg);
1066 }
1067 static inline xbt_dict_t simcall_storage_get_properties__get__result(smx_simcall_t simcall){
1068     return simgrid::simix::unmarshal<xbt_dict_t>(simcall->result);
1069 }
1070 static inline void simcall_storage_get_properties__set__result(smx_simcall_t simcall, xbt_dict_t result){
1071     simgrid::simix::marshal<xbt_dict_t>(simcall->result, result);
1072 }
1073
1074 static inline smx_storage_t simcall_storage_get_content__get__storage(smx_simcall_t simcall) {
1075   return simgrid::simix::unmarshal<smx_storage_t>(simcall->args[0]);
1076 }
1077 static inline void simcall_storage_get_content__set__storage(smx_simcall_t simcall, smx_storage_t arg) {
1078     simgrid::simix::marshal<smx_storage_t>(simcall->args[0], arg);
1079 }
1080 static inline xbt_dict_t simcall_storage_get_content__get__result(smx_simcall_t simcall){
1081     return simgrid::simix::unmarshal<xbt_dict_t>(simcall->result);
1082 }
1083 static inline void simcall_storage_get_content__set__result(smx_simcall_t simcall, xbt_dict_t result){
1084     simgrid::simix::marshal<xbt_dict_t>(simcall->result, result);
1085 }
1086
1087 static inline const char* simcall_asr_get_properties__get__name(smx_simcall_t simcall) {
1088   return simgrid::simix::unmarshal<const char*>(simcall->args[0]);
1089 }
1090 static inline void simcall_asr_get_properties__set__name(smx_simcall_t simcall, const char* arg) {
1091     simgrid::simix::marshal<const char*>(simcall->args[0], arg);
1092 }
1093 static inline xbt_dict_t simcall_asr_get_properties__get__result(smx_simcall_t simcall){
1094     return simgrid::simix::unmarshal<xbt_dict_t>(simcall->result);
1095 }
1096 static inline void simcall_asr_get_properties__set__result(smx_simcall_t simcall, xbt_dict_t result){
1097     simgrid::simix::marshal<xbt_dict_t>(simcall->result, result);
1098 }
1099
1100 static inline int simcall_mc_random__get__min(smx_simcall_t simcall) {
1101   return simgrid::simix::unmarshal<int>(simcall->args[0]);
1102 }
1103 static inline void simcall_mc_random__set__min(smx_simcall_t simcall, int arg) {
1104     simgrid::simix::marshal<int>(simcall->args[0], arg);
1105 }
1106 static inline int simcall_mc_random__get__max(smx_simcall_t simcall) {
1107   return simgrid::simix::unmarshal<int>(simcall->args[1]);
1108 }
1109 static inline void simcall_mc_random__set__max(smx_simcall_t simcall, int arg) {
1110     simgrid::simix::marshal<int>(simcall->args[1], arg);
1111 }
1112 static inline int simcall_mc_random__get__result(smx_simcall_t simcall){
1113     return simgrid::simix::unmarshal<int>(simcall->result);
1114 }
1115 static inline void simcall_mc_random__set__result(smx_simcall_t simcall, int result){
1116     simgrid::simix::marshal<int>(simcall->result, result);
1117 }
1118
1119 static inline smx_activity_t simcall_set_category__get__synchro(smx_simcall_t simcall) {
1120   return simgrid::simix::unmarshal<smx_activity_t>(simcall->args[0]);
1121 }
1122 static inline void simcall_set_category__set__synchro(smx_simcall_t simcall, smx_activity_t arg) {
1123     simgrid::simix::marshal<smx_activity_t>(simcall->args[0], arg);
1124 }
1125 static inline const char* simcall_set_category__get__category(smx_simcall_t simcall) {
1126   return simgrid::simix::unmarshal<const char*>(simcall->args[1]);
1127 }
1128 static inline void simcall_set_category__set__category(smx_simcall_t simcall, const char* arg) {
1129     simgrid::simix::marshal<const char*>(simcall->args[1], arg);
1130 }
1131
1132 static inline std::function<void()> const* simcall_run_kernel__get__code(smx_simcall_t simcall) {
1133   return simgrid::simix::unmarshal<std::function<void()> const*>(simcall->args[0]);
1134 }
1135 static inline void simcall_run_kernel__set__code(smx_simcall_t simcall, std::function<void()> const* arg) {
1136     simgrid::simix::marshal<std::function<void()> const*>(simcall->args[0], arg);
1137 }
1138
1139 static inline std::function<void()> const* simcall_run_blocking__get__code(smx_simcall_t simcall) {
1140   return simgrid::simix::unmarshal<std::function<void()> const*>(simcall->args[0]);
1141 }
1142 static inline void simcall_run_blocking__set__code(smx_simcall_t simcall, std::function<void()> const* arg) {
1143     simgrid::simix::marshal<std::function<void()> const*>(simcall->args[0], arg);
1144 }
1145
1146 /* The prototype of all simcall handlers, automatically generated for you */
1147
1148 XBT_PRIVATE void simcall_HANDLER_vm_suspend(smx_simcall_t simcall, sg_host_t ind_vm);
1149 XBT_PRIVATE void simcall_HANDLER_vm_shutdown(smx_simcall_t simcall, sg_host_t ind_vm);
1150 XBT_PRIVATE void simcall_HANDLER_vm_save(smx_simcall_t simcall, sg_host_t ind_vm);
1151 XBT_PRIVATE void simcall_HANDLER_process_kill(smx_simcall_t simcall, smx_actor_t process);
1152 XBT_PRIVATE void simcall_HANDLER_process_killall(smx_simcall_t simcall, int reset_pid);
1153 XBT_PRIVATE void simcall_HANDLER_process_suspend(smx_simcall_t simcall, smx_actor_t process);
1154 XBT_PRIVATE void simcall_HANDLER_process_set_host(smx_simcall_t simcall, smx_actor_t process, sg_host_t dest);
1155 XBT_PRIVATE void simcall_HANDLER_process_join(smx_simcall_t simcall, smx_actor_t process, double timeout);
1156 XBT_PRIVATE void simcall_HANDLER_process_sleep(smx_simcall_t simcall, double duration);
1157 XBT_PRIVATE smx_activity_t simcall_HANDLER_execution_start(smx_simcall_t simcall, const char* name, double flops_amount, double priority, double bound);
1158 XBT_PRIVATE void simcall_HANDLER_execution_wait(smx_simcall_t simcall, smx_activity_t execution);
1159 XBT_PRIVATE smx_actor_t simcall_HANDLER_process_restart(smx_simcall_t simcall, smx_actor_t process);
1160 XBT_PRIVATE smx_activity_t simcall_HANDLER_comm_iprobe(smx_simcall_t simcall, smx_mailbox_t mbox, int type, int src, int tag, simix_match_func_t match_fun, void* data);
1161 XBT_PRIVATE void simcall_HANDLER_comm_send(smx_simcall_t simcall, smx_actor_t sender, smx_mailbox_t mbox, 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);
1162 XBT_PRIVATE smx_activity_t simcall_HANDLER_comm_isend(smx_simcall_t simcall, smx_actor_t sender, smx_mailbox_t mbox, 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);
1163 XBT_PRIVATE void simcall_HANDLER_comm_recv(smx_simcall_t simcall, smx_actor_t receiver, smx_mailbox_t mbox, 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);
1164 XBT_PRIVATE smx_activity_t simcall_HANDLER_comm_irecv(smx_simcall_t simcall, smx_actor_t receiver, smx_mailbox_t mbox, 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);
1165 XBT_PRIVATE void simcall_HANDLER_comm_waitany(smx_simcall_t simcall, xbt_dynar_t comms, double timeout);
1166 XBT_PRIVATE void simcall_HANDLER_comm_wait(smx_simcall_t simcall, smx_activity_t comm, double timeout);
1167 XBT_PRIVATE void simcall_HANDLER_comm_test(smx_simcall_t simcall, smx_activity_t comm);
1168 XBT_PRIVATE void simcall_HANDLER_comm_testany(smx_simcall_t simcall, smx_activity_t* comms, size_t count);
1169 XBT_PRIVATE smx_mutex_t simcall_HANDLER_mutex_init(smx_simcall_t simcall);
1170 XBT_PRIVATE void simcall_HANDLER_mutex_lock(smx_simcall_t simcall, smx_mutex_t mutex);
1171 XBT_PRIVATE int simcall_HANDLER_mutex_trylock(smx_simcall_t simcall, smx_mutex_t mutex);
1172 XBT_PRIVATE void simcall_HANDLER_mutex_unlock(smx_simcall_t simcall, smx_mutex_t mutex);
1173 XBT_PRIVATE void simcall_HANDLER_cond_wait(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex);
1174 XBT_PRIVATE void simcall_HANDLER_cond_wait_timeout(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex, double timeout);
1175 XBT_PRIVATE void simcall_HANDLER_sem_release(smx_simcall_t simcall, smx_sem_t sem);
1176 XBT_PRIVATE int simcall_HANDLER_sem_would_block(smx_simcall_t simcall, smx_sem_t sem);
1177 XBT_PRIVATE void simcall_HANDLER_sem_acquire(smx_simcall_t simcall, smx_sem_t sem);
1178 XBT_PRIVATE void simcall_HANDLER_sem_acquire_timeout(smx_simcall_t simcall, smx_sem_t sem, double timeout);
1179 XBT_PRIVATE int simcall_HANDLER_sem_get_capacity(smx_simcall_t simcall, smx_sem_t sem);
1180 XBT_PRIVATE void simcall_HANDLER_file_read(smx_simcall_t simcall, smx_file_t fd, sg_size_t size, sg_host_t host);
1181 XBT_PRIVATE void simcall_HANDLER_file_write(smx_simcall_t simcall, smx_file_t fd, sg_size_t size, sg_host_t host);
1182 XBT_PRIVATE void simcall_HANDLER_file_open(smx_simcall_t simcall, const char* fullpath, sg_host_t host);
1183 XBT_PRIVATE void simcall_HANDLER_file_close(smx_simcall_t simcall, smx_file_t fd, sg_host_t host);
1184 XBT_PRIVATE sg_size_t simcall_HANDLER_file_get_size(smx_simcall_t simcall, smx_file_t fd);
1185 XBT_PRIVATE sg_size_t simcall_HANDLER_file_tell(smx_simcall_t simcall, smx_file_t fd);
1186 XBT_PRIVATE int simcall_HANDLER_file_seek(smx_simcall_t simcall, smx_file_t fd, sg_offset_t offset, int origin);
1187 XBT_PRIVATE xbt_dynar_t simcall_HANDLER_file_get_info(smx_simcall_t simcall, smx_file_t fd);
1188 XBT_PRIVATE int simcall_HANDLER_file_move(smx_simcall_t simcall, smx_file_t fd, const char* fullpath);
1189 XBT_PRIVATE sg_size_t simcall_HANDLER_storage_get_free_size(smx_simcall_t simcall, smx_storage_t storage);
1190 XBT_PRIVATE sg_size_t simcall_HANDLER_storage_get_used_size(smx_simcall_t simcall, smx_storage_t name);
1191 XBT_PRIVATE xbt_dict_t simcall_HANDLER_asr_get_properties(smx_simcall_t simcall, const char* name);
1192 XBT_PRIVATE int simcall_HANDLER_mc_random(smx_simcall_t simcall, int min, int max);