Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Modernize simcall process_on_exit.
[simgrid.git] / src / simix / popping_accessors.hpp
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-2018. 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.hpp"
18 static inline smx_actor_t simcall_process_suspend__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_suspend__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_suspend__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 smx_actor_t simcall_process_join__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_join__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_join__set__process(smx_simcall_t simcall, smx_actor_t arg)
40 {
41   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
42 }
43 static inline double simcall_process_join__get__timeout(smx_simcall_t simcall)
44 {
45   return simgrid::simix::unmarshal<double>(simcall->args[1]);
46 }
47 static inline double simcall_process_join__getraw__timeout(smx_simcall_t simcall)
48 {
49   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
50 }
51 static inline void simcall_process_join__set__timeout(smx_simcall_t simcall, double arg)
52 {
53   simgrid::simix::marshal<double>(simcall->args[1], arg);
54 }
55 static inline int simcall_process_join__get__result(smx_simcall_t simcall)
56 {
57   return simgrid::simix::unmarshal<int>(simcall->result);
58 }
59 static inline int simcall_process_join__getraw__result(smx_simcall_t simcall)
60 {
61   return simgrid::simix::unmarshal_raw<int>(simcall->result);
62 }
63 static inline void simcall_process_join__set__result(smx_simcall_t simcall, int result)
64 {
65   simgrid::simix::marshal<int>(simcall->result, result);
66 }
67
68 static inline double simcall_process_sleep__get__duration(smx_simcall_t simcall)
69 {
70   return simgrid::simix::unmarshal<double>(simcall->args[0]);
71 }
72 static inline double simcall_process_sleep__getraw__duration(smx_simcall_t simcall)
73 {
74   return simgrid::simix::unmarshal_raw<double>(simcall->args[0]);
75 }
76 static inline void simcall_process_sleep__set__duration(smx_simcall_t simcall, double arg)
77 {
78   simgrid::simix::marshal<double>(simcall->args[0], arg);
79 }
80 static inline int simcall_process_sleep__get__result(smx_simcall_t simcall)
81 {
82   return simgrid::simix::unmarshal<int>(simcall->result);
83 }
84 static inline int simcall_process_sleep__getraw__result(smx_simcall_t simcall)
85 {
86   return simgrid::simix::unmarshal_raw<int>(simcall->result);
87 }
88 static inline void simcall_process_sleep__set__result(smx_simcall_t simcall, int result)
89 {
90   simgrid::simix::marshal<int>(simcall->result, result);
91 }
92
93 static inline const char* simcall_execution_start__get__name(smx_simcall_t simcall)
94 {
95   return simgrid::simix::unmarshal<const char*>(simcall->args[0]);
96 }
97 static inline const char* simcall_execution_start__getraw__name(smx_simcall_t simcall)
98 {
99   return simgrid::simix::unmarshal_raw<const char*>(simcall->args[0]);
100 }
101 static inline void simcall_execution_start__set__name(smx_simcall_t simcall, const char* arg)
102 {
103   simgrid::simix::marshal<const char*>(simcall->args[0], arg);
104 }
105 static inline double simcall_execution_start__get__flops_amount(smx_simcall_t simcall)
106 {
107   return simgrid::simix::unmarshal<double>(simcall->args[1]);
108 }
109 static inline double simcall_execution_start__getraw__flops_amount(smx_simcall_t simcall)
110 {
111   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
112 }
113 static inline void simcall_execution_start__set__flops_amount(smx_simcall_t simcall, double arg)
114 {
115   simgrid::simix::marshal<double>(simcall->args[1], arg);
116 }
117 static inline double simcall_execution_start__get__priority(smx_simcall_t simcall)
118 {
119   return simgrid::simix::unmarshal<double>(simcall->args[2]);
120 }
121 static inline double simcall_execution_start__getraw__priority(smx_simcall_t simcall)
122 {
123   return simgrid::simix::unmarshal_raw<double>(simcall->args[2]);
124 }
125 static inline void simcall_execution_start__set__priority(smx_simcall_t simcall, double arg)
126 {
127   simgrid::simix::marshal<double>(simcall->args[2], arg);
128 }
129 static inline double simcall_execution_start__get__bound(smx_simcall_t simcall)
130 {
131   return simgrid::simix::unmarshal<double>(simcall->args[3]);
132 }
133 static inline double simcall_execution_start__getraw__bound(smx_simcall_t simcall)
134 {
135   return simgrid::simix::unmarshal_raw<double>(simcall->args[3]);
136 }
137 static inline void simcall_execution_start__set__bound(smx_simcall_t simcall, double arg)
138 {
139   simgrid::simix::marshal<double>(simcall->args[3], arg);
140 }
141 static inline sg_host_t simcall_execution_start__get__host(smx_simcall_t simcall)
142 {
143   return simgrid::simix::unmarshal<sg_host_t>(simcall->args[4]);
144 }
145 static inline sg_host_t simcall_execution_start__getraw__host(smx_simcall_t simcall)
146 {
147   return simgrid::simix::unmarshal_raw<sg_host_t>(simcall->args[4]);
148 }
149 static inline void simcall_execution_start__set__host(smx_simcall_t simcall, sg_host_t arg)
150 {
151   simgrid::simix::marshal<sg_host_t>(simcall->args[4], arg);
152 }
153 static inline boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl> simcall_execution_start__get__result(smx_simcall_t simcall)
154 {
155   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl>>(simcall->result);
156 }
157 static inline simgrid::kernel::activity::ExecImpl* simcall_execution_start__getraw__result(smx_simcall_t simcall)
158 {
159   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ExecImpl*>(simcall->result);
160 }
161 static inline void simcall_execution_start__set__result(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl> result)
162 {
163   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl>>(simcall->result, result);
164 }
165
166 static inline const char* simcall_execution_parallel_start__get__name(smx_simcall_t simcall)
167 {
168   return simgrid::simix::unmarshal<const char*>(simcall->args[0]);
169 }
170 static inline const char* simcall_execution_parallel_start__getraw__name(smx_simcall_t simcall)
171 {
172   return simgrid::simix::unmarshal_raw<const char*>(simcall->args[0]);
173 }
174 static inline void simcall_execution_parallel_start__set__name(smx_simcall_t simcall, const char* arg)
175 {
176   simgrid::simix::marshal<const char*>(simcall->args[0], arg);
177 }
178 static inline int simcall_execution_parallel_start__get__host_nb(smx_simcall_t simcall)
179 {
180   return simgrid::simix::unmarshal<int>(simcall->args[1]);
181 }
182 static inline int simcall_execution_parallel_start__getraw__host_nb(smx_simcall_t simcall)
183 {
184   return simgrid::simix::unmarshal_raw<int>(simcall->args[1]);
185 }
186 static inline void simcall_execution_parallel_start__set__host_nb(smx_simcall_t simcall, int arg)
187 {
188   simgrid::simix::marshal<int>(simcall->args[1], arg);
189 }
190 static inline sg_host_t* simcall_execution_parallel_start__get__host_list(smx_simcall_t simcall)
191 {
192   return simgrid::simix::unmarshal<sg_host_t*>(simcall->args[2]);
193 }
194 static inline sg_host_t* simcall_execution_parallel_start__getraw__host_list(smx_simcall_t simcall)
195 {
196   return simgrid::simix::unmarshal_raw<sg_host_t*>(simcall->args[2]);
197 }
198 static inline void simcall_execution_parallel_start__set__host_list(smx_simcall_t simcall, sg_host_t* arg)
199 {
200   simgrid::simix::marshal<sg_host_t*>(simcall->args[2], arg);
201 }
202 static inline double* simcall_execution_parallel_start__get__flops_amount(smx_simcall_t simcall)
203 {
204   return simgrid::simix::unmarshal<double*>(simcall->args[3]);
205 }
206 static inline double* simcall_execution_parallel_start__getraw__flops_amount(smx_simcall_t simcall)
207 {
208   return simgrid::simix::unmarshal_raw<double*>(simcall->args[3]);
209 }
210 static inline void simcall_execution_parallel_start__set__flops_amount(smx_simcall_t simcall, double* arg)
211 {
212   simgrid::simix::marshal<double*>(simcall->args[3], arg);
213 }
214 static inline double* simcall_execution_parallel_start__get__bytes_amount(smx_simcall_t simcall)
215 {
216   return simgrid::simix::unmarshal<double*>(simcall->args[4]);
217 }
218 static inline double* simcall_execution_parallel_start__getraw__bytes_amount(smx_simcall_t simcall)
219 {
220   return simgrid::simix::unmarshal_raw<double*>(simcall->args[4]);
221 }
222 static inline void simcall_execution_parallel_start__set__bytes_amount(smx_simcall_t simcall, double* arg)
223 {
224   simgrid::simix::marshal<double*>(simcall->args[4], arg);
225 }
226 static inline double simcall_execution_parallel_start__get__rate(smx_simcall_t simcall)
227 {
228   return simgrid::simix::unmarshal<double>(simcall->args[5]);
229 }
230 static inline double simcall_execution_parallel_start__getraw__rate(smx_simcall_t simcall)
231 {
232   return simgrid::simix::unmarshal_raw<double>(simcall->args[5]);
233 }
234 static inline void simcall_execution_parallel_start__set__rate(smx_simcall_t simcall, double arg)
235 {
236   simgrid::simix::marshal<double>(simcall->args[5], arg);
237 }
238 static inline double simcall_execution_parallel_start__get__timeout(smx_simcall_t simcall)
239 {
240   return simgrid::simix::unmarshal<double>(simcall->args[6]);
241 }
242 static inline double simcall_execution_parallel_start__getraw__timeout(smx_simcall_t simcall)
243 {
244   return simgrid::simix::unmarshal_raw<double>(simcall->args[6]);
245 }
246 static inline void simcall_execution_parallel_start__set__timeout(smx_simcall_t simcall, double arg)
247 {
248   simgrid::simix::marshal<double>(simcall->args[6], arg);
249 }
250 static inline boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl> simcall_execution_parallel_start__get__result(smx_simcall_t simcall)
251 {
252   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl>>(simcall->result);
253 }
254 static inline simgrid::kernel::activity::ExecImpl* simcall_execution_parallel_start__getraw__result(smx_simcall_t simcall)
255 {
256   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ExecImpl*>(simcall->result);
257 }
258 static inline void simcall_execution_parallel_start__set__result(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl> result)
259 {
260   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl>>(simcall->result, result);
261 }
262
263 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_execution_wait__get__execution(smx_simcall_t simcall)
264 {
265   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
266 }
267 static inline simgrid::kernel::activity::ActivityImpl* simcall_execution_wait__getraw__execution(smx_simcall_t simcall)
268 {
269   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
270 }
271 static inline void simcall_execution_wait__set__execution(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
272 {
273   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
274 }
275 static inline int simcall_execution_wait__get__result(smx_simcall_t simcall)
276 {
277   return simgrid::simix::unmarshal<int>(simcall->result);
278 }
279 static inline int simcall_execution_wait__getraw__result(smx_simcall_t simcall)
280 {
281   return simgrid::simix::unmarshal_raw<int>(simcall->result);
282 }
283 static inline void simcall_execution_wait__set__result(smx_simcall_t simcall, int result)
284 {
285   simgrid::simix::marshal<int>(simcall->result, result);
286 }
287
288 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
289 simcall_execution_test__get__execution(smx_simcall_t simcall)
290 {
291   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
292 }
293 static inline simgrid::kernel::activity::ActivityImpl* simcall_execution_test__getraw__execution(smx_simcall_t simcall)
294 {
295   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
296 }
297 static inline void
298 simcall_execution_test__set__execution(smx_simcall_t simcall,
299                                        boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
300 {
301   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
302 }
303 static inline int simcall_execution_test__get__result(smx_simcall_t simcall)
304 {
305   return simgrid::simix::unmarshal<int>(simcall->result);
306 }
307 static inline int simcall_execution_test__getraw__result(smx_simcall_t simcall)
308 {
309   return simgrid::simix::unmarshal_raw<int>(simcall->result);
310 }
311 static inline void simcall_execution_test__set__result(smx_simcall_t simcall, int result)
312 {
313   simgrid::simix::marshal<int>(simcall->result, result);
314 }
315
316 static inline smx_mailbox_t simcall_comm_iprobe__get__mbox(smx_simcall_t simcall)
317 {
318   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[0]);
319 }
320 static inline smx_mailbox_t simcall_comm_iprobe__getraw__mbox(smx_simcall_t simcall)
321 {
322   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[0]);
323 }
324 static inline void simcall_comm_iprobe__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
325 {
326   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[0], arg);
327 }
328 static inline int simcall_comm_iprobe__get__type(smx_simcall_t simcall)
329 {
330   return simgrid::simix::unmarshal<int>(simcall->args[1]);
331 }
332 static inline int simcall_comm_iprobe__getraw__type(smx_simcall_t simcall)
333 {
334   return simgrid::simix::unmarshal_raw<int>(simcall->args[1]);
335 }
336 static inline void simcall_comm_iprobe__set__type(smx_simcall_t simcall, int arg)
337 {
338   simgrid::simix::marshal<int>(simcall->args[1], arg);
339 }
340 static inline simix_match_func_t simcall_comm_iprobe__get__match_fun(smx_simcall_t simcall)
341 {
342   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[2]);
343 }
344 static inline simix_match_func_t simcall_comm_iprobe__getraw__match_fun(smx_simcall_t simcall)
345 {
346   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[2]);
347 }
348 static inline void simcall_comm_iprobe__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
349 {
350   simgrid::simix::marshal<simix_match_func_t>(simcall->args[2], arg);
351 }
352 static inline void* simcall_comm_iprobe__get__data(smx_simcall_t simcall)
353 {
354   return simgrid::simix::unmarshal<void*>(simcall->args[3]);
355 }
356 static inline void* simcall_comm_iprobe__getraw__data(smx_simcall_t simcall)
357 {
358   return simgrid::simix::unmarshal_raw<void*>(simcall->args[3]);
359 }
360 static inline void simcall_comm_iprobe__set__data(smx_simcall_t simcall, void* arg)
361 {
362   simgrid::simix::marshal<void*>(simcall->args[3], arg);
363 }
364 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_comm_iprobe__get__result(smx_simcall_t simcall)
365 {
366   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result);
367 }
368 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_iprobe__getraw__result(smx_simcall_t simcall)
369 {
370   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->result);
371 }
372 static inline void simcall_comm_iprobe__set__result(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> result)
373 {
374   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result, result);
375 }
376
377 static inline smx_actor_t simcall_comm_send__get__sender(smx_simcall_t simcall)
378 {
379   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
380 }
381 static inline smx_actor_t simcall_comm_send__getraw__sender(smx_simcall_t simcall)
382 {
383   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
384 }
385 static inline void simcall_comm_send__set__sender(smx_simcall_t simcall, smx_actor_t arg)
386 {
387   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
388 }
389 static inline smx_mailbox_t simcall_comm_send__get__mbox(smx_simcall_t simcall)
390 {
391   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[1]);
392 }
393 static inline smx_mailbox_t simcall_comm_send__getraw__mbox(smx_simcall_t simcall)
394 {
395   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[1]);
396 }
397 static inline void simcall_comm_send__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
398 {
399   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[1], arg);
400 }
401 static inline double simcall_comm_send__get__task_size(smx_simcall_t simcall)
402 {
403   return simgrid::simix::unmarshal<double>(simcall->args[2]);
404 }
405 static inline double simcall_comm_send__getraw__task_size(smx_simcall_t simcall)
406 {
407   return simgrid::simix::unmarshal_raw<double>(simcall->args[2]);
408 }
409 static inline void simcall_comm_send__set__task_size(smx_simcall_t simcall, double arg)
410 {
411   simgrid::simix::marshal<double>(simcall->args[2], arg);
412 }
413 static inline double simcall_comm_send__get__rate(smx_simcall_t simcall)
414 {
415   return simgrid::simix::unmarshal<double>(simcall->args[3]);
416 }
417 static inline double simcall_comm_send__getraw__rate(smx_simcall_t simcall)
418 {
419   return simgrid::simix::unmarshal_raw<double>(simcall->args[3]);
420 }
421 static inline void simcall_comm_send__set__rate(smx_simcall_t simcall, double arg)
422 {
423   simgrid::simix::marshal<double>(simcall->args[3], arg);
424 }
425 static inline void* simcall_comm_send__get__src_buff(smx_simcall_t simcall)
426 {
427   return simgrid::simix::unmarshal<void*>(simcall->args[4]);
428 }
429 static inline void* simcall_comm_send__getraw__src_buff(smx_simcall_t simcall)
430 {
431   return simgrid::simix::unmarshal_raw<void*>(simcall->args[4]);
432 }
433 static inline void simcall_comm_send__set__src_buff(smx_simcall_t simcall, void* arg)
434 {
435   simgrid::simix::marshal<void*>(simcall->args[4], arg);
436 }
437 static inline size_t simcall_comm_send__get__src_buff_size(smx_simcall_t simcall)
438 {
439   return simgrid::simix::unmarshal<size_t>(simcall->args[5]);
440 }
441 static inline size_t simcall_comm_send__getraw__src_buff_size(smx_simcall_t simcall)
442 {
443   return simgrid::simix::unmarshal_raw<size_t>(simcall->args[5]);
444 }
445 static inline void simcall_comm_send__set__src_buff_size(smx_simcall_t simcall, size_t arg)
446 {
447   simgrid::simix::marshal<size_t>(simcall->args[5], arg);
448 }
449 static inline simix_match_func_t simcall_comm_send__get__match_fun(smx_simcall_t simcall)
450 {
451   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[6]);
452 }
453 static inline simix_match_func_t simcall_comm_send__getraw__match_fun(smx_simcall_t simcall)
454 {
455   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[6]);
456 }
457 static inline void simcall_comm_send__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
458 {
459   simgrid::simix::marshal<simix_match_func_t>(simcall->args[6], arg);
460 }
461 static inline simix_copy_data_func_t simcall_comm_send__get__copy_data_fun(smx_simcall_t simcall)
462 {
463   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[7]);
464 }
465 static inline simix_copy_data_func_t simcall_comm_send__getraw__copy_data_fun(smx_simcall_t simcall)
466 {
467   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args[7]);
468 }
469 static inline void simcall_comm_send__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
470 {
471   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[7], arg);
472 }
473 static inline void* simcall_comm_send__get__data(smx_simcall_t simcall)
474 {
475   return simgrid::simix::unmarshal<void*>(simcall->args[8]);
476 }
477 static inline void* simcall_comm_send__getraw__data(smx_simcall_t simcall)
478 {
479   return simgrid::simix::unmarshal_raw<void*>(simcall->args[8]);
480 }
481 static inline void simcall_comm_send__set__data(smx_simcall_t simcall, void* arg)
482 {
483   simgrid::simix::marshal<void*>(simcall->args[8], arg);
484 }
485 static inline double simcall_comm_send__get__timeout(smx_simcall_t simcall)
486 {
487   return simgrid::simix::unmarshal<double>(simcall->args[9]);
488 }
489 static inline double simcall_comm_send__getraw__timeout(smx_simcall_t simcall)
490 {
491   return simgrid::simix::unmarshal_raw<double>(simcall->args[9]);
492 }
493 static inline void simcall_comm_send__set__timeout(smx_simcall_t simcall, double arg)
494 {
495   simgrid::simix::marshal<double>(simcall->args[9], arg);
496 }
497
498 static inline smx_actor_t simcall_comm_isend__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_isend__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_isend__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_isend__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_isend__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_isend__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_isend__get__task_size(smx_simcall_t simcall)
523 {
524   return simgrid::simix::unmarshal<double>(simcall->args[2]);
525 }
526 static inline double simcall_comm_isend__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_isend__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_isend__get__rate(smx_simcall_t simcall)
535 {
536   return simgrid::simix::unmarshal<double>(simcall->args[3]);
537 }
538 static inline double simcall_comm_isend__getraw__rate(smx_simcall_t simcall)
539 {
540   return simgrid::simix::unmarshal_raw<double>(simcall->args[3]);
541 }
542 static inline void simcall_comm_isend__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_isend__get__src_buff(smx_simcall_t simcall)
547 {
548   return simgrid::simix::unmarshal<void*>(simcall->args[4]);
549 }
550 static inline void* simcall_comm_isend__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_isend__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_isend__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_isend__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_isend__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_isend__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_isend__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_isend__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_clean_func_t simcall_comm_isend__get__clean_fun(smx_simcall_t simcall)
583 {
584   return simgrid::simix::unmarshal<simix_clean_func_t>(simcall->args[7]);
585 }
586 static inline simix_clean_func_t simcall_comm_isend__getraw__clean_fun(smx_simcall_t simcall)
587 {
588   return simgrid::simix::unmarshal_raw<simix_clean_func_t>(simcall->args[7]);
589 }
590 static inline void simcall_comm_isend__set__clean_fun(smx_simcall_t simcall, simix_clean_func_t arg)
591 {
592   simgrid::simix::marshal<simix_clean_func_t>(simcall->args[7], arg);
593 }
594 static inline simix_copy_data_func_t simcall_comm_isend__get__copy_data_fun(smx_simcall_t simcall)
595 {
596   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[8]);
597 }
598 static inline simix_copy_data_func_t simcall_comm_isend__getraw__copy_data_fun(smx_simcall_t simcall)
599 {
600   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args[8]);
601 }
602 static inline void simcall_comm_isend__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
603 {
604   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[8], arg);
605 }
606 static inline void* simcall_comm_isend__get__data(smx_simcall_t simcall)
607 {
608   return simgrid::simix::unmarshal<void*>(simcall->args[9]);
609 }
610 static inline void* simcall_comm_isend__getraw__data(smx_simcall_t simcall)
611 {
612   return simgrid::simix::unmarshal_raw<void*>(simcall->args[9]);
613 }
614 static inline void simcall_comm_isend__set__data(smx_simcall_t simcall, void* arg)
615 {
616   simgrid::simix::marshal<void*>(simcall->args[9], arg);
617 }
618 static inline int simcall_comm_isend__get__detached(smx_simcall_t simcall)
619 {
620   return simgrid::simix::unmarshal<int>(simcall->args[10]);
621 }
622 static inline int simcall_comm_isend__getraw__detached(smx_simcall_t simcall)
623 {
624   return simgrid::simix::unmarshal_raw<int>(simcall->args[10]);
625 }
626 static inline void simcall_comm_isend__set__detached(smx_simcall_t simcall, int arg)
627 {
628   simgrid::simix::marshal<int>(simcall->args[10], arg);
629 }
630 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_comm_isend__get__result(smx_simcall_t simcall)
631 {
632   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result);
633 }
634 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_isend__getraw__result(smx_simcall_t simcall)
635 {
636   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->result);
637 }
638 static inline void simcall_comm_isend__set__result(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> result)
639 {
640   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result, result);
641 }
642
643 static inline smx_actor_t simcall_comm_recv__get__receiver(smx_simcall_t simcall)
644 {
645   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
646 }
647 static inline smx_actor_t simcall_comm_recv__getraw__receiver(smx_simcall_t simcall)
648 {
649   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
650 }
651 static inline void simcall_comm_recv__set__receiver(smx_simcall_t simcall, smx_actor_t arg)
652 {
653   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
654 }
655 static inline smx_mailbox_t simcall_comm_recv__get__mbox(smx_simcall_t simcall)
656 {
657   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[1]);
658 }
659 static inline smx_mailbox_t simcall_comm_recv__getraw__mbox(smx_simcall_t simcall)
660 {
661   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[1]);
662 }
663 static inline void simcall_comm_recv__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
664 {
665   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[1], arg);
666 }
667 static inline void* simcall_comm_recv__get__dst_buff(smx_simcall_t simcall)
668 {
669   return simgrid::simix::unmarshal<void*>(simcall->args[2]);
670 }
671 static inline void* simcall_comm_recv__getraw__dst_buff(smx_simcall_t simcall)
672 {
673   return simgrid::simix::unmarshal_raw<void*>(simcall->args[2]);
674 }
675 static inline void simcall_comm_recv__set__dst_buff(smx_simcall_t simcall, void* arg)
676 {
677   simgrid::simix::marshal<void*>(simcall->args[2], arg);
678 }
679 static inline size_t* simcall_comm_recv__get__dst_buff_size(smx_simcall_t simcall)
680 {
681   return simgrid::simix::unmarshal<size_t*>(simcall->args[3]);
682 }
683 static inline size_t* simcall_comm_recv__getraw__dst_buff_size(smx_simcall_t simcall)
684 {
685   return simgrid::simix::unmarshal_raw<size_t*>(simcall->args[3]);
686 }
687 static inline void simcall_comm_recv__set__dst_buff_size(smx_simcall_t simcall, size_t* arg)
688 {
689   simgrid::simix::marshal<size_t*>(simcall->args[3], arg);
690 }
691 static inline simix_match_func_t simcall_comm_recv__get__match_fun(smx_simcall_t simcall)
692 {
693   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[4]);
694 }
695 static inline simix_match_func_t simcall_comm_recv__getraw__match_fun(smx_simcall_t simcall)
696 {
697   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[4]);
698 }
699 static inline void simcall_comm_recv__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
700 {
701   simgrid::simix::marshal<simix_match_func_t>(simcall->args[4], arg);
702 }
703 static inline simix_copy_data_func_t simcall_comm_recv__get__copy_data_fun(smx_simcall_t simcall)
704 {
705   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[5]);
706 }
707 static inline simix_copy_data_func_t simcall_comm_recv__getraw__copy_data_fun(smx_simcall_t simcall)
708 {
709   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args[5]);
710 }
711 static inline void simcall_comm_recv__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
712 {
713   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[5], arg);
714 }
715 static inline void* simcall_comm_recv__get__data(smx_simcall_t simcall)
716 {
717   return simgrid::simix::unmarshal<void*>(simcall->args[6]);
718 }
719 static inline void* simcall_comm_recv__getraw__data(smx_simcall_t simcall)
720 {
721   return simgrid::simix::unmarshal_raw<void*>(simcall->args[6]);
722 }
723 static inline void simcall_comm_recv__set__data(smx_simcall_t simcall, void* arg)
724 {
725   simgrid::simix::marshal<void*>(simcall->args[6], arg);
726 }
727 static inline double simcall_comm_recv__get__timeout(smx_simcall_t simcall)
728 {
729   return simgrid::simix::unmarshal<double>(simcall->args[7]);
730 }
731 static inline double simcall_comm_recv__getraw__timeout(smx_simcall_t simcall)
732 {
733   return simgrid::simix::unmarshal_raw<double>(simcall->args[7]);
734 }
735 static inline void simcall_comm_recv__set__timeout(smx_simcall_t simcall, double arg)
736 {
737   simgrid::simix::marshal<double>(simcall->args[7], arg);
738 }
739 static inline double simcall_comm_recv__get__rate(smx_simcall_t simcall)
740 {
741   return simgrid::simix::unmarshal<double>(simcall->args[8]);
742 }
743 static inline double simcall_comm_recv__getraw__rate(smx_simcall_t simcall)
744 {
745   return simgrid::simix::unmarshal_raw<double>(simcall->args[8]);
746 }
747 static inline void simcall_comm_recv__set__rate(smx_simcall_t simcall, double arg)
748 {
749   simgrid::simix::marshal<double>(simcall->args[8], arg);
750 }
751
752 static inline smx_actor_t simcall_comm_irecv__get__receiver(smx_simcall_t simcall)
753 {
754   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
755 }
756 static inline smx_actor_t simcall_comm_irecv__getraw__receiver(smx_simcall_t simcall)
757 {
758   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
759 }
760 static inline void simcall_comm_irecv__set__receiver(smx_simcall_t simcall, smx_actor_t arg)
761 {
762   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
763 }
764 static inline smx_mailbox_t simcall_comm_irecv__get__mbox(smx_simcall_t simcall)
765 {
766   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[1]);
767 }
768 static inline smx_mailbox_t simcall_comm_irecv__getraw__mbox(smx_simcall_t simcall)
769 {
770   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[1]);
771 }
772 static inline void simcall_comm_irecv__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
773 {
774   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[1], arg);
775 }
776 static inline void* simcall_comm_irecv__get__dst_buff(smx_simcall_t simcall)
777 {
778   return simgrid::simix::unmarshal<void*>(simcall->args[2]);
779 }
780 static inline void* simcall_comm_irecv__getraw__dst_buff(smx_simcall_t simcall)
781 {
782   return simgrid::simix::unmarshal_raw<void*>(simcall->args[2]);
783 }
784 static inline void simcall_comm_irecv__set__dst_buff(smx_simcall_t simcall, void* arg)
785 {
786   simgrid::simix::marshal<void*>(simcall->args[2], arg);
787 }
788 static inline size_t* simcall_comm_irecv__get__dst_buff_size(smx_simcall_t simcall)
789 {
790   return simgrid::simix::unmarshal<size_t*>(simcall->args[3]);
791 }
792 static inline size_t* simcall_comm_irecv__getraw__dst_buff_size(smx_simcall_t simcall)
793 {
794   return simgrid::simix::unmarshal_raw<size_t*>(simcall->args[3]);
795 }
796 static inline void simcall_comm_irecv__set__dst_buff_size(smx_simcall_t simcall, size_t* arg)
797 {
798   simgrid::simix::marshal<size_t*>(simcall->args[3], arg);
799 }
800 static inline simix_match_func_t simcall_comm_irecv__get__match_fun(smx_simcall_t simcall)
801 {
802   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[4]);
803 }
804 static inline simix_match_func_t simcall_comm_irecv__getraw__match_fun(smx_simcall_t simcall)
805 {
806   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[4]);
807 }
808 static inline void simcall_comm_irecv__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
809 {
810   simgrid::simix::marshal<simix_match_func_t>(simcall->args[4], arg);
811 }
812 static inline simix_copy_data_func_t simcall_comm_irecv__get__copy_data_fun(smx_simcall_t simcall)
813 {
814   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[5]);
815 }
816 static inline simix_copy_data_func_t simcall_comm_irecv__getraw__copy_data_fun(smx_simcall_t simcall)
817 {
818   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args[5]);
819 }
820 static inline void simcall_comm_irecv__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
821 {
822   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[5], arg);
823 }
824 static inline void* simcall_comm_irecv__get__data(smx_simcall_t simcall)
825 {
826   return simgrid::simix::unmarshal<void*>(simcall->args[6]);
827 }
828 static inline void* simcall_comm_irecv__getraw__data(smx_simcall_t simcall)
829 {
830   return simgrid::simix::unmarshal_raw<void*>(simcall->args[6]);
831 }
832 static inline void simcall_comm_irecv__set__data(smx_simcall_t simcall, void* arg)
833 {
834   simgrid::simix::marshal<void*>(simcall->args[6], arg);
835 }
836 static inline double simcall_comm_irecv__get__rate(smx_simcall_t simcall)
837 {
838   return simgrid::simix::unmarshal<double>(simcall->args[7]);
839 }
840 static inline double simcall_comm_irecv__getraw__rate(smx_simcall_t simcall)
841 {
842   return simgrid::simix::unmarshal_raw<double>(simcall->args[7]);
843 }
844 static inline void simcall_comm_irecv__set__rate(smx_simcall_t simcall, double arg)
845 {
846   simgrid::simix::marshal<double>(simcall->args[7], arg);
847 }
848 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_comm_irecv__get__result(smx_simcall_t simcall)
849 {
850   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result);
851 }
852 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_irecv__getraw__result(smx_simcall_t simcall)
853 {
854   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->result);
855 }
856 static inline void simcall_comm_irecv__set__result(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> result)
857 {
858   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result, result);
859 }
860
861 static inline xbt_dynar_t simcall_comm_waitany__get__comms(smx_simcall_t simcall)
862 {
863   return simgrid::simix::unmarshal<xbt_dynar_t>(simcall->args[0]);
864 }
865 static inline xbt_dynar_t simcall_comm_waitany__getraw__comms(smx_simcall_t simcall)
866 {
867   return simgrid::simix::unmarshal_raw<xbt_dynar_t>(simcall->args[0]);
868 }
869 static inline void simcall_comm_waitany__set__comms(smx_simcall_t simcall, xbt_dynar_t arg)
870 {
871   simgrid::simix::marshal<xbt_dynar_t>(simcall->args[0], arg);
872 }
873 static inline double simcall_comm_waitany__get__timeout(smx_simcall_t simcall)
874 {
875   return simgrid::simix::unmarshal<double>(simcall->args[1]);
876 }
877 static inline double simcall_comm_waitany__getraw__timeout(smx_simcall_t simcall)
878 {
879   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
880 }
881 static inline void simcall_comm_waitany__set__timeout(smx_simcall_t simcall, double arg)
882 {
883   simgrid::simix::marshal<double>(simcall->args[1], arg);
884 }
885 static inline int simcall_comm_waitany__get__result(smx_simcall_t simcall)
886 {
887   return simgrid::simix::unmarshal<int>(simcall->result);
888 }
889 static inline int simcall_comm_waitany__getraw__result(smx_simcall_t simcall)
890 {
891   return simgrid::simix::unmarshal_raw<int>(simcall->result);
892 }
893 static inline void simcall_comm_waitany__set__result(smx_simcall_t simcall, int result)
894 {
895   simgrid::simix::marshal<int>(simcall->result, result);
896 }
897
898 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_comm_wait__get__comm(smx_simcall_t simcall)
899 {
900   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
901 }
902 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_wait__getraw__comm(smx_simcall_t simcall)
903 {
904   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
905 }
906 static inline void simcall_comm_wait__set__comm(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
907 {
908   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
909 }
910 static inline double simcall_comm_wait__get__timeout(smx_simcall_t simcall)
911 {
912   return simgrid::simix::unmarshal<double>(simcall->args[1]);
913 }
914 static inline double simcall_comm_wait__getraw__timeout(smx_simcall_t simcall)
915 {
916   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
917 }
918 static inline void simcall_comm_wait__set__timeout(smx_simcall_t simcall, double arg)
919 {
920   simgrid::simix::marshal<double>(simcall->args[1], arg);
921 }
922
923 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_comm_test__get__comm(smx_simcall_t simcall)
924 {
925   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
926 }
927 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_test__getraw__comm(smx_simcall_t simcall)
928 {
929   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
930 }
931 static inline void simcall_comm_test__set__comm(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
932 {
933   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
934 }
935 static inline int simcall_comm_test__get__result(smx_simcall_t simcall)
936 {
937   return simgrid::simix::unmarshal<int>(simcall->result);
938 }
939 static inline int simcall_comm_test__getraw__result(smx_simcall_t simcall)
940 {
941   return simgrid::simix::unmarshal_raw<int>(simcall->result);
942 }
943 static inline void simcall_comm_test__set__result(smx_simcall_t simcall, int result)
944 {
945   simgrid::simix::marshal<int>(simcall->result, result);
946 }
947
948 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>* simcall_comm_testany__get__comms(smx_simcall_t simcall)
949 {
950   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>*>(simcall->args[0]);
951 }
952 static inline simgrid::kernel::activity::ActivityImpl** simcall_comm_testany__getraw__comms(smx_simcall_t simcall)
953 {
954   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl**>(simcall->args[0]);
955 }
956 static inline void simcall_comm_testany__set__comms(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>* arg)
957 {
958   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>*>(simcall->args[0], arg);
959 }
960 static inline size_t simcall_comm_testany__get__count(smx_simcall_t simcall)
961 {
962   return simgrid::simix::unmarshal<size_t>(simcall->args[1]);
963 }
964 static inline size_t simcall_comm_testany__getraw__count(smx_simcall_t simcall)
965 {
966   return simgrid::simix::unmarshal_raw<size_t>(simcall->args[1]);
967 }
968 static inline void simcall_comm_testany__set__count(smx_simcall_t simcall, size_t arg)
969 {
970   simgrid::simix::marshal<size_t>(simcall->args[1], arg);
971 }
972 static inline int simcall_comm_testany__get__result(smx_simcall_t simcall)
973 {
974   return simgrid::simix::unmarshal<int>(simcall->result);
975 }
976 static inline int simcall_comm_testany__getraw__result(smx_simcall_t simcall)
977 {
978   return simgrid::simix::unmarshal_raw<int>(simcall->result);
979 }
980 static inline void simcall_comm_testany__set__result(smx_simcall_t simcall, int result)
981 {
982   simgrid::simix::marshal<int>(simcall->result, result);
983 }
984
985 static inline smx_mutex_t simcall_mutex_lock__get__mutex(smx_simcall_t simcall)
986 {
987   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[0]);
988 }
989 static inline smx_mutex_t simcall_mutex_lock__getraw__mutex(smx_simcall_t simcall)
990 {
991   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[0]);
992 }
993 static inline void simcall_mutex_lock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
994 {
995   simgrid::simix::marshal<smx_mutex_t>(simcall->args[0], arg);
996 }
997
998 static inline smx_mutex_t simcall_mutex_trylock__get__mutex(smx_simcall_t simcall)
999 {
1000   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[0]);
1001 }
1002 static inline smx_mutex_t simcall_mutex_trylock__getraw__mutex(smx_simcall_t simcall)
1003 {
1004   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[0]);
1005 }
1006 static inline void simcall_mutex_trylock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
1007 {
1008   simgrid::simix::marshal<smx_mutex_t>(simcall->args[0], arg);
1009 }
1010 static inline int simcall_mutex_trylock__get__result(smx_simcall_t simcall)
1011 {
1012   return simgrid::simix::unmarshal<int>(simcall->result);
1013 }
1014 static inline int simcall_mutex_trylock__getraw__result(smx_simcall_t simcall)
1015 {
1016   return simgrid::simix::unmarshal_raw<int>(simcall->result);
1017 }
1018 static inline void simcall_mutex_trylock__set__result(smx_simcall_t simcall, int result)
1019 {
1020   simgrid::simix::marshal<int>(simcall->result, result);
1021 }
1022
1023 static inline smx_mutex_t simcall_mutex_unlock__get__mutex(smx_simcall_t simcall)
1024 {
1025   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[0]);
1026 }
1027 static inline smx_mutex_t simcall_mutex_unlock__getraw__mutex(smx_simcall_t simcall)
1028 {
1029   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[0]);
1030 }
1031 static inline void simcall_mutex_unlock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
1032 {
1033   simgrid::simix::marshal<smx_mutex_t>(simcall->args[0], arg);
1034 }
1035
1036 static inline smx_cond_t simcall_cond_init__get__result(smx_simcall_t simcall)
1037 {
1038   return simgrid::simix::unmarshal<smx_cond_t>(simcall->result);
1039 }
1040 static inline smx_cond_t simcall_cond_init__getraw__result(smx_simcall_t simcall)
1041 {
1042   return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->result);
1043 }
1044 static inline void simcall_cond_init__set__result(smx_simcall_t simcall, smx_cond_t result)
1045 {
1046   simgrid::simix::marshal<smx_cond_t>(simcall->result, result);
1047 }
1048
1049 static inline smx_cond_t simcall_cond_wait__get__cond(smx_simcall_t simcall)
1050 {
1051   return simgrid::simix::unmarshal<smx_cond_t>(simcall->args[0]);
1052 }
1053 static inline smx_cond_t simcall_cond_wait__getraw__cond(smx_simcall_t simcall)
1054 {
1055   return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->args[0]);
1056 }
1057 static inline void simcall_cond_wait__set__cond(smx_simcall_t simcall, smx_cond_t arg)
1058 {
1059   simgrid::simix::marshal<smx_cond_t>(simcall->args[0], arg);
1060 }
1061 static inline smx_mutex_t simcall_cond_wait__get__mutex(smx_simcall_t simcall)
1062 {
1063   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[1]);
1064 }
1065 static inline smx_mutex_t simcall_cond_wait__getraw__mutex(smx_simcall_t simcall)
1066 {
1067   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[1]);
1068 }
1069 static inline void simcall_cond_wait__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
1070 {
1071   simgrid::simix::marshal<smx_mutex_t>(simcall->args[1], arg);
1072 }
1073
1074 static inline smx_cond_t simcall_cond_wait_timeout__get__cond(smx_simcall_t simcall)
1075 {
1076   return simgrid::simix::unmarshal<smx_cond_t>(simcall->args[0]);
1077 }
1078 static inline smx_cond_t simcall_cond_wait_timeout__getraw__cond(smx_simcall_t simcall)
1079 {
1080   return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->args[0]);
1081 }
1082 static inline void simcall_cond_wait_timeout__set__cond(smx_simcall_t simcall, smx_cond_t arg)
1083 {
1084   simgrid::simix::marshal<smx_cond_t>(simcall->args[0], arg);
1085 }
1086 static inline smx_mutex_t simcall_cond_wait_timeout__get__mutex(smx_simcall_t simcall)
1087 {
1088   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[1]);
1089 }
1090 static inline smx_mutex_t simcall_cond_wait_timeout__getraw__mutex(smx_simcall_t simcall)
1091 {
1092   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[1]);
1093 }
1094 static inline void simcall_cond_wait_timeout__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
1095 {
1096   simgrid::simix::marshal<smx_mutex_t>(simcall->args[1], arg);
1097 }
1098 static inline double simcall_cond_wait_timeout__get__timeout(smx_simcall_t simcall)
1099 {
1100   return simgrid::simix::unmarshal<double>(simcall->args[2]);
1101 }
1102 static inline double simcall_cond_wait_timeout__getraw__timeout(smx_simcall_t simcall)
1103 {
1104   return simgrid::simix::unmarshal_raw<double>(simcall->args[2]);
1105 }
1106 static inline void simcall_cond_wait_timeout__set__timeout(smx_simcall_t simcall, double arg)
1107 {
1108   simgrid::simix::marshal<double>(simcall->args[2], arg);
1109 }
1110
1111 static inline smx_sem_t simcall_sem_acquire__get__sem(smx_simcall_t simcall)
1112 {
1113   return simgrid::simix::unmarshal<smx_sem_t>(simcall->args[0]);
1114 }
1115 static inline smx_sem_t simcall_sem_acquire__getraw__sem(smx_simcall_t simcall)
1116 {
1117   return simgrid::simix::unmarshal_raw<smx_sem_t>(simcall->args[0]);
1118 }
1119 static inline void simcall_sem_acquire__set__sem(smx_simcall_t simcall, smx_sem_t arg)
1120 {
1121   simgrid::simix::marshal<smx_sem_t>(simcall->args[0], arg);
1122 }
1123
1124 static inline smx_sem_t simcall_sem_acquire_timeout__get__sem(smx_simcall_t simcall)
1125 {
1126   return simgrid::simix::unmarshal<smx_sem_t>(simcall->args[0]);
1127 }
1128 static inline smx_sem_t simcall_sem_acquire_timeout__getraw__sem(smx_simcall_t simcall)
1129 {
1130   return simgrid::simix::unmarshal_raw<smx_sem_t>(simcall->args[0]);
1131 }
1132 static inline void simcall_sem_acquire_timeout__set__sem(smx_simcall_t simcall, smx_sem_t arg)
1133 {
1134   simgrid::simix::marshal<smx_sem_t>(simcall->args[0], arg);
1135 }
1136 static inline double simcall_sem_acquire_timeout__get__timeout(smx_simcall_t simcall)
1137 {
1138   return simgrid::simix::unmarshal<double>(simcall->args[1]);
1139 }
1140 static inline double simcall_sem_acquire_timeout__getraw__timeout(smx_simcall_t simcall)
1141 {
1142   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
1143 }
1144 static inline void simcall_sem_acquire_timeout__set__timeout(smx_simcall_t simcall, double arg)
1145 {
1146   simgrid::simix::marshal<double>(simcall->args[1], arg);
1147 }
1148
1149 static inline surf_storage_t simcall_storage_read__get__st(smx_simcall_t simcall)
1150 {
1151   return simgrid::simix::unmarshal<surf_storage_t>(simcall->args[0]);
1152 }
1153 static inline surf_storage_t simcall_storage_read__getraw__st(smx_simcall_t simcall)
1154 {
1155   return simgrid::simix::unmarshal_raw<surf_storage_t>(simcall->args[0]);
1156 }
1157 static inline void simcall_storage_read__set__st(smx_simcall_t simcall, surf_storage_t arg)
1158 {
1159   simgrid::simix::marshal<surf_storage_t>(simcall->args[0], arg);
1160 }
1161 static inline sg_size_t simcall_storage_read__get__size(smx_simcall_t simcall)
1162 {
1163   return simgrid::simix::unmarshal<sg_size_t>(simcall->args[1]);
1164 }
1165 static inline sg_size_t simcall_storage_read__getraw__size(smx_simcall_t simcall)
1166 {
1167   return simgrid::simix::unmarshal_raw<sg_size_t>(simcall->args[1]);
1168 }
1169 static inline void simcall_storage_read__set__size(smx_simcall_t simcall, sg_size_t arg)
1170 {
1171   simgrid::simix::marshal<sg_size_t>(simcall->args[1], arg);
1172 }
1173 static inline sg_size_t simcall_storage_read__get__result(smx_simcall_t simcall)
1174 {
1175   return simgrid::simix::unmarshal<sg_size_t>(simcall->result);
1176 }
1177 static inline sg_size_t simcall_storage_read__getraw__result(smx_simcall_t simcall)
1178 {
1179   return simgrid::simix::unmarshal_raw<sg_size_t>(simcall->result);
1180 }
1181 static inline void simcall_storage_read__set__result(smx_simcall_t simcall, sg_size_t result)
1182 {
1183   simgrid::simix::marshal<sg_size_t>(simcall->result, result);
1184 }
1185
1186 static inline surf_storage_t simcall_storage_write__get__st(smx_simcall_t simcall)
1187 {
1188   return simgrid::simix::unmarshal<surf_storage_t>(simcall->args[0]);
1189 }
1190 static inline surf_storage_t simcall_storage_write__getraw__st(smx_simcall_t simcall)
1191 {
1192   return simgrid::simix::unmarshal_raw<surf_storage_t>(simcall->args[0]);
1193 }
1194 static inline void simcall_storage_write__set__st(smx_simcall_t simcall, surf_storage_t arg)
1195 {
1196   simgrid::simix::marshal<surf_storage_t>(simcall->args[0], arg);
1197 }
1198 static inline sg_size_t simcall_storage_write__get__size(smx_simcall_t simcall)
1199 {
1200   return simgrid::simix::unmarshal<sg_size_t>(simcall->args[1]);
1201 }
1202 static inline sg_size_t simcall_storage_write__getraw__size(smx_simcall_t simcall)
1203 {
1204   return simgrid::simix::unmarshal_raw<sg_size_t>(simcall->args[1]);
1205 }
1206 static inline void simcall_storage_write__set__size(smx_simcall_t simcall, sg_size_t arg)
1207 {
1208   simgrid::simix::marshal<sg_size_t>(simcall->args[1], arg);
1209 }
1210 static inline sg_size_t simcall_storage_write__get__result(smx_simcall_t simcall)
1211 {
1212   return simgrid::simix::unmarshal<sg_size_t>(simcall->result);
1213 }
1214 static inline sg_size_t simcall_storage_write__getraw__result(smx_simcall_t simcall)
1215 {
1216   return simgrid::simix::unmarshal_raw<sg_size_t>(simcall->result);
1217 }
1218 static inline void simcall_storage_write__set__result(smx_simcall_t simcall, sg_size_t result)
1219 {
1220   simgrid::simix::marshal<sg_size_t>(simcall->result, result);
1221 }
1222
1223 static inline int simcall_mc_random__get__min(smx_simcall_t simcall)
1224 {
1225   return simgrid::simix::unmarshal<int>(simcall->args[0]);
1226 }
1227 static inline int simcall_mc_random__getraw__min(smx_simcall_t simcall)
1228 {
1229   return simgrid::simix::unmarshal_raw<int>(simcall->args[0]);
1230 }
1231 static inline void simcall_mc_random__set__min(smx_simcall_t simcall, int arg)
1232 {
1233   simgrid::simix::marshal<int>(simcall->args[0], arg);
1234 }
1235 static inline int simcall_mc_random__get__max(smx_simcall_t simcall)
1236 {
1237   return simgrid::simix::unmarshal<int>(simcall->args[1]);
1238 }
1239 static inline int simcall_mc_random__getraw__max(smx_simcall_t simcall)
1240 {
1241   return simgrid::simix::unmarshal_raw<int>(simcall->args[1]);
1242 }
1243 static inline void simcall_mc_random__set__max(smx_simcall_t simcall, int arg)
1244 {
1245   simgrid::simix::marshal<int>(simcall->args[1], arg);
1246 }
1247 static inline int simcall_mc_random__get__result(smx_simcall_t simcall)
1248 {
1249   return simgrid::simix::unmarshal<int>(simcall->result);
1250 }
1251 static inline int simcall_mc_random__getraw__result(smx_simcall_t simcall)
1252 {
1253   return simgrid::simix::unmarshal_raw<int>(simcall->result);
1254 }
1255 static inline void simcall_mc_random__set__result(smx_simcall_t simcall, int result)
1256 {
1257   simgrid::simix::marshal<int>(simcall->result, result);
1258 }
1259
1260 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_set_category__get__synchro(smx_simcall_t simcall)
1261 {
1262   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
1263 }
1264 static inline simgrid::kernel::activity::ActivityImpl* simcall_set_category__getraw__synchro(smx_simcall_t simcall)
1265 {
1266   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
1267 }
1268 static inline void simcall_set_category__set__synchro(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
1269 {
1270   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
1271 }
1272 static inline const char* simcall_set_category__get__category(smx_simcall_t simcall)
1273 {
1274   return simgrid::simix::unmarshal<const char*>(simcall->args[1]);
1275 }
1276 static inline const char* simcall_set_category__getraw__category(smx_simcall_t simcall)
1277 {
1278   return simgrid::simix::unmarshal_raw<const char*>(simcall->args[1]);
1279 }
1280 static inline void simcall_set_category__set__category(smx_simcall_t simcall, const char* arg)
1281 {
1282   simgrid::simix::marshal<const char*>(simcall->args[1], arg);
1283 }
1284
1285 static inline std::function<void()> const* simcall_run_kernel__get__code(smx_simcall_t simcall)
1286 {
1287   return simgrid::simix::unmarshal<std::function<void()> const*>(simcall->args[0]);
1288 }
1289 static inline std::function<void()> const* simcall_run_kernel__getraw__code(smx_simcall_t simcall)
1290 {
1291   return simgrid::simix::unmarshal_raw<std::function<void()> const*>(simcall->args[0]);
1292 }
1293 static inline void simcall_run_kernel__set__code(smx_simcall_t simcall, std::function<void()> const* arg)
1294 {
1295   simgrid::simix::marshal<std::function<void()> const*>(simcall->args[0], arg);
1296 }
1297
1298 static inline std::function<void()> const* simcall_run_blocking__get__code(smx_simcall_t simcall)
1299 {
1300   return simgrid::simix::unmarshal<std::function<void()> const*>(simcall->args[0]);
1301 }
1302 static inline std::function<void()> const* simcall_run_blocking__getraw__code(smx_simcall_t simcall)
1303 {
1304   return simgrid::simix::unmarshal_raw<std::function<void()> const*>(simcall->args[0]);
1305 }
1306 static inline void simcall_run_blocking__set__code(smx_simcall_t simcall, std::function<void()> const* arg)
1307 {
1308   simgrid::simix::marshal<std::function<void()> const*>(simcall->args[0], arg);
1309 }
1310
1311 /* The prototype of all simcall handlers, automatically generated for you */
1312
1313 XBT_PRIVATE void simcall_HANDLER_process_suspend(smx_simcall_t simcall, smx_actor_t process);
1314 XBT_PRIVATE void simcall_HANDLER_process_join(smx_simcall_t simcall, smx_actor_t process, double timeout);
1315 XBT_PRIVATE void simcall_HANDLER_process_sleep(smx_simcall_t simcall, double duration);
1316 XBT_PRIVATE void simcall_HANDLER_execution_wait(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> execution);
1317 XBT_PRIVATE void
1318 simcall_HANDLER_execution_test(smx_simcall_t simcall,
1319                                boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> execution);
1320 XBT_PRIVATE boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_HANDLER_comm_iprobe(smx_simcall_t simcall, smx_mailbox_t mbox, int type, simix_match_func_t match_fun, void* data);
1321 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);
1322 XBT_PRIVATE boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_HANDLER_comm_isend(smx_simcall_t simcall, smx_actor_t sender, smx_mailbox_t mbox, double task_size, double rate, void* src_buff, size_t src_buff_size, simix_match_func_t match_fun, simix_clean_func_t clean_fun, simix_copy_data_func_t copy_data_fun, void* data, int detached);
1323 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);
1324 XBT_PRIVATE boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_HANDLER_comm_irecv(smx_simcall_t simcall, smx_actor_t receiver, smx_mailbox_t mbox, void* dst_buff, size_t* dst_buff_size, simix_match_func_t match_fun, simix_copy_data_func_t copy_data_fun, void* data, double rate);
1325 XBT_PRIVATE void simcall_HANDLER_comm_waitany(smx_simcall_t simcall, xbt_dynar_t comms, double timeout);
1326 XBT_PRIVATE void simcall_HANDLER_comm_wait(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> comm, double timeout);
1327 XBT_PRIVATE void simcall_HANDLER_comm_test(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> comm);
1328 XBT_PRIVATE void simcall_HANDLER_comm_testany(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>* comms, size_t count);
1329 XBT_PRIVATE void simcall_HANDLER_mutex_lock(smx_simcall_t simcall, smx_mutex_t mutex);
1330 XBT_PRIVATE int simcall_HANDLER_mutex_trylock(smx_simcall_t simcall, smx_mutex_t mutex);
1331 XBT_PRIVATE void simcall_HANDLER_mutex_unlock(smx_simcall_t simcall, smx_mutex_t mutex);
1332 XBT_PRIVATE void simcall_HANDLER_cond_wait(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex);
1333 XBT_PRIVATE void simcall_HANDLER_cond_wait_timeout(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex, double timeout);
1334 XBT_PRIVATE void simcall_HANDLER_sem_acquire(smx_simcall_t simcall, smx_sem_t sem);
1335 XBT_PRIVATE void simcall_HANDLER_sem_acquire_timeout(smx_simcall_t simcall, smx_sem_t sem, double timeout);
1336 XBT_PRIVATE void simcall_HANDLER_storage_read(smx_simcall_t simcall, surf_storage_t st, sg_size_t size);
1337 XBT_PRIVATE void simcall_HANDLER_storage_write(smx_simcall_t simcall, surf_storage_t st, sg_size_t size);
1338 XBT_PRIVATE int simcall_HANDLER_mc_random(smx_simcall_t simcall, int min, int max);