Logo AND Algorithmique Numérique Distribuée

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