Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
kill kill 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 /* Copyright (c) 2014-2017. The SimGrid Team. All rights reserved.    */
8 /**********************************************************************/
9
10 /*
11  * Note that the name comes from http://en.wikipedia.org/wiki/Popping
12  * Indeed, the control flow is doing a strange dance in there.
13  *
14  * That's not about http://en.wikipedia.org/wiki/Poop, despite the odor :)
15  */
16
17 #include "src/simix/popping_private.h"
18 static inline int simcall_process_killall__get__reset_pid(smx_simcall_t simcall)
19 {
20   return simgrid::simix::unmarshal<int>(simcall->args[0]);
21 }
22 static inline int simcall_process_killall__getraw__reset_pid(smx_simcall_t simcall)
23 {
24   return simgrid::simix::unmarshal_raw<int>(simcall->args[0]);
25 }
26 static inline void simcall_process_killall__set__reset_pid(smx_simcall_t simcall, int arg)
27 {
28   simgrid::simix::marshal<int>(simcall->args[0], arg);
29 }
30
31 static inline smx_actor_t simcall_process_cleanup__get__process(smx_simcall_t simcall)
32 {
33   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
34 }
35 static inline smx_actor_t simcall_process_cleanup__getraw__process(smx_simcall_t simcall)
36 {
37   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
38 }
39 static inline void simcall_process_cleanup__set__process(smx_simcall_t simcall, smx_actor_t arg)
40 {
41   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
42 }
43
44 static inline smx_actor_t simcall_process_suspend__get__process(smx_simcall_t simcall)
45 {
46   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
47 }
48 static inline smx_actor_t simcall_process_suspend__getraw__process(smx_simcall_t simcall)
49 {
50   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
51 }
52 static inline void simcall_process_suspend__set__process(smx_simcall_t simcall, smx_actor_t arg)
53 {
54   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
55 }
56
57 static inline smx_actor_t simcall_process_join__get__process(smx_simcall_t simcall)
58 {
59   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
60 }
61 static inline smx_actor_t simcall_process_join__getraw__process(smx_simcall_t simcall)
62 {
63   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
64 }
65 static inline void simcall_process_join__set__process(smx_simcall_t simcall, smx_actor_t arg)
66 {
67   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
68 }
69 static inline double simcall_process_join__get__timeout(smx_simcall_t simcall)
70 {
71   return simgrid::simix::unmarshal<double>(simcall->args[1]);
72 }
73 static inline double simcall_process_join__getraw__timeout(smx_simcall_t simcall)
74 {
75   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
76 }
77 static inline void simcall_process_join__set__timeout(smx_simcall_t simcall, double arg)
78 {
79   simgrid::simix::marshal<double>(simcall->args[1], arg);
80 }
81 static inline int simcall_process_join__get__result(smx_simcall_t simcall)
82 {
83   return simgrid::simix::unmarshal<int>(simcall->result);
84 }
85 static inline int simcall_process_join__getraw__result(smx_simcall_t simcall)
86 {
87   return simgrid::simix::unmarshal_raw<int>(simcall->result);
88 }
89 static inline void simcall_process_join__set__result(smx_simcall_t simcall, int result){
90     simgrid::simix::marshal<int>(simcall->result, result);
91 }
92
93 static inline double simcall_process_sleep__get__duration(smx_simcall_t simcall)
94 {
95   return simgrid::simix::unmarshal<double>(simcall->args[0]);
96 }
97 static inline double simcall_process_sleep__getraw__duration(smx_simcall_t simcall)
98 {
99   return simgrid::simix::unmarshal_raw<double>(simcall->args[0]);
100 }
101 static inline void simcall_process_sleep__set__duration(smx_simcall_t simcall, double arg)
102 {
103   simgrid::simix::marshal<double>(simcall->args[0], arg);
104 }
105 static inline int simcall_process_sleep__get__result(smx_simcall_t simcall)
106 {
107   return simgrid::simix::unmarshal<int>(simcall->result);
108 }
109 static inline int simcall_process_sleep__getraw__result(smx_simcall_t simcall)
110 {
111   return simgrid::simix::unmarshal_raw<int>(simcall->result);
112 }
113 static inline void simcall_process_sleep__set__result(smx_simcall_t simcall, int result){
114     simgrid::simix::marshal<int>(simcall->result, result);
115 }
116
117 static inline const char* simcall_execution_start__get__name(smx_simcall_t simcall)
118 {
119   return simgrid::simix::unmarshal<const char*>(simcall->args[0]);
120 }
121 static inline const char* simcall_execution_start__getraw__name(smx_simcall_t simcall)
122 {
123   return simgrid::simix::unmarshal_raw<const char*>(simcall->args[0]);
124 }
125 static inline void simcall_execution_start__set__name(smx_simcall_t simcall, const char* arg)
126 {
127   simgrid::simix::marshal<const char*>(simcall->args[0], arg);
128 }
129 static inline double simcall_execution_start__get__flops_amount(smx_simcall_t simcall)
130 {
131   return simgrid::simix::unmarshal<double>(simcall->args[1]);
132 }
133 static inline double simcall_execution_start__getraw__flops_amount(smx_simcall_t simcall)
134 {
135   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
136 }
137 static inline void simcall_execution_start__set__flops_amount(smx_simcall_t simcall, double arg)
138 {
139   simgrid::simix::marshal<double>(simcall->args[1], arg);
140 }
141 static inline double simcall_execution_start__get__priority(smx_simcall_t simcall)
142 {
143   return simgrid::simix::unmarshal<double>(simcall->args[2]);
144 }
145 static inline double simcall_execution_start__getraw__priority(smx_simcall_t simcall)
146 {
147   return simgrid::simix::unmarshal_raw<double>(simcall->args[2]);
148 }
149 static inline void simcall_execution_start__set__priority(smx_simcall_t simcall, double arg)
150 {
151   simgrid::simix::marshal<double>(simcall->args[2], arg);
152 }
153 static inline double simcall_execution_start__get__bound(smx_simcall_t simcall)
154 {
155   return simgrid::simix::unmarshal<double>(simcall->args[3]);
156 }
157 static inline double simcall_execution_start__getraw__bound(smx_simcall_t simcall)
158 {
159   return simgrid::simix::unmarshal_raw<double>(simcall->args[3]);
160 }
161 static inline void simcall_execution_start__set__bound(smx_simcall_t simcall, double arg)
162 {
163   simgrid::simix::marshal<double>(simcall->args[3], arg);
164 }
165 static inline boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl>
166 simcall_execution_start__get__result(smx_simcall_t simcall)
167 {
168   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl>>(simcall->result);
169 }
170 static inline simgrid::kernel::activity::ExecImpl* simcall_execution_start__getraw__result(smx_simcall_t simcall)
171 {
172   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ExecImpl*>(simcall->result);
173 }
174 static inline void
175 simcall_execution_start__set__result(smx_simcall_t simcall,
176                                      boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl> result)
177 {
178   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl>>(simcall->result, result);
179 }
180
181 static inline const char* simcall_execution_parallel_start__get__name(smx_simcall_t simcall)
182 {
183   return simgrid::simix::unmarshal<const char*>(simcall->args[0]);
184 }
185 static inline const char* simcall_execution_parallel_start__getraw__name(smx_simcall_t simcall)
186 {
187   return simgrid::simix::unmarshal_raw<const char*>(simcall->args[0]);
188 }
189 static inline void simcall_execution_parallel_start__set__name(smx_simcall_t simcall, const char* arg)
190 {
191   simgrid::simix::marshal<const char*>(simcall->args[0], arg);
192 }
193 static inline int simcall_execution_parallel_start__get__host_nb(smx_simcall_t simcall)
194 {
195   return simgrid::simix::unmarshal<int>(simcall->args[1]);
196 }
197 static inline int simcall_execution_parallel_start__getraw__host_nb(smx_simcall_t simcall)
198 {
199   return simgrid::simix::unmarshal_raw<int>(simcall->args[1]);
200 }
201 static inline void simcall_execution_parallel_start__set__host_nb(smx_simcall_t simcall, int arg)
202 {
203   simgrid::simix::marshal<int>(simcall->args[1], arg);
204 }
205 static inline sg_host_t* simcall_execution_parallel_start__get__host_list(smx_simcall_t simcall)
206 {
207   return simgrid::simix::unmarshal<sg_host_t*>(simcall->args[2]);
208 }
209 static inline sg_host_t* simcall_execution_parallel_start__getraw__host_list(smx_simcall_t simcall)
210 {
211   return simgrid::simix::unmarshal_raw<sg_host_t*>(simcall->args[2]);
212 }
213 static inline void simcall_execution_parallel_start__set__host_list(smx_simcall_t simcall, sg_host_t* arg)
214 {
215   simgrid::simix::marshal<sg_host_t*>(simcall->args[2], arg);
216 }
217 static inline double* simcall_execution_parallel_start__get__flops_amount(smx_simcall_t simcall)
218 {
219   return simgrid::simix::unmarshal<double*>(simcall->args[3]);
220 }
221 static inline double* simcall_execution_parallel_start__getraw__flops_amount(smx_simcall_t simcall)
222 {
223   return simgrid::simix::unmarshal_raw<double*>(simcall->args[3]);
224 }
225 static inline void simcall_execution_parallel_start__set__flops_amount(smx_simcall_t simcall, double* arg)
226 {
227   simgrid::simix::marshal<double*>(simcall->args[3], arg);
228 }
229 static inline double* simcall_execution_parallel_start__get__bytes_amount(smx_simcall_t simcall)
230 {
231   return simgrid::simix::unmarshal<double*>(simcall->args[4]);
232 }
233 static inline double* simcall_execution_parallel_start__getraw__bytes_amount(smx_simcall_t simcall)
234 {
235   return simgrid::simix::unmarshal_raw<double*>(simcall->args[4]);
236 }
237 static inline void simcall_execution_parallel_start__set__bytes_amount(smx_simcall_t simcall, double* arg)
238 {
239   simgrid::simix::marshal<double*>(simcall->args[4], arg);
240 }
241 static inline double simcall_execution_parallel_start__get__rate(smx_simcall_t simcall)
242 {
243   return simgrid::simix::unmarshal<double>(simcall->args[5]);
244 }
245 static inline double simcall_execution_parallel_start__getraw__rate(smx_simcall_t simcall)
246 {
247   return simgrid::simix::unmarshal_raw<double>(simcall->args[5]);
248 }
249 static inline void simcall_execution_parallel_start__set__rate(smx_simcall_t simcall, double arg)
250 {
251   simgrid::simix::marshal<double>(simcall->args[5], arg);
252 }
253 static inline double simcall_execution_parallel_start__get__timeout(smx_simcall_t simcall)
254 {
255   return simgrid::simix::unmarshal<double>(simcall->args[6]);
256 }
257 static inline double simcall_execution_parallel_start__getraw__timeout(smx_simcall_t simcall)
258 {
259   return simgrid::simix::unmarshal_raw<double>(simcall->args[6]);
260 }
261 static inline void simcall_execution_parallel_start__set__timeout(smx_simcall_t simcall, double arg)
262 {
263   simgrid::simix::marshal<double>(simcall->args[6], arg);
264 }
265 static inline boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl>
266 simcall_execution_parallel_start__get__result(smx_simcall_t simcall)
267 {
268   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl>>(simcall->result);
269 }
270 static inline simgrid::kernel::activity::ExecImpl*
271 simcall_execution_parallel_start__getraw__result(smx_simcall_t simcall)
272 {
273   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ExecImpl*>(simcall->result);
274 }
275 static inline void
276 simcall_execution_parallel_start__set__result(smx_simcall_t simcall,
277                                               boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl> result)
278 {
279   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl>>(simcall->result, result);
280 }
281
282 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
283 simcall_execution_cancel__get__execution(smx_simcall_t simcall)
284 {
285   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
286 }
287 static inline simgrid::kernel::activity::ActivityImpl*
288 simcall_execution_cancel__getraw__execution(smx_simcall_t simcall)
289 {
290   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
291 }
292 static inline void
293 simcall_execution_cancel__set__execution(smx_simcall_t simcall,
294                                          boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
295 {
296   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
297 }
298
299 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
300 simcall_execution_set_priority__get__execution(smx_simcall_t simcall)
301 {
302   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
303 }
304 static inline simgrid::kernel::activity::ActivityImpl*
305 simcall_execution_set_priority__getraw__execution(smx_simcall_t simcall)
306 {
307   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
308 }
309 static inline void
310 simcall_execution_set_priority__set__execution(smx_simcall_t simcall,
311                                                boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
312 {
313   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
314 }
315 static inline double simcall_execution_set_priority__get__priority(smx_simcall_t simcall)
316 {
317   return simgrid::simix::unmarshal<double>(simcall->args[1]);
318 }
319 static inline double simcall_execution_set_priority__getraw__priority(smx_simcall_t simcall)
320 {
321   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
322 }
323 static inline void simcall_execution_set_priority__set__priority(smx_simcall_t simcall, double arg)
324 {
325   simgrid::simix::marshal<double>(simcall->args[1], arg);
326 }
327
328 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
329 simcall_execution_set_bound__get__execution(smx_simcall_t simcall)
330 {
331   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
332 }
333 static inline simgrid::kernel::activity::ActivityImpl*
334 simcall_execution_set_bound__getraw__execution(smx_simcall_t simcall)
335 {
336   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
337 }
338 static inline void
339 simcall_execution_set_bound__set__execution(smx_simcall_t simcall,
340                                             boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
341 {
342   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
343 }
344 static inline double simcall_execution_set_bound__get__bound(smx_simcall_t simcall)
345 {
346   return simgrid::simix::unmarshal<double>(simcall->args[1]);
347 }
348 static inline double simcall_execution_set_bound__getraw__bound(smx_simcall_t simcall)
349 {
350   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
351 }
352 static inline void simcall_execution_set_bound__set__bound(smx_simcall_t simcall, double arg)
353 {
354   simgrid::simix::marshal<double>(simcall->args[1], arg);
355 }
356
357 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
358 simcall_execution_wait__get__execution(smx_simcall_t simcall)
359 {
360   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
361 }
362 static inline simgrid::kernel::activity::ActivityImpl* simcall_execution_wait__getraw__execution(smx_simcall_t simcall)
363 {
364   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
365 }
366 static inline void
367 simcall_execution_wait__set__execution(smx_simcall_t simcall,
368                                        boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
369 {
370   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
371 }
372 static inline int simcall_execution_wait__get__result(smx_simcall_t simcall)
373 {
374   return simgrid::simix::unmarshal<int>(simcall->result);
375 }
376 static inline int simcall_execution_wait__getraw__result(smx_simcall_t simcall)
377 {
378   return simgrid::simix::unmarshal_raw<int>(simcall->result);
379 }
380 static inline void simcall_execution_wait__set__result(smx_simcall_t simcall, int result){
381     simgrid::simix::marshal<int>(simcall->result, result);
382 }
383
384 static inline smx_actor_t simcall_process_on_exit__get__process(smx_simcall_t simcall)
385 {
386   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
387 }
388 static inline smx_actor_t simcall_process_on_exit__getraw__process(smx_simcall_t simcall)
389 {
390   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
391 }
392 static inline void simcall_process_on_exit__set__process(smx_simcall_t simcall, smx_actor_t arg)
393 {
394   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
395 }
396 static inline int_f_pvoid_pvoid_t simcall_process_on_exit__get__fun(smx_simcall_t simcall)
397 {
398   return simgrid::simix::unmarshal<int_f_pvoid_pvoid_t>(simcall->args[1]);
399 }
400 static inline int_f_pvoid_pvoid_t simcall_process_on_exit__getraw__fun(smx_simcall_t simcall)
401 {
402   return simgrid::simix::unmarshal_raw<int_f_pvoid_pvoid_t>(simcall->args[1]);
403 }
404 static inline void simcall_process_on_exit__set__fun(smx_simcall_t simcall, int_f_pvoid_pvoid_t arg)
405 {
406   simgrid::simix::marshal<int_f_pvoid_pvoid_t>(simcall->args[1], arg);
407 }
408 static inline void* simcall_process_on_exit__get__data(smx_simcall_t simcall)
409 {
410   return simgrid::simix::unmarshal<void*>(simcall->args[2]);
411 }
412 static inline void* simcall_process_on_exit__getraw__data(smx_simcall_t simcall)
413 {
414   return simgrid::simix::unmarshal_raw<void*>(simcall->args[2]);
415 }
416 static inline void simcall_process_on_exit__set__data(smx_simcall_t simcall, void* arg)
417 {
418   simgrid::simix::marshal<void*>(simcall->args[2], arg);
419 }
420
421 static inline smx_mailbox_t simcall_comm_iprobe__get__mbox(smx_simcall_t simcall)
422 {
423   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[0]);
424 }
425 static inline smx_mailbox_t simcall_comm_iprobe__getraw__mbox(smx_simcall_t simcall)
426 {
427   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[0]);
428 }
429 static inline void simcall_comm_iprobe__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
430 {
431   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[0], arg);
432 }
433 static inline int simcall_comm_iprobe__get__type(smx_simcall_t simcall)
434 {
435   return simgrid::simix::unmarshal<int>(simcall->args[1]);
436 }
437 static inline int simcall_comm_iprobe__getraw__type(smx_simcall_t simcall)
438 {
439   return simgrid::simix::unmarshal_raw<int>(simcall->args[1]);
440 }
441 static inline void simcall_comm_iprobe__set__type(smx_simcall_t simcall, int arg)
442 {
443   simgrid::simix::marshal<int>(simcall->args[1], arg);
444 }
445 static inline simix_match_func_t simcall_comm_iprobe__get__match_fun(smx_simcall_t simcall)
446 {
447   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[2]);
448 }
449 static inline simix_match_func_t simcall_comm_iprobe__getraw__match_fun(smx_simcall_t simcall)
450 {
451   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[2]);
452 }
453 static inline void simcall_comm_iprobe__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
454 {
455   simgrid::simix::marshal<simix_match_func_t>(simcall->args[2], arg);
456 }
457 static inline void* simcall_comm_iprobe__get__data(smx_simcall_t simcall)
458 {
459   return simgrid::simix::unmarshal<void*>(simcall->args[3]);
460 }
461 static inline void* simcall_comm_iprobe__getraw__data(smx_simcall_t simcall)
462 {
463   return simgrid::simix::unmarshal_raw<void*>(simcall->args[3]);
464 }
465 static inline void simcall_comm_iprobe__set__data(smx_simcall_t simcall, void* arg)
466 {
467   simgrid::simix::marshal<void*>(simcall->args[3], arg);
468 }
469 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
470 simcall_comm_iprobe__get__result(smx_simcall_t simcall)
471 {
472   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result);
473 }
474 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_iprobe__getraw__result(smx_simcall_t simcall)
475 {
476   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->result);
477 }
478 static inline void
479 simcall_comm_iprobe__set__result(smx_simcall_t simcall,
480                                  boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> result)
481 {
482   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result, result);
483 }
484
485 static inline smx_actor_t simcall_comm_send__get__sender(smx_simcall_t simcall)
486 {
487   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
488 }
489 static inline smx_actor_t simcall_comm_send__getraw__sender(smx_simcall_t simcall)
490 {
491   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
492 }
493 static inline void simcall_comm_send__set__sender(smx_simcall_t simcall, smx_actor_t arg)
494 {
495   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
496 }
497 static inline smx_mailbox_t simcall_comm_send__get__mbox(smx_simcall_t simcall)
498 {
499   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[1]);
500 }
501 static inline smx_mailbox_t simcall_comm_send__getraw__mbox(smx_simcall_t simcall)
502 {
503   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[1]);
504 }
505 static inline void simcall_comm_send__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
506 {
507   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[1], arg);
508 }
509 static inline double simcall_comm_send__get__task_size(smx_simcall_t simcall)
510 {
511   return simgrid::simix::unmarshal<double>(simcall->args[2]);
512 }
513 static inline double simcall_comm_send__getraw__task_size(smx_simcall_t simcall)
514 {
515   return simgrid::simix::unmarshal_raw<double>(simcall->args[2]);
516 }
517 static inline void simcall_comm_send__set__task_size(smx_simcall_t simcall, double arg)
518 {
519   simgrid::simix::marshal<double>(simcall->args[2], arg);
520 }
521 static inline double simcall_comm_send__get__rate(smx_simcall_t simcall)
522 {
523   return simgrid::simix::unmarshal<double>(simcall->args[3]);
524 }
525 static inline double simcall_comm_send__getraw__rate(smx_simcall_t simcall)
526 {
527   return simgrid::simix::unmarshal_raw<double>(simcall->args[3]);
528 }
529 static inline void simcall_comm_send__set__rate(smx_simcall_t simcall, double arg)
530 {
531   simgrid::simix::marshal<double>(simcall->args[3], arg);
532 }
533 static inline void* simcall_comm_send__get__src_buff(smx_simcall_t simcall)
534 {
535   return simgrid::simix::unmarshal<void*>(simcall->args[4]);
536 }
537 static inline void* simcall_comm_send__getraw__src_buff(smx_simcall_t simcall)
538 {
539   return simgrid::simix::unmarshal_raw<void*>(simcall->args[4]);
540 }
541 static inline void simcall_comm_send__set__src_buff(smx_simcall_t simcall, void* arg)
542 {
543   simgrid::simix::marshal<void*>(simcall->args[4], arg);
544 }
545 static inline size_t simcall_comm_send__get__src_buff_size(smx_simcall_t simcall)
546 {
547   return simgrid::simix::unmarshal<size_t>(simcall->args[5]);
548 }
549 static inline size_t simcall_comm_send__getraw__src_buff_size(smx_simcall_t simcall)
550 {
551   return simgrid::simix::unmarshal_raw<size_t>(simcall->args[5]);
552 }
553 static inline void simcall_comm_send__set__src_buff_size(smx_simcall_t simcall, size_t arg)
554 {
555   simgrid::simix::marshal<size_t>(simcall->args[5], arg);
556 }
557 static inline simix_match_func_t simcall_comm_send__get__match_fun(smx_simcall_t simcall)
558 {
559   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[6]);
560 }
561 static inline simix_match_func_t simcall_comm_send__getraw__match_fun(smx_simcall_t simcall)
562 {
563   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[6]);
564 }
565 static inline void simcall_comm_send__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
566 {
567   simgrid::simix::marshal<simix_match_func_t>(simcall->args[6], arg);
568 }
569 static inline simix_copy_data_func_t simcall_comm_send__get__copy_data_fun(smx_simcall_t simcall)
570 {
571   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[7]);
572 }
573 static inline simix_copy_data_func_t simcall_comm_send__getraw__copy_data_fun(smx_simcall_t simcall)
574 {
575   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args[7]);
576 }
577 static inline void simcall_comm_send__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
578 {
579   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[7], arg);
580 }
581 static inline void* simcall_comm_send__get__data(smx_simcall_t simcall)
582 {
583   return simgrid::simix::unmarshal<void*>(simcall->args[8]);
584 }
585 static inline void* simcall_comm_send__getraw__data(smx_simcall_t simcall)
586 {
587   return simgrid::simix::unmarshal_raw<void*>(simcall->args[8]);
588 }
589 static inline void simcall_comm_send__set__data(smx_simcall_t simcall, void* arg)
590 {
591   simgrid::simix::marshal<void*>(simcall->args[8], arg);
592 }
593 static inline double simcall_comm_send__get__timeout(smx_simcall_t simcall)
594 {
595   return simgrid::simix::unmarshal<double>(simcall->args[9]);
596 }
597 static inline double simcall_comm_send__getraw__timeout(smx_simcall_t simcall)
598 {
599   return simgrid::simix::unmarshal_raw<double>(simcall->args[9]);
600 }
601 static inline void simcall_comm_send__set__timeout(smx_simcall_t simcall, double arg)
602 {
603   simgrid::simix::marshal<double>(simcall->args[9], arg);
604 }
605
606 static inline smx_actor_t simcall_comm_isend__get__sender(smx_simcall_t simcall)
607 {
608   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
609 }
610 static inline smx_actor_t simcall_comm_isend__getraw__sender(smx_simcall_t simcall)
611 {
612   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
613 }
614 static inline void simcall_comm_isend__set__sender(smx_simcall_t simcall, smx_actor_t arg)
615 {
616   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
617 }
618 static inline smx_mailbox_t simcall_comm_isend__get__mbox(smx_simcall_t simcall)
619 {
620   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[1]);
621 }
622 static inline smx_mailbox_t simcall_comm_isend__getraw__mbox(smx_simcall_t simcall)
623 {
624   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[1]);
625 }
626 static inline void simcall_comm_isend__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
627 {
628   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[1], arg);
629 }
630 static inline double simcall_comm_isend__get__task_size(smx_simcall_t simcall)
631 {
632   return simgrid::simix::unmarshal<double>(simcall->args[2]);
633 }
634 static inline double simcall_comm_isend__getraw__task_size(smx_simcall_t simcall)
635 {
636   return simgrid::simix::unmarshal_raw<double>(simcall->args[2]);
637 }
638 static inline void simcall_comm_isend__set__task_size(smx_simcall_t simcall, double arg)
639 {
640   simgrid::simix::marshal<double>(simcall->args[2], arg);
641 }
642 static inline double simcall_comm_isend__get__rate(smx_simcall_t simcall)
643 {
644   return simgrid::simix::unmarshal<double>(simcall->args[3]);
645 }
646 static inline double simcall_comm_isend__getraw__rate(smx_simcall_t simcall)
647 {
648   return simgrid::simix::unmarshal_raw<double>(simcall->args[3]);
649 }
650 static inline void simcall_comm_isend__set__rate(smx_simcall_t simcall, double arg)
651 {
652   simgrid::simix::marshal<double>(simcall->args[3], arg);
653 }
654 static inline void* simcall_comm_isend__get__src_buff(smx_simcall_t simcall)
655 {
656   return simgrid::simix::unmarshal<void*>(simcall->args[4]);
657 }
658 static inline void* simcall_comm_isend__getraw__src_buff(smx_simcall_t simcall)
659 {
660   return simgrid::simix::unmarshal_raw<void*>(simcall->args[4]);
661 }
662 static inline void simcall_comm_isend__set__src_buff(smx_simcall_t simcall, void* arg)
663 {
664   simgrid::simix::marshal<void*>(simcall->args[4], arg);
665 }
666 static inline size_t simcall_comm_isend__get__src_buff_size(smx_simcall_t simcall)
667 {
668   return simgrid::simix::unmarshal<size_t>(simcall->args[5]);
669 }
670 static inline size_t simcall_comm_isend__getraw__src_buff_size(smx_simcall_t simcall)
671 {
672   return simgrid::simix::unmarshal_raw<size_t>(simcall->args[5]);
673 }
674 static inline void simcall_comm_isend__set__src_buff_size(smx_simcall_t simcall, size_t arg)
675 {
676   simgrid::simix::marshal<size_t>(simcall->args[5], arg);
677 }
678 static inline simix_match_func_t simcall_comm_isend__get__match_fun(smx_simcall_t simcall)
679 {
680   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[6]);
681 }
682 static inline simix_match_func_t simcall_comm_isend__getraw__match_fun(smx_simcall_t simcall)
683 {
684   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[6]);
685 }
686 static inline void simcall_comm_isend__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
687 {
688   simgrid::simix::marshal<simix_match_func_t>(simcall->args[6], arg);
689 }
690 static inline simix_clean_func_t simcall_comm_isend__get__clean_fun(smx_simcall_t simcall)
691 {
692   return simgrid::simix::unmarshal<simix_clean_func_t>(simcall->args[7]);
693 }
694 static inline simix_clean_func_t simcall_comm_isend__getraw__clean_fun(smx_simcall_t simcall)
695 {
696   return simgrid::simix::unmarshal_raw<simix_clean_func_t>(simcall->args[7]);
697 }
698 static inline void simcall_comm_isend__set__clean_fun(smx_simcall_t simcall, simix_clean_func_t arg)
699 {
700   simgrid::simix::marshal<simix_clean_func_t>(simcall->args[7], arg);
701 }
702 static inline simix_copy_data_func_t simcall_comm_isend__get__copy_data_fun(smx_simcall_t simcall)
703 {
704   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[8]);
705 }
706 static inline simix_copy_data_func_t simcall_comm_isend__getraw__copy_data_fun(smx_simcall_t simcall)
707 {
708   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args[8]);
709 }
710 static inline void simcall_comm_isend__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
711 {
712   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[8], arg);
713 }
714 static inline void* simcall_comm_isend__get__data(smx_simcall_t simcall)
715 {
716   return simgrid::simix::unmarshal<void*>(simcall->args[9]);
717 }
718 static inline void* simcall_comm_isend__getraw__data(smx_simcall_t simcall)
719 {
720   return simgrid::simix::unmarshal_raw<void*>(simcall->args[9]);
721 }
722 static inline void simcall_comm_isend__set__data(smx_simcall_t simcall, void* arg)
723 {
724   simgrid::simix::marshal<void*>(simcall->args[9], arg);
725 }
726 static inline int simcall_comm_isend__get__detached(smx_simcall_t simcall)
727 {
728   return simgrid::simix::unmarshal<int>(simcall->args[10]);
729 }
730 static inline int simcall_comm_isend__getraw__detached(smx_simcall_t simcall)
731 {
732   return simgrid::simix::unmarshal_raw<int>(simcall->args[10]);
733 }
734 static inline void simcall_comm_isend__set__detached(smx_simcall_t simcall, int arg)
735 {
736   simgrid::simix::marshal<int>(simcall->args[10], arg);
737 }
738 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
739 simcall_comm_isend__get__result(smx_simcall_t simcall)
740 {
741   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result);
742 }
743 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_isend__getraw__result(smx_simcall_t simcall)
744 {
745   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->result);
746 }
747 static inline void simcall_comm_isend__set__result(smx_simcall_t simcall,
748                                                    boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> result)
749 {
750   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result, result);
751 }
752
753 static inline smx_actor_t simcall_comm_recv__get__receiver(smx_simcall_t simcall)
754 {
755   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
756 }
757 static inline smx_actor_t simcall_comm_recv__getraw__receiver(smx_simcall_t simcall)
758 {
759   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
760 }
761 static inline void simcall_comm_recv__set__receiver(smx_simcall_t simcall, smx_actor_t arg)
762 {
763   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
764 }
765 static inline smx_mailbox_t simcall_comm_recv__get__mbox(smx_simcall_t simcall)
766 {
767   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[1]);
768 }
769 static inline smx_mailbox_t simcall_comm_recv__getraw__mbox(smx_simcall_t simcall)
770 {
771   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[1]);
772 }
773 static inline void simcall_comm_recv__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
774 {
775   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[1], arg);
776 }
777 static inline void* simcall_comm_recv__get__dst_buff(smx_simcall_t simcall)
778 {
779   return simgrid::simix::unmarshal<void*>(simcall->args[2]);
780 }
781 static inline void* simcall_comm_recv__getraw__dst_buff(smx_simcall_t simcall)
782 {
783   return simgrid::simix::unmarshal_raw<void*>(simcall->args[2]);
784 }
785 static inline void simcall_comm_recv__set__dst_buff(smx_simcall_t simcall, void* arg)
786 {
787   simgrid::simix::marshal<void*>(simcall->args[2], arg);
788 }
789 static inline size_t* simcall_comm_recv__get__dst_buff_size(smx_simcall_t simcall)
790 {
791   return simgrid::simix::unmarshal<size_t*>(simcall->args[3]);
792 }
793 static inline size_t* simcall_comm_recv__getraw__dst_buff_size(smx_simcall_t simcall)
794 {
795   return simgrid::simix::unmarshal_raw<size_t*>(simcall->args[3]);
796 }
797 static inline void simcall_comm_recv__set__dst_buff_size(smx_simcall_t simcall, size_t* arg)
798 {
799   simgrid::simix::marshal<size_t*>(simcall->args[3], arg);
800 }
801 static inline simix_match_func_t simcall_comm_recv__get__match_fun(smx_simcall_t simcall)
802 {
803   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[4]);
804 }
805 static inline simix_match_func_t simcall_comm_recv__getraw__match_fun(smx_simcall_t simcall)
806 {
807   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[4]);
808 }
809 static inline void simcall_comm_recv__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
810 {
811   simgrid::simix::marshal<simix_match_func_t>(simcall->args[4], arg);
812 }
813 static inline simix_copy_data_func_t simcall_comm_recv__get__copy_data_fun(smx_simcall_t simcall)
814 {
815   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[5]);
816 }
817 static inline simix_copy_data_func_t simcall_comm_recv__getraw__copy_data_fun(smx_simcall_t simcall)
818 {
819   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args[5]);
820 }
821 static inline void simcall_comm_recv__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
822 {
823   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[5], arg);
824 }
825 static inline void* simcall_comm_recv__get__data(smx_simcall_t simcall)
826 {
827   return simgrid::simix::unmarshal<void*>(simcall->args[6]);
828 }
829 static inline void* simcall_comm_recv__getraw__data(smx_simcall_t simcall)
830 {
831   return simgrid::simix::unmarshal_raw<void*>(simcall->args[6]);
832 }
833 static inline void simcall_comm_recv__set__data(smx_simcall_t simcall, void* arg)
834 {
835   simgrid::simix::marshal<void*>(simcall->args[6], arg);
836 }
837 static inline double simcall_comm_recv__get__timeout(smx_simcall_t simcall)
838 {
839   return simgrid::simix::unmarshal<double>(simcall->args[7]);
840 }
841 static inline double simcall_comm_recv__getraw__timeout(smx_simcall_t simcall)
842 {
843   return simgrid::simix::unmarshal_raw<double>(simcall->args[7]);
844 }
845 static inline void simcall_comm_recv__set__timeout(smx_simcall_t simcall, double arg)
846 {
847   simgrid::simix::marshal<double>(simcall->args[7], arg);
848 }
849 static inline double simcall_comm_recv__get__rate(smx_simcall_t simcall)
850 {
851   return simgrid::simix::unmarshal<double>(simcall->args[8]);
852 }
853 static inline double simcall_comm_recv__getraw__rate(smx_simcall_t simcall)
854 {
855   return simgrid::simix::unmarshal_raw<double>(simcall->args[8]);
856 }
857 static inline void simcall_comm_recv__set__rate(smx_simcall_t simcall, double arg)
858 {
859   simgrid::simix::marshal<double>(simcall->args[8], arg);
860 }
861
862 static inline smx_actor_t simcall_comm_irecv__get__receiver(smx_simcall_t simcall)
863 {
864   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
865 }
866 static inline smx_actor_t simcall_comm_irecv__getraw__receiver(smx_simcall_t simcall)
867 {
868   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
869 }
870 static inline void simcall_comm_irecv__set__receiver(smx_simcall_t simcall, smx_actor_t arg)
871 {
872   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
873 }
874 static inline smx_mailbox_t simcall_comm_irecv__get__mbox(smx_simcall_t simcall)
875 {
876   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[1]);
877 }
878 static inline smx_mailbox_t simcall_comm_irecv__getraw__mbox(smx_simcall_t simcall)
879 {
880   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[1]);
881 }
882 static inline void simcall_comm_irecv__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
883 {
884   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[1], arg);
885 }
886 static inline void* simcall_comm_irecv__get__dst_buff(smx_simcall_t simcall)
887 {
888   return simgrid::simix::unmarshal<void*>(simcall->args[2]);
889 }
890 static inline void* simcall_comm_irecv__getraw__dst_buff(smx_simcall_t simcall)
891 {
892   return simgrid::simix::unmarshal_raw<void*>(simcall->args[2]);
893 }
894 static inline void simcall_comm_irecv__set__dst_buff(smx_simcall_t simcall, void* arg)
895 {
896   simgrid::simix::marshal<void*>(simcall->args[2], arg);
897 }
898 static inline size_t* simcall_comm_irecv__get__dst_buff_size(smx_simcall_t simcall)
899 {
900   return simgrid::simix::unmarshal<size_t*>(simcall->args[3]);
901 }
902 static inline size_t* simcall_comm_irecv__getraw__dst_buff_size(smx_simcall_t simcall)
903 {
904   return simgrid::simix::unmarshal_raw<size_t*>(simcall->args[3]);
905 }
906 static inline void simcall_comm_irecv__set__dst_buff_size(smx_simcall_t simcall, size_t* arg)
907 {
908   simgrid::simix::marshal<size_t*>(simcall->args[3], arg);
909 }
910 static inline simix_match_func_t simcall_comm_irecv__get__match_fun(smx_simcall_t simcall)
911 {
912   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[4]);
913 }
914 static inline simix_match_func_t simcall_comm_irecv__getraw__match_fun(smx_simcall_t simcall)
915 {
916   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[4]);
917 }
918 static inline void simcall_comm_irecv__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
919 {
920   simgrid::simix::marshal<simix_match_func_t>(simcall->args[4], arg);
921 }
922 static inline simix_copy_data_func_t simcall_comm_irecv__get__copy_data_fun(smx_simcall_t simcall)
923 {
924   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[5]);
925 }
926 static inline simix_copy_data_func_t simcall_comm_irecv__getraw__copy_data_fun(smx_simcall_t simcall)
927 {
928   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args[5]);
929 }
930 static inline void simcall_comm_irecv__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
931 {
932   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[5], arg);
933 }
934 static inline void* simcall_comm_irecv__get__data(smx_simcall_t simcall)
935 {
936   return simgrid::simix::unmarshal<void*>(simcall->args[6]);
937 }
938 static inline void* simcall_comm_irecv__getraw__data(smx_simcall_t simcall)
939 {
940   return simgrid::simix::unmarshal_raw<void*>(simcall->args[6]);
941 }
942 static inline void simcall_comm_irecv__set__data(smx_simcall_t simcall, void* arg)
943 {
944   simgrid::simix::marshal<void*>(simcall->args[6], arg);
945 }
946 static inline double simcall_comm_irecv__get__rate(smx_simcall_t simcall)
947 {
948   return simgrid::simix::unmarshal<double>(simcall->args[7]);
949 }
950 static inline double simcall_comm_irecv__getraw__rate(smx_simcall_t simcall)
951 {
952   return simgrid::simix::unmarshal_raw<double>(simcall->args[7]);
953 }
954 static inline void simcall_comm_irecv__set__rate(smx_simcall_t simcall, double arg)
955 {
956   simgrid::simix::marshal<double>(simcall->args[7], arg);
957 }
958 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
959 simcall_comm_irecv__get__result(smx_simcall_t simcall)
960 {
961   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result);
962 }
963 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_irecv__getraw__result(smx_simcall_t simcall)
964 {
965   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->result);
966 }
967 static inline void simcall_comm_irecv__set__result(smx_simcall_t simcall,
968                                                    boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> result)
969 {
970   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result, result);
971 }
972
973 static inline xbt_dynar_t simcall_comm_waitany__get__comms(smx_simcall_t simcall)
974 {
975   return simgrid::simix::unmarshal<xbt_dynar_t>(simcall->args[0]);
976 }
977 static inline xbt_dynar_t simcall_comm_waitany__getraw__comms(smx_simcall_t simcall)
978 {
979   return simgrid::simix::unmarshal_raw<xbt_dynar_t>(simcall->args[0]);
980 }
981 static inline void simcall_comm_waitany__set__comms(smx_simcall_t simcall, xbt_dynar_t arg)
982 {
983   simgrid::simix::marshal<xbt_dynar_t>(simcall->args[0], arg);
984 }
985 static inline double simcall_comm_waitany__get__timeout(smx_simcall_t simcall)
986 {
987   return simgrid::simix::unmarshal<double>(simcall->args[1]);
988 }
989 static inline double simcall_comm_waitany__getraw__timeout(smx_simcall_t simcall)
990 {
991   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
992 }
993 static inline void simcall_comm_waitany__set__timeout(smx_simcall_t simcall, double arg)
994 {
995   simgrid::simix::marshal<double>(simcall->args[1], arg);
996 }
997 static inline int simcall_comm_waitany__get__result(smx_simcall_t simcall)
998 {
999   return simgrid::simix::unmarshal<int>(simcall->result);
1000 }
1001 static inline int simcall_comm_waitany__getraw__result(smx_simcall_t simcall)
1002 {
1003   return simgrid::simix::unmarshal_raw<int>(simcall->result);
1004 }
1005 static inline void simcall_comm_waitany__set__result(smx_simcall_t simcall, int result){
1006     simgrid::simix::marshal<int>(simcall->result, result);
1007 }
1008
1009 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
1010 simcall_comm_wait__get__comm(smx_simcall_t simcall)
1011 {
1012   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
1013 }
1014 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_wait__getraw__comm(smx_simcall_t simcall)
1015 {
1016   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
1017 }
1018 static inline void simcall_comm_wait__set__comm(smx_simcall_t simcall,
1019                                                 boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
1020 {
1021   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
1022 }
1023 static inline double simcall_comm_wait__get__timeout(smx_simcall_t simcall)
1024 {
1025   return simgrid::simix::unmarshal<double>(simcall->args[1]);
1026 }
1027 static inline double simcall_comm_wait__getraw__timeout(smx_simcall_t simcall)
1028 {
1029   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
1030 }
1031 static inline void simcall_comm_wait__set__timeout(smx_simcall_t simcall, double arg)
1032 {
1033   simgrid::simix::marshal<double>(simcall->args[1], arg);
1034 }
1035
1036 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
1037 simcall_comm_test__get__comm(smx_simcall_t simcall)
1038 {
1039   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
1040 }
1041 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_test__getraw__comm(smx_simcall_t simcall)
1042 {
1043   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
1044 }
1045 static inline void simcall_comm_test__set__comm(smx_simcall_t simcall,
1046                                                 boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
1047 {
1048   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
1049 }
1050 static inline int simcall_comm_test__get__result(smx_simcall_t simcall)
1051 {
1052   return simgrid::simix::unmarshal<int>(simcall->result);
1053 }
1054 static inline int simcall_comm_test__getraw__result(smx_simcall_t simcall)
1055 {
1056   return simgrid::simix::unmarshal_raw<int>(simcall->result);
1057 }
1058 static inline void simcall_comm_test__set__result(smx_simcall_t simcall, int result){
1059     simgrid::simix::marshal<int>(simcall->result, result);
1060 }
1061
1062 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>*
1063 simcall_comm_testany__get__comms(smx_simcall_t simcall)
1064 {
1065   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>*>(simcall->args[0]);
1066 }
1067 static inline simgrid::kernel::activity::ActivityImpl** simcall_comm_testany__getraw__comms(smx_simcall_t simcall)
1068 {
1069   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl**>(simcall->args[0]);
1070 }
1071 static inline void simcall_comm_testany__set__comms(smx_simcall_t simcall,
1072                                                     boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>* arg)
1073 {
1074   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>*>(simcall->args[0], arg);
1075 }
1076 static inline size_t simcall_comm_testany__get__count(smx_simcall_t simcall)
1077 {
1078   return simgrid::simix::unmarshal<size_t>(simcall->args[1]);
1079 }
1080 static inline size_t simcall_comm_testany__getraw__count(smx_simcall_t simcall)
1081 {
1082   return simgrid::simix::unmarshal_raw<size_t>(simcall->args[1]);
1083 }
1084 static inline void simcall_comm_testany__set__count(smx_simcall_t simcall, size_t arg)
1085 {
1086   simgrid::simix::marshal<size_t>(simcall->args[1], arg);
1087 }
1088 static inline int simcall_comm_testany__get__result(smx_simcall_t simcall)
1089 {
1090   return simgrid::simix::unmarshal<int>(simcall->result);
1091 }
1092 static inline int simcall_comm_testany__getraw__result(smx_simcall_t simcall)
1093 {
1094   return simgrid::simix::unmarshal_raw<int>(simcall->result);
1095 }
1096 static inline void simcall_comm_testany__set__result(smx_simcall_t simcall, int result){
1097     simgrid::simix::marshal<int>(simcall->result, result);
1098 }
1099
1100 static inline smx_mutex_t simcall_mutex_lock__get__mutex(smx_simcall_t simcall)
1101 {
1102   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[0]);
1103 }
1104 static inline smx_mutex_t simcall_mutex_lock__getraw__mutex(smx_simcall_t simcall)
1105 {
1106   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[0]);
1107 }
1108 static inline void simcall_mutex_lock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
1109 {
1110   simgrid::simix::marshal<smx_mutex_t>(simcall->args[0], arg);
1111 }
1112
1113 static inline smx_mutex_t simcall_mutex_trylock__get__mutex(smx_simcall_t simcall)
1114 {
1115   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[0]);
1116 }
1117 static inline smx_mutex_t simcall_mutex_trylock__getraw__mutex(smx_simcall_t simcall)
1118 {
1119   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[0]);
1120 }
1121 static inline void simcall_mutex_trylock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
1122 {
1123   simgrid::simix::marshal<smx_mutex_t>(simcall->args[0], arg);
1124 }
1125 static inline int simcall_mutex_trylock__get__result(smx_simcall_t simcall)
1126 {
1127   return simgrid::simix::unmarshal<int>(simcall->result);
1128 }
1129 static inline int simcall_mutex_trylock__getraw__result(smx_simcall_t simcall)
1130 {
1131   return simgrid::simix::unmarshal_raw<int>(simcall->result);
1132 }
1133 static inline void simcall_mutex_trylock__set__result(smx_simcall_t simcall, int result){
1134     simgrid::simix::marshal<int>(simcall->result, result);
1135 }
1136
1137 static inline smx_mutex_t simcall_mutex_unlock__get__mutex(smx_simcall_t simcall)
1138 {
1139   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[0]);
1140 }
1141 static inline smx_mutex_t simcall_mutex_unlock__getraw__mutex(smx_simcall_t simcall)
1142 {
1143   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[0]);
1144 }
1145 static inline void simcall_mutex_unlock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
1146 {
1147   simgrid::simix::marshal<smx_mutex_t>(simcall->args[0], arg);
1148 }
1149
1150 static inline smx_cond_t simcall_cond_init__get__result(smx_simcall_t simcall)
1151 {
1152   return simgrid::simix::unmarshal<smx_cond_t>(simcall->result);
1153 }
1154 static inline smx_cond_t simcall_cond_init__getraw__result(smx_simcall_t simcall)
1155 {
1156   return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->result);
1157 }
1158 static inline void simcall_cond_init__set__result(smx_simcall_t simcall, smx_cond_t result){
1159     simgrid::simix::marshal<smx_cond_t>(simcall->result, result);
1160 }
1161
1162 static inline smx_cond_t simcall_cond_signal__get__cond(smx_simcall_t simcall)
1163 {
1164   return simgrid::simix::unmarshal<smx_cond_t>(simcall->args[0]);
1165 }
1166 static inline smx_cond_t simcall_cond_signal__getraw__cond(smx_simcall_t simcall)
1167 {
1168   return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->args[0]);
1169 }
1170 static inline void simcall_cond_signal__set__cond(smx_simcall_t simcall, smx_cond_t arg)
1171 {
1172   simgrid::simix::marshal<smx_cond_t>(simcall->args[0], arg);
1173 }
1174
1175 static inline smx_cond_t simcall_cond_wait__get__cond(smx_simcall_t simcall)
1176 {
1177   return simgrid::simix::unmarshal<smx_cond_t>(simcall->args[0]);
1178 }
1179 static inline smx_cond_t simcall_cond_wait__getraw__cond(smx_simcall_t simcall)
1180 {
1181   return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->args[0]);
1182 }
1183 static inline void simcall_cond_wait__set__cond(smx_simcall_t simcall, smx_cond_t arg)
1184 {
1185   simgrid::simix::marshal<smx_cond_t>(simcall->args[0], arg);
1186 }
1187 static inline smx_mutex_t simcall_cond_wait__get__mutex(smx_simcall_t simcall)
1188 {
1189   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[1]);
1190 }
1191 static inline smx_mutex_t simcall_cond_wait__getraw__mutex(smx_simcall_t simcall)
1192 {
1193   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[1]);
1194 }
1195 static inline void simcall_cond_wait__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
1196 {
1197   simgrid::simix::marshal<smx_mutex_t>(simcall->args[1], arg);
1198 }
1199
1200 static inline smx_cond_t simcall_cond_wait_timeout__get__cond(smx_simcall_t simcall)
1201 {
1202   return simgrid::simix::unmarshal<smx_cond_t>(simcall->args[0]);
1203 }
1204 static inline smx_cond_t simcall_cond_wait_timeout__getraw__cond(smx_simcall_t simcall)
1205 {
1206   return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->args[0]);
1207 }
1208 static inline void simcall_cond_wait_timeout__set__cond(smx_simcall_t simcall, smx_cond_t arg)
1209 {
1210   simgrid::simix::marshal<smx_cond_t>(simcall->args[0], arg);
1211 }
1212 static inline smx_mutex_t simcall_cond_wait_timeout__get__mutex(smx_simcall_t simcall)
1213 {
1214   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[1]);
1215 }
1216 static inline smx_mutex_t simcall_cond_wait_timeout__getraw__mutex(smx_simcall_t simcall)
1217 {
1218   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[1]);
1219 }
1220 static inline void simcall_cond_wait_timeout__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
1221 {
1222   simgrid::simix::marshal<smx_mutex_t>(simcall->args[1], arg);
1223 }
1224 static inline double simcall_cond_wait_timeout__get__timeout(smx_simcall_t simcall)
1225 {
1226   return simgrid::simix::unmarshal<double>(simcall->args[2]);
1227 }
1228 static inline double simcall_cond_wait_timeout__getraw__timeout(smx_simcall_t simcall)
1229 {
1230   return simgrid::simix::unmarshal_raw<double>(simcall->args[2]);
1231 }
1232 static inline void simcall_cond_wait_timeout__set__timeout(smx_simcall_t simcall, double arg)
1233 {
1234   simgrid::simix::marshal<double>(simcall->args[2], arg);
1235 }
1236
1237 static inline smx_cond_t simcall_cond_broadcast__get__cond(smx_simcall_t simcall)
1238 {
1239   return simgrid::simix::unmarshal<smx_cond_t>(simcall->args[0]);
1240 }
1241 static inline smx_cond_t simcall_cond_broadcast__getraw__cond(smx_simcall_t simcall)
1242 {
1243   return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->args[0]);
1244 }
1245 static inline void simcall_cond_broadcast__set__cond(smx_simcall_t simcall, smx_cond_t arg)
1246 {
1247   simgrid::simix::marshal<smx_cond_t>(simcall->args[0], arg);
1248 }
1249
1250 static inline smx_sem_t simcall_sem_acquire__get__sem(smx_simcall_t simcall)
1251 {
1252   return simgrid::simix::unmarshal<smx_sem_t>(simcall->args[0]);
1253 }
1254 static inline smx_sem_t simcall_sem_acquire__getraw__sem(smx_simcall_t simcall)
1255 {
1256   return simgrid::simix::unmarshal_raw<smx_sem_t>(simcall->args[0]);
1257 }
1258 static inline void simcall_sem_acquire__set__sem(smx_simcall_t simcall, smx_sem_t arg)
1259 {
1260   simgrid::simix::marshal<smx_sem_t>(simcall->args[0], arg);
1261 }
1262
1263 static inline smx_sem_t simcall_sem_acquire_timeout__get__sem(smx_simcall_t simcall)
1264 {
1265   return simgrid::simix::unmarshal<smx_sem_t>(simcall->args[0]);
1266 }
1267 static inline smx_sem_t simcall_sem_acquire_timeout__getraw__sem(smx_simcall_t simcall)
1268 {
1269   return simgrid::simix::unmarshal_raw<smx_sem_t>(simcall->args[0]);
1270 }
1271 static inline void simcall_sem_acquire_timeout__set__sem(smx_simcall_t simcall, smx_sem_t arg)
1272 {
1273   simgrid::simix::marshal<smx_sem_t>(simcall->args[0], arg);
1274 }
1275 static inline double simcall_sem_acquire_timeout__get__timeout(smx_simcall_t simcall)
1276 {
1277   return simgrid::simix::unmarshal<double>(simcall->args[1]);
1278 }
1279 static inline double simcall_sem_acquire_timeout__getraw__timeout(smx_simcall_t simcall)
1280 {
1281   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
1282 }
1283 static inline void simcall_sem_acquire_timeout__set__timeout(smx_simcall_t simcall, double arg)
1284 {
1285   simgrid::simix::marshal<double>(simcall->args[1], arg);
1286 }
1287
1288 static inline surf_file_t simcall_file_read__get__fd(smx_simcall_t simcall)
1289 {
1290   return simgrid::simix::unmarshal<surf_file_t>(simcall->args[0]);
1291 }
1292 static inline surf_file_t simcall_file_read__getraw__fd(smx_simcall_t simcall)
1293 {
1294   return simgrid::simix::unmarshal_raw<surf_file_t>(simcall->args[0]);
1295 }
1296 static inline void simcall_file_read__set__fd(smx_simcall_t simcall, surf_file_t arg)
1297 {
1298   simgrid::simix::marshal<surf_file_t>(simcall->args[0], arg);
1299 }
1300 static inline sg_size_t simcall_file_read__get__size(smx_simcall_t simcall)
1301 {
1302   return simgrid::simix::unmarshal<sg_size_t>(simcall->args[1]);
1303 }
1304 static inline sg_size_t simcall_file_read__getraw__size(smx_simcall_t simcall)
1305 {
1306   return simgrid::simix::unmarshal_raw<sg_size_t>(simcall->args[1]);
1307 }
1308 static inline void simcall_file_read__set__size(smx_simcall_t simcall, sg_size_t arg)
1309 {
1310   simgrid::simix::marshal<sg_size_t>(simcall->args[1], arg);
1311 }
1312 static inline sg_size_t simcall_file_read__get__result(smx_simcall_t simcall)
1313 {
1314   return simgrid::simix::unmarshal<sg_size_t>(simcall->result);
1315 }
1316 static inline sg_size_t simcall_file_read__getraw__result(smx_simcall_t simcall)
1317 {
1318   return simgrid::simix::unmarshal_raw<sg_size_t>(simcall->result);
1319 }
1320 static inline void simcall_file_read__set__result(smx_simcall_t simcall, sg_size_t result){
1321     simgrid::simix::marshal<sg_size_t>(simcall->result, result);
1322 }
1323
1324 static inline surf_file_t simcall_file_write__get__fd(smx_simcall_t simcall)
1325 {
1326   return simgrid::simix::unmarshal<surf_file_t>(simcall->args[0]);
1327 }
1328 static inline surf_file_t simcall_file_write__getraw__fd(smx_simcall_t simcall)
1329 {
1330   return simgrid::simix::unmarshal_raw<surf_file_t>(simcall->args[0]);
1331 }
1332 static inline void simcall_file_write__set__fd(smx_simcall_t simcall, surf_file_t arg)
1333 {
1334   simgrid::simix::marshal<surf_file_t>(simcall->args[0], arg);
1335 }
1336 static inline sg_size_t simcall_file_write__get__size(smx_simcall_t simcall)
1337 {
1338   return simgrid::simix::unmarshal<sg_size_t>(simcall->args[1]);
1339 }
1340 static inline sg_size_t simcall_file_write__getraw__size(smx_simcall_t simcall)
1341 {
1342   return simgrid::simix::unmarshal_raw<sg_size_t>(simcall->args[1]);
1343 }
1344 static inline void simcall_file_write__set__size(smx_simcall_t simcall, sg_size_t arg)
1345 {
1346   simgrid::simix::marshal<sg_size_t>(simcall->args[1], arg);
1347 }
1348 static inline sg_size_t simcall_file_write__get__result(smx_simcall_t simcall)
1349 {
1350   return simgrid::simix::unmarshal<sg_size_t>(simcall->result);
1351 }
1352 static inline sg_size_t simcall_file_write__getraw__result(smx_simcall_t simcall)
1353 {
1354   return simgrid::simix::unmarshal_raw<sg_size_t>(simcall->result);
1355 }
1356 static inline void simcall_file_write__set__result(smx_simcall_t simcall, sg_size_t result){
1357     simgrid::simix::marshal<sg_size_t>(simcall->result, result);
1358 }
1359
1360 static inline int simcall_mc_random__get__min(smx_simcall_t simcall)
1361 {
1362   return simgrid::simix::unmarshal<int>(simcall->args[0]);
1363 }
1364 static inline int simcall_mc_random__getraw__min(smx_simcall_t simcall)
1365 {
1366   return simgrid::simix::unmarshal_raw<int>(simcall->args[0]);
1367 }
1368 static inline void simcall_mc_random__set__min(smx_simcall_t simcall, int arg)
1369 {
1370   simgrid::simix::marshal<int>(simcall->args[0], arg);
1371 }
1372 static inline int simcall_mc_random__get__max(smx_simcall_t simcall)
1373 {
1374   return simgrid::simix::unmarshal<int>(simcall->args[1]);
1375 }
1376 static inline int simcall_mc_random__getraw__max(smx_simcall_t simcall)
1377 {
1378   return simgrid::simix::unmarshal_raw<int>(simcall->args[1]);
1379 }
1380 static inline void simcall_mc_random__set__max(smx_simcall_t simcall, int arg)
1381 {
1382   simgrid::simix::marshal<int>(simcall->args[1], arg);
1383 }
1384 static inline int simcall_mc_random__get__result(smx_simcall_t simcall)
1385 {
1386   return simgrid::simix::unmarshal<int>(simcall->result);
1387 }
1388 static inline int simcall_mc_random__getraw__result(smx_simcall_t simcall)
1389 {
1390   return simgrid::simix::unmarshal_raw<int>(simcall->result);
1391 }
1392 static inline void simcall_mc_random__set__result(smx_simcall_t simcall, int result){
1393     simgrid::simix::marshal<int>(simcall->result, result);
1394 }
1395
1396 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
1397 simcall_set_category__get__synchro(smx_simcall_t simcall)
1398 {
1399   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
1400 }
1401 static inline simgrid::kernel::activity::ActivityImpl* simcall_set_category__getraw__synchro(smx_simcall_t simcall)
1402 {
1403   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
1404 }
1405 static inline void simcall_set_category__set__synchro(smx_simcall_t simcall,
1406                                                       boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
1407 {
1408   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
1409 }
1410 static inline const char* simcall_set_category__get__category(smx_simcall_t simcall)
1411 {
1412   return simgrid::simix::unmarshal<const char*>(simcall->args[1]);
1413 }
1414 static inline const char* simcall_set_category__getraw__category(smx_simcall_t simcall)
1415 {
1416   return simgrid::simix::unmarshal_raw<const char*>(simcall->args[1]);
1417 }
1418 static inline void simcall_set_category__set__category(smx_simcall_t simcall, const char* arg)
1419 {
1420   simgrid::simix::marshal<const char*>(simcall->args[1], arg);
1421 }
1422
1423 static inline std::function<void()> const* simcall_run_kernel__get__code(smx_simcall_t simcall)
1424 {
1425   return simgrid::simix::unmarshal<std::function<void()> const*>(simcall->args[0]);
1426 }
1427 static inline std::function<void()> const* simcall_run_kernel__getraw__code(smx_simcall_t simcall)
1428 {
1429   return simgrid::simix::unmarshal_raw<std::function<void()> const*>(simcall->args[0]);
1430 }
1431 static inline void simcall_run_kernel__set__code(smx_simcall_t simcall, std::function<void()> const* arg)
1432 {
1433   simgrid::simix::marshal<std::function<void()> const*>(simcall->args[0], arg);
1434 }
1435
1436 static inline std::function<void()> const* simcall_run_blocking__get__code(smx_simcall_t simcall)
1437 {
1438   return simgrid::simix::unmarshal<std::function<void()> const*>(simcall->args[0]);
1439 }
1440 static inline std::function<void()> const* simcall_run_blocking__getraw__code(smx_simcall_t simcall)
1441 {
1442   return simgrid::simix::unmarshal_raw<std::function<void()> const*>(simcall->args[0]);
1443 }
1444 static inline void simcall_run_blocking__set__code(smx_simcall_t simcall, std::function<void()> const* arg)
1445 {
1446   simgrid::simix::marshal<std::function<void()> const*>(simcall->args[0], arg);
1447 }
1448
1449 /* The prototype of all simcall handlers, automatically generated for you */
1450
1451 XBT_PRIVATE void simcall_HANDLER_process_killall(smx_simcall_t simcall, int reset_pid);
1452 XBT_PRIVATE void simcall_HANDLER_process_suspend(smx_simcall_t simcall, smx_actor_t process);
1453 XBT_PRIVATE void simcall_HANDLER_process_join(smx_simcall_t simcall, smx_actor_t process, double timeout);
1454 XBT_PRIVATE void simcall_HANDLER_process_sleep(smx_simcall_t simcall, double duration);
1455 XBT_PRIVATE boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl>
1456 simcall_HANDLER_execution_start(smx_simcall_t simcall, const char* name, double flops_amount, double priority,
1457                                 double bound);
1458 XBT_PRIVATE void
1459 simcall_HANDLER_execution_wait(smx_simcall_t simcall,
1460                                boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> execution);
1461 XBT_PRIVATE boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
1462 simcall_HANDLER_comm_iprobe(smx_simcall_t simcall, smx_mailbox_t mbox, int type, simix_match_func_t match_fun,
1463                             void* data);
1464 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);
1465 XBT_PRIVATE boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
1466 simcall_HANDLER_comm_isend(smx_simcall_t simcall, smx_actor_t sender, smx_mailbox_t mbox, double task_size, double rate,
1467                            void* src_buff, size_t src_buff_size, simix_match_func_t match_fun,
1468                            simix_clean_func_t clean_fun, simix_copy_data_func_t copy_data_fun, void* data,
1469                            int detached);
1470 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);
1471 XBT_PRIVATE boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
1472 simcall_HANDLER_comm_irecv(smx_simcall_t simcall, smx_actor_t receiver, smx_mailbox_t mbox, void* dst_buff,
1473                            size_t* dst_buff_size, simix_match_func_t match_fun, simix_copy_data_func_t copy_data_fun,
1474                            void* data, double rate);
1475 XBT_PRIVATE void simcall_HANDLER_comm_waitany(smx_simcall_t simcall, xbt_dynar_t comms, double timeout);
1476 XBT_PRIVATE void simcall_HANDLER_comm_wait(smx_simcall_t simcall,
1477                                            boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> comm,
1478                                            double timeout);
1479 XBT_PRIVATE void simcall_HANDLER_comm_test(smx_simcall_t simcall,
1480                                            boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> comm);
1481 XBT_PRIVATE void simcall_HANDLER_comm_testany(smx_simcall_t simcall,
1482                                               boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>* comms,
1483                                               size_t count);
1484 XBT_PRIVATE void simcall_HANDLER_mutex_lock(smx_simcall_t simcall, smx_mutex_t mutex);
1485 XBT_PRIVATE int simcall_HANDLER_mutex_trylock(smx_simcall_t simcall, smx_mutex_t mutex);
1486 XBT_PRIVATE void simcall_HANDLER_mutex_unlock(smx_simcall_t simcall, smx_mutex_t mutex);
1487 XBT_PRIVATE void simcall_HANDLER_cond_wait(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex);
1488 XBT_PRIVATE void simcall_HANDLER_cond_wait_timeout(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex, double timeout);
1489 XBT_PRIVATE void simcall_HANDLER_sem_acquire(smx_simcall_t simcall, smx_sem_t sem);
1490 XBT_PRIVATE void simcall_HANDLER_sem_acquire_timeout(smx_simcall_t simcall, smx_sem_t sem, double timeout);
1491 XBT_PRIVATE void simcall_HANDLER_file_read(smx_simcall_t simcall, surf_file_t fd, sg_size_t size);
1492 XBT_PRIVATE void simcall_HANDLER_file_write(smx_simcall_t simcall, surf_file_t fd, sg_size_t size);
1493 XBT_PRIVATE int simcall_HANDLER_mc_random(smx_simcall_t simcall, int min, int max);