Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
simcall_comm_test returns a bool too
[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-2019. 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 simgrid::kernel::activity::ExecImpl* simcall_execution_wait__get__execution(smx_simcall_t simcall)
94 {
95   return simgrid::simix::unmarshal<simgrid::kernel::activity::ExecImpl*>(simcall->args[0]);
96 }
97 static inline simgrid::kernel::activity::ExecImpl* simcall_execution_wait__getraw__execution(smx_simcall_t simcall)
98 {
99   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ExecImpl*>(simcall->args[0]);
100 }
101 static inline void simcall_execution_wait__set__execution(smx_simcall_t simcall, simgrid::kernel::activity::ExecImpl* arg)
102 {
103   simgrid::simix::marshal<simgrid::kernel::activity::ExecImpl*>(simcall->args[0], arg);
104 }
105 static inline int simcall_execution_wait__get__result(smx_simcall_t simcall)
106 {
107   return simgrid::simix::unmarshal<int>(simcall->result);
108 }
109 static inline int simcall_execution_wait__getraw__result(smx_simcall_t simcall)
110 {
111   return simgrid::simix::unmarshal_raw<int>(simcall->result);
112 }
113 static inline void simcall_execution_wait__set__result(smx_simcall_t simcall, int result)
114 {
115   simgrid::simix::marshal<int>(simcall->result, result);
116 }
117
118 static inline simgrid::kernel::activity::ExecImpl* simcall_execution_test__get__execution(smx_simcall_t simcall)
119 {
120   return simgrid::simix::unmarshal<simgrid::kernel::activity::ExecImpl*>(simcall->args[0]);
121 }
122 static inline simgrid::kernel::activity::ExecImpl* simcall_execution_test__getraw__execution(smx_simcall_t simcall)
123 {
124   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ExecImpl*>(simcall->args[0]);
125 }
126 static inline void simcall_execution_test__set__execution(smx_simcall_t simcall, simgrid::kernel::activity::ExecImpl* arg)
127 {
128   simgrid::simix::marshal<simgrid::kernel::activity::ExecImpl*>(simcall->args[0], arg);
129 }
130 static inline bool simcall_execution_test__get__result(smx_simcall_t simcall)
131 {
132   return simgrid::simix::unmarshal<bool>(simcall->result);
133 }
134 static inline bool simcall_execution_test__getraw__result(smx_simcall_t simcall)
135 {
136   return simgrid::simix::unmarshal_raw<bool>(simcall->result);
137 }
138 static inline void simcall_execution_test__set__result(smx_simcall_t simcall, bool result)
139 {
140   simgrid::simix::marshal<bool>(simcall->result, result);
141 }
142
143 static inline smx_actor_t simcall_comm_send__get__sender(smx_simcall_t simcall)
144 {
145   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
146 }
147 static inline smx_actor_t simcall_comm_send__getraw__sender(smx_simcall_t simcall)
148 {
149   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
150 }
151 static inline void simcall_comm_send__set__sender(smx_simcall_t simcall, smx_actor_t arg)
152 {
153   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
154 }
155 static inline smx_mailbox_t simcall_comm_send__get__mbox(smx_simcall_t simcall)
156 {
157   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[1]);
158 }
159 static inline smx_mailbox_t simcall_comm_send__getraw__mbox(smx_simcall_t simcall)
160 {
161   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[1]);
162 }
163 static inline void simcall_comm_send__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
164 {
165   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[1], arg);
166 }
167 static inline double simcall_comm_send__get__task_size(smx_simcall_t simcall)
168 {
169   return simgrid::simix::unmarshal<double>(simcall->args[2]);
170 }
171 static inline double simcall_comm_send__getraw__task_size(smx_simcall_t simcall)
172 {
173   return simgrid::simix::unmarshal_raw<double>(simcall->args[2]);
174 }
175 static inline void simcall_comm_send__set__task_size(smx_simcall_t simcall, double arg)
176 {
177   simgrid::simix::marshal<double>(simcall->args[2], arg);
178 }
179 static inline double simcall_comm_send__get__rate(smx_simcall_t simcall)
180 {
181   return simgrid::simix::unmarshal<double>(simcall->args[3]);
182 }
183 static inline double simcall_comm_send__getraw__rate(smx_simcall_t simcall)
184 {
185   return simgrid::simix::unmarshal_raw<double>(simcall->args[3]);
186 }
187 static inline void simcall_comm_send__set__rate(smx_simcall_t simcall, double arg)
188 {
189   simgrid::simix::marshal<double>(simcall->args[3], arg);
190 }
191 static inline void* simcall_comm_send__get__src_buff(smx_simcall_t simcall)
192 {
193   return simgrid::simix::unmarshal<void*>(simcall->args[4]);
194 }
195 static inline void* simcall_comm_send__getraw__src_buff(smx_simcall_t simcall)
196 {
197   return simgrid::simix::unmarshal_raw<void*>(simcall->args[4]);
198 }
199 static inline void simcall_comm_send__set__src_buff(smx_simcall_t simcall, void* arg)
200 {
201   simgrid::simix::marshal<void*>(simcall->args[4], arg);
202 }
203 static inline size_t simcall_comm_send__get__src_buff_size(smx_simcall_t simcall)
204 {
205   return simgrid::simix::unmarshal<size_t>(simcall->args[5]);
206 }
207 static inline size_t simcall_comm_send__getraw__src_buff_size(smx_simcall_t simcall)
208 {
209   return simgrid::simix::unmarshal_raw<size_t>(simcall->args[5]);
210 }
211 static inline void simcall_comm_send__set__src_buff_size(smx_simcall_t simcall, size_t arg)
212 {
213   simgrid::simix::marshal<size_t>(simcall->args[5], arg);
214 }
215 static inline simix_match_func_t simcall_comm_send__get__match_fun(smx_simcall_t simcall)
216 {
217   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[6]);
218 }
219 static inline simix_match_func_t simcall_comm_send__getraw__match_fun(smx_simcall_t simcall)
220 {
221   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[6]);
222 }
223 static inline void simcall_comm_send__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
224 {
225   simgrid::simix::marshal<simix_match_func_t>(simcall->args[6], arg);
226 }
227 static inline simix_copy_data_func_t simcall_comm_send__get__copy_data_fun(smx_simcall_t simcall)
228 {
229   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[7]);
230 }
231 static inline simix_copy_data_func_t simcall_comm_send__getraw__copy_data_fun(smx_simcall_t simcall)
232 {
233   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args[7]);
234 }
235 static inline void simcall_comm_send__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
236 {
237   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[7], arg);
238 }
239 static inline void* simcall_comm_send__get__data(smx_simcall_t simcall)
240 {
241   return simgrid::simix::unmarshal<void*>(simcall->args[8]);
242 }
243 static inline void* simcall_comm_send__getraw__data(smx_simcall_t simcall)
244 {
245   return simgrid::simix::unmarshal_raw<void*>(simcall->args[8]);
246 }
247 static inline void simcall_comm_send__set__data(smx_simcall_t simcall, void* arg)
248 {
249   simgrid::simix::marshal<void*>(simcall->args[8], arg);
250 }
251 static inline double simcall_comm_send__get__timeout(smx_simcall_t simcall)
252 {
253   return simgrid::simix::unmarshal<double>(simcall->args[9]);
254 }
255 static inline double simcall_comm_send__getraw__timeout(smx_simcall_t simcall)
256 {
257   return simgrid::simix::unmarshal_raw<double>(simcall->args[9]);
258 }
259 static inline void simcall_comm_send__set__timeout(smx_simcall_t simcall, double arg)
260 {
261   simgrid::simix::marshal<double>(simcall->args[9], arg);
262 }
263
264 static inline smx_actor_t simcall_comm_isend__get__sender(smx_simcall_t simcall)
265 {
266   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
267 }
268 static inline smx_actor_t simcall_comm_isend__getraw__sender(smx_simcall_t simcall)
269 {
270   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
271 }
272 static inline void simcall_comm_isend__set__sender(smx_simcall_t simcall, smx_actor_t arg)
273 {
274   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
275 }
276 static inline smx_mailbox_t simcall_comm_isend__get__mbox(smx_simcall_t simcall)
277 {
278   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[1]);
279 }
280 static inline smx_mailbox_t simcall_comm_isend__getraw__mbox(smx_simcall_t simcall)
281 {
282   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[1]);
283 }
284 static inline void simcall_comm_isend__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
285 {
286   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[1], arg);
287 }
288 static inline double simcall_comm_isend__get__task_size(smx_simcall_t simcall)
289 {
290   return simgrid::simix::unmarshal<double>(simcall->args[2]);
291 }
292 static inline double simcall_comm_isend__getraw__task_size(smx_simcall_t simcall)
293 {
294   return simgrid::simix::unmarshal_raw<double>(simcall->args[2]);
295 }
296 static inline void simcall_comm_isend__set__task_size(smx_simcall_t simcall, double arg)
297 {
298   simgrid::simix::marshal<double>(simcall->args[2], arg);
299 }
300 static inline double simcall_comm_isend__get__rate(smx_simcall_t simcall)
301 {
302   return simgrid::simix::unmarshal<double>(simcall->args[3]);
303 }
304 static inline double simcall_comm_isend__getraw__rate(smx_simcall_t simcall)
305 {
306   return simgrid::simix::unmarshal_raw<double>(simcall->args[3]);
307 }
308 static inline void simcall_comm_isend__set__rate(smx_simcall_t simcall, double arg)
309 {
310   simgrid::simix::marshal<double>(simcall->args[3], arg);
311 }
312 static inline void* simcall_comm_isend__get__src_buff(smx_simcall_t simcall)
313 {
314   return simgrid::simix::unmarshal<void*>(simcall->args[4]);
315 }
316 static inline void* simcall_comm_isend__getraw__src_buff(smx_simcall_t simcall)
317 {
318   return simgrid::simix::unmarshal_raw<void*>(simcall->args[4]);
319 }
320 static inline void simcall_comm_isend__set__src_buff(smx_simcall_t simcall, void* arg)
321 {
322   simgrid::simix::marshal<void*>(simcall->args[4], arg);
323 }
324 static inline size_t simcall_comm_isend__get__src_buff_size(smx_simcall_t simcall)
325 {
326   return simgrid::simix::unmarshal<size_t>(simcall->args[5]);
327 }
328 static inline size_t simcall_comm_isend__getraw__src_buff_size(smx_simcall_t simcall)
329 {
330   return simgrid::simix::unmarshal_raw<size_t>(simcall->args[5]);
331 }
332 static inline void simcall_comm_isend__set__src_buff_size(smx_simcall_t simcall, size_t arg)
333 {
334   simgrid::simix::marshal<size_t>(simcall->args[5], arg);
335 }
336 static inline simix_match_func_t simcall_comm_isend__get__match_fun(smx_simcall_t simcall)
337 {
338   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[6]);
339 }
340 static inline simix_match_func_t simcall_comm_isend__getraw__match_fun(smx_simcall_t simcall)
341 {
342   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[6]);
343 }
344 static inline void simcall_comm_isend__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
345 {
346   simgrid::simix::marshal<simix_match_func_t>(simcall->args[6], arg);
347 }
348 static inline simix_clean_func_t simcall_comm_isend__get__clean_fun(smx_simcall_t simcall)
349 {
350   return simgrid::simix::unmarshal<simix_clean_func_t>(simcall->args[7]);
351 }
352 static inline simix_clean_func_t simcall_comm_isend__getraw__clean_fun(smx_simcall_t simcall)
353 {
354   return simgrid::simix::unmarshal_raw<simix_clean_func_t>(simcall->args[7]);
355 }
356 static inline void simcall_comm_isend__set__clean_fun(smx_simcall_t simcall, simix_clean_func_t arg)
357 {
358   simgrid::simix::marshal<simix_clean_func_t>(simcall->args[7], arg);
359 }
360 static inline simix_copy_data_func_t simcall_comm_isend__get__copy_data_fun(smx_simcall_t simcall)
361 {
362   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[8]);
363 }
364 static inline simix_copy_data_func_t simcall_comm_isend__getraw__copy_data_fun(smx_simcall_t simcall)
365 {
366   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args[8]);
367 }
368 static inline void simcall_comm_isend__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
369 {
370   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[8], arg);
371 }
372 static inline void* simcall_comm_isend__get__data(smx_simcall_t simcall)
373 {
374   return simgrid::simix::unmarshal<void*>(simcall->args[9]);
375 }
376 static inline void* simcall_comm_isend__getraw__data(smx_simcall_t simcall)
377 {
378   return simgrid::simix::unmarshal_raw<void*>(simcall->args[9]);
379 }
380 static inline void simcall_comm_isend__set__data(smx_simcall_t simcall, void* arg)
381 {
382   simgrid::simix::marshal<void*>(simcall->args[9], arg);
383 }
384 static inline bool simcall_comm_isend__get__detached(smx_simcall_t simcall)
385 {
386   return simgrid::simix::unmarshal<bool>(simcall->args[10]);
387 }
388 static inline bool simcall_comm_isend__getraw__detached(smx_simcall_t simcall)
389 {
390   return simgrid::simix::unmarshal_raw<bool>(simcall->args[10]);
391 }
392 static inline void simcall_comm_isend__set__detached(smx_simcall_t simcall, bool arg)
393 {
394   simgrid::simix::marshal<bool>(simcall->args[10], arg);
395 }
396 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_comm_isend__get__result(smx_simcall_t simcall)
397 {
398   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result);
399 }
400 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_isend__getraw__result(smx_simcall_t simcall)
401 {
402   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->result);
403 }
404 static inline void simcall_comm_isend__set__result(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> result)
405 {
406   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result, result);
407 }
408
409 static inline smx_actor_t simcall_comm_recv__get__receiver(smx_simcall_t simcall)
410 {
411   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
412 }
413 static inline smx_actor_t simcall_comm_recv__getraw__receiver(smx_simcall_t simcall)
414 {
415   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
416 }
417 static inline void simcall_comm_recv__set__receiver(smx_simcall_t simcall, smx_actor_t arg)
418 {
419   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
420 }
421 static inline smx_mailbox_t simcall_comm_recv__get__mbox(smx_simcall_t simcall)
422 {
423   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[1]);
424 }
425 static inline smx_mailbox_t simcall_comm_recv__getraw__mbox(smx_simcall_t simcall)
426 {
427   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[1]);
428 }
429 static inline void simcall_comm_recv__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
430 {
431   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[1], arg);
432 }
433 static inline void* simcall_comm_recv__get__dst_buff(smx_simcall_t simcall)
434 {
435   return simgrid::simix::unmarshal<void*>(simcall->args[2]);
436 }
437 static inline void* simcall_comm_recv__getraw__dst_buff(smx_simcall_t simcall)
438 {
439   return simgrid::simix::unmarshal_raw<void*>(simcall->args[2]);
440 }
441 static inline void simcall_comm_recv__set__dst_buff(smx_simcall_t simcall, void* arg)
442 {
443   simgrid::simix::marshal<void*>(simcall->args[2], arg);
444 }
445 static inline size_t* simcall_comm_recv__get__dst_buff_size(smx_simcall_t simcall)
446 {
447   return simgrid::simix::unmarshal<size_t*>(simcall->args[3]);
448 }
449 static inline size_t* simcall_comm_recv__getraw__dst_buff_size(smx_simcall_t simcall)
450 {
451   return simgrid::simix::unmarshal_raw<size_t*>(simcall->args[3]);
452 }
453 static inline void simcall_comm_recv__set__dst_buff_size(smx_simcall_t simcall, size_t* arg)
454 {
455   simgrid::simix::marshal<size_t*>(simcall->args[3], arg);
456 }
457 static inline simix_match_func_t simcall_comm_recv__get__match_fun(smx_simcall_t simcall)
458 {
459   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[4]);
460 }
461 static inline simix_match_func_t simcall_comm_recv__getraw__match_fun(smx_simcall_t simcall)
462 {
463   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[4]);
464 }
465 static inline void simcall_comm_recv__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
466 {
467   simgrid::simix::marshal<simix_match_func_t>(simcall->args[4], arg);
468 }
469 static inline simix_copy_data_func_t simcall_comm_recv__get__copy_data_fun(smx_simcall_t simcall)
470 {
471   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[5]);
472 }
473 static inline simix_copy_data_func_t simcall_comm_recv__getraw__copy_data_fun(smx_simcall_t simcall)
474 {
475   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args[5]);
476 }
477 static inline void simcall_comm_recv__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
478 {
479   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[5], arg);
480 }
481 static inline void* simcall_comm_recv__get__data(smx_simcall_t simcall)
482 {
483   return simgrid::simix::unmarshal<void*>(simcall->args[6]);
484 }
485 static inline void* simcall_comm_recv__getraw__data(smx_simcall_t simcall)
486 {
487   return simgrid::simix::unmarshal_raw<void*>(simcall->args[6]);
488 }
489 static inline void simcall_comm_recv__set__data(smx_simcall_t simcall, void* arg)
490 {
491   simgrid::simix::marshal<void*>(simcall->args[6], arg);
492 }
493 static inline double simcall_comm_recv__get__timeout(smx_simcall_t simcall)
494 {
495   return simgrid::simix::unmarshal<double>(simcall->args[7]);
496 }
497 static inline double simcall_comm_recv__getraw__timeout(smx_simcall_t simcall)
498 {
499   return simgrid::simix::unmarshal_raw<double>(simcall->args[7]);
500 }
501 static inline void simcall_comm_recv__set__timeout(smx_simcall_t simcall, double arg)
502 {
503   simgrid::simix::marshal<double>(simcall->args[7], arg);
504 }
505 static inline double simcall_comm_recv__get__rate(smx_simcall_t simcall)
506 {
507   return simgrid::simix::unmarshal<double>(simcall->args[8]);
508 }
509 static inline double simcall_comm_recv__getraw__rate(smx_simcall_t simcall)
510 {
511   return simgrid::simix::unmarshal_raw<double>(simcall->args[8]);
512 }
513 static inline void simcall_comm_recv__set__rate(smx_simcall_t simcall, double arg)
514 {
515   simgrid::simix::marshal<double>(simcall->args[8], arg);
516 }
517
518 static inline smx_actor_t simcall_comm_irecv__get__receiver(smx_simcall_t simcall)
519 {
520   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
521 }
522 static inline smx_actor_t simcall_comm_irecv__getraw__receiver(smx_simcall_t simcall)
523 {
524   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
525 }
526 static inline void simcall_comm_irecv__set__receiver(smx_simcall_t simcall, smx_actor_t arg)
527 {
528   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
529 }
530 static inline smx_mailbox_t simcall_comm_irecv__get__mbox(smx_simcall_t simcall)
531 {
532   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[1]);
533 }
534 static inline smx_mailbox_t simcall_comm_irecv__getraw__mbox(smx_simcall_t simcall)
535 {
536   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[1]);
537 }
538 static inline void simcall_comm_irecv__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
539 {
540   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[1], arg);
541 }
542 static inline void* simcall_comm_irecv__get__dst_buff(smx_simcall_t simcall)
543 {
544   return simgrid::simix::unmarshal<void*>(simcall->args[2]);
545 }
546 static inline void* simcall_comm_irecv__getraw__dst_buff(smx_simcall_t simcall)
547 {
548   return simgrid::simix::unmarshal_raw<void*>(simcall->args[2]);
549 }
550 static inline void simcall_comm_irecv__set__dst_buff(smx_simcall_t simcall, void* arg)
551 {
552   simgrid::simix::marshal<void*>(simcall->args[2], arg);
553 }
554 static inline size_t* simcall_comm_irecv__get__dst_buff_size(smx_simcall_t simcall)
555 {
556   return simgrid::simix::unmarshal<size_t*>(simcall->args[3]);
557 }
558 static inline size_t* simcall_comm_irecv__getraw__dst_buff_size(smx_simcall_t simcall)
559 {
560   return simgrid::simix::unmarshal_raw<size_t*>(simcall->args[3]);
561 }
562 static inline void simcall_comm_irecv__set__dst_buff_size(smx_simcall_t simcall, size_t* arg)
563 {
564   simgrid::simix::marshal<size_t*>(simcall->args[3], arg);
565 }
566 static inline simix_match_func_t simcall_comm_irecv__get__match_fun(smx_simcall_t simcall)
567 {
568   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[4]);
569 }
570 static inline simix_match_func_t simcall_comm_irecv__getraw__match_fun(smx_simcall_t simcall)
571 {
572   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[4]);
573 }
574 static inline void simcall_comm_irecv__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
575 {
576   simgrid::simix::marshal<simix_match_func_t>(simcall->args[4], arg);
577 }
578 static inline simix_copy_data_func_t simcall_comm_irecv__get__copy_data_fun(smx_simcall_t simcall)
579 {
580   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[5]);
581 }
582 static inline simix_copy_data_func_t simcall_comm_irecv__getraw__copy_data_fun(smx_simcall_t simcall)
583 {
584   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args[5]);
585 }
586 static inline void simcall_comm_irecv__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
587 {
588   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[5], arg);
589 }
590 static inline void* simcall_comm_irecv__get__data(smx_simcall_t simcall)
591 {
592   return simgrid::simix::unmarshal<void*>(simcall->args[6]);
593 }
594 static inline void* simcall_comm_irecv__getraw__data(smx_simcall_t simcall)
595 {
596   return simgrid::simix::unmarshal_raw<void*>(simcall->args[6]);
597 }
598 static inline void simcall_comm_irecv__set__data(smx_simcall_t simcall, void* arg)
599 {
600   simgrid::simix::marshal<void*>(simcall->args[6], arg);
601 }
602 static inline double simcall_comm_irecv__get__rate(smx_simcall_t simcall)
603 {
604   return simgrid::simix::unmarshal<double>(simcall->args[7]);
605 }
606 static inline double simcall_comm_irecv__getraw__rate(smx_simcall_t simcall)
607 {
608   return simgrid::simix::unmarshal_raw<double>(simcall->args[7]);
609 }
610 static inline void simcall_comm_irecv__set__rate(smx_simcall_t simcall, double arg)
611 {
612   simgrid::simix::marshal<double>(simcall->args[7], arg);
613 }
614 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_comm_irecv__get__result(smx_simcall_t simcall)
615 {
616   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result);
617 }
618 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_irecv__getraw__result(smx_simcall_t simcall)
619 {
620   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->result);
621 }
622 static inline void simcall_comm_irecv__set__result(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> result)
623 {
624   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result, result);
625 }
626
627 static inline simgrid::kernel::activity::CommImpl** simcall_comm_waitany__get__comms(smx_simcall_t simcall)
628 {
629   return simgrid::simix::unmarshal<simgrid::kernel::activity::CommImpl**>(simcall->args[0]);
630 }
631 static inline simgrid::kernel::activity::CommImpl** simcall_comm_waitany__getraw__comms(smx_simcall_t simcall)
632 {
633   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::CommImpl**>(simcall->args[0]);
634 }
635 static inline void simcall_comm_waitany__set__comms(smx_simcall_t simcall, simgrid::kernel::activity::CommImpl** arg)
636 {
637   simgrid::simix::marshal<simgrid::kernel::activity::CommImpl**>(simcall->args[0], arg);
638 }
639 static inline size_t simcall_comm_waitany__get__count(smx_simcall_t simcall)
640 {
641   return simgrid::simix::unmarshal<size_t>(simcall->args[1]);
642 }
643 static inline size_t simcall_comm_waitany__getraw__count(smx_simcall_t simcall)
644 {
645   return simgrid::simix::unmarshal_raw<size_t>(simcall->args[1]);
646 }
647 static inline void simcall_comm_waitany__set__count(smx_simcall_t simcall, size_t arg)
648 {
649   simgrid::simix::marshal<size_t>(simcall->args[1], arg);
650 }
651 static inline double simcall_comm_waitany__get__timeout(smx_simcall_t simcall)
652 {
653   return simgrid::simix::unmarshal<double>(simcall->args[2]);
654 }
655 static inline double simcall_comm_waitany__getraw__timeout(smx_simcall_t simcall)
656 {
657   return simgrid::simix::unmarshal_raw<double>(simcall->args[2]);
658 }
659 static inline void simcall_comm_waitany__set__timeout(smx_simcall_t simcall, double arg)
660 {
661   simgrid::simix::marshal<double>(simcall->args[2], arg);
662 }
663 static inline int simcall_comm_waitany__get__result(smx_simcall_t simcall)
664 {
665   return simgrid::simix::unmarshal<int>(simcall->result);
666 }
667 static inline int simcall_comm_waitany__getraw__result(smx_simcall_t simcall)
668 {
669   return simgrid::simix::unmarshal_raw<int>(simcall->result);
670 }
671 static inline void simcall_comm_waitany__set__result(smx_simcall_t simcall, int result)
672 {
673   simgrid::simix::marshal<int>(simcall->result, result);
674 }
675
676 static inline simgrid::kernel::activity::CommImpl* simcall_comm_wait__get__comm(smx_simcall_t simcall)
677 {
678   return simgrid::simix::unmarshal<simgrid::kernel::activity::CommImpl*>(simcall->args[0]);
679 }
680 static inline simgrid::kernel::activity::CommImpl* simcall_comm_wait__getraw__comm(smx_simcall_t simcall)
681 {
682   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::CommImpl*>(simcall->args[0]);
683 }
684 static inline void simcall_comm_wait__set__comm(smx_simcall_t simcall, simgrid::kernel::activity::CommImpl* arg)
685 {
686   simgrid::simix::marshal<simgrid::kernel::activity::CommImpl*>(simcall->args[0], arg);
687 }
688 static inline double simcall_comm_wait__get__timeout(smx_simcall_t simcall)
689 {
690   return simgrid::simix::unmarshal<double>(simcall->args[1]);
691 }
692 static inline double simcall_comm_wait__getraw__timeout(smx_simcall_t simcall)
693 {
694   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
695 }
696 static inline void simcall_comm_wait__set__timeout(smx_simcall_t simcall, double arg)
697 {
698   simgrid::simix::marshal<double>(simcall->args[1], arg);
699 }
700
701 static inline simgrid::kernel::activity::CommImpl* simcall_comm_test__get__comm(smx_simcall_t simcall)
702 {
703   return simgrid::simix::unmarshal<simgrid::kernel::activity::CommImpl*>(simcall->args[0]);
704 }
705 static inline simgrid::kernel::activity::CommImpl* simcall_comm_test__getraw__comm(smx_simcall_t simcall)
706 {
707   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::CommImpl*>(simcall->args[0]);
708 }
709 static inline void simcall_comm_test__set__comm(smx_simcall_t simcall, simgrid::kernel::activity::CommImpl* arg)
710 {
711   simgrid::simix::marshal<simgrid::kernel::activity::CommImpl*>(simcall->args[0], arg);
712 }
713 static inline bool simcall_comm_test__get__result(smx_simcall_t simcall)
714 {
715   return simgrid::simix::unmarshal<bool>(simcall->result);
716 }
717 static inline bool simcall_comm_test__getraw__result(smx_simcall_t simcall)
718 {
719   return simgrid::simix::unmarshal_raw<bool>(simcall->result);
720 }
721 static inline void simcall_comm_test__set__result(smx_simcall_t simcall, bool result)
722 {
723   simgrid::simix::marshal<bool>(simcall->result, result);
724 }
725
726 static inline simgrid::kernel::activity::CommImpl** simcall_comm_testany__get__comms(smx_simcall_t simcall)
727 {
728   return simgrid::simix::unmarshal<simgrid::kernel::activity::CommImpl**>(simcall->args[0]);
729 }
730 static inline simgrid::kernel::activity::CommImpl** simcall_comm_testany__getraw__comms(smx_simcall_t simcall)
731 {
732   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::CommImpl**>(simcall->args[0]);
733 }
734 static inline void simcall_comm_testany__set__comms(smx_simcall_t simcall, simgrid::kernel::activity::CommImpl** arg)
735 {
736   simgrid::simix::marshal<simgrid::kernel::activity::CommImpl**>(simcall->args[0], arg);
737 }
738 static inline size_t simcall_comm_testany__get__count(smx_simcall_t simcall)
739 {
740   return simgrid::simix::unmarshal<size_t>(simcall->args[1]);
741 }
742 static inline size_t simcall_comm_testany__getraw__count(smx_simcall_t simcall)
743 {
744   return simgrid::simix::unmarshal_raw<size_t>(simcall->args[1]);
745 }
746 static inline void simcall_comm_testany__set__count(smx_simcall_t simcall, size_t arg)
747 {
748   simgrid::simix::marshal<size_t>(simcall->args[1], arg);
749 }
750 static inline int simcall_comm_testany__get__result(smx_simcall_t simcall)
751 {
752   return simgrid::simix::unmarshal<int>(simcall->result);
753 }
754 static inline int simcall_comm_testany__getraw__result(smx_simcall_t simcall)
755 {
756   return simgrid::simix::unmarshal_raw<int>(simcall->result);
757 }
758 static inline void simcall_comm_testany__set__result(smx_simcall_t simcall, int result)
759 {
760   simgrid::simix::marshal<int>(simcall->result, result);
761 }
762
763 static inline smx_mutex_t simcall_mutex_lock__get__mutex(smx_simcall_t simcall)
764 {
765   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[0]);
766 }
767 static inline smx_mutex_t simcall_mutex_lock__getraw__mutex(smx_simcall_t simcall)
768 {
769   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[0]);
770 }
771 static inline void simcall_mutex_lock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
772 {
773   simgrid::simix::marshal<smx_mutex_t>(simcall->args[0], arg);
774 }
775
776 static inline smx_mutex_t simcall_mutex_trylock__get__mutex(smx_simcall_t simcall)
777 {
778   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[0]);
779 }
780 static inline smx_mutex_t simcall_mutex_trylock__getraw__mutex(smx_simcall_t simcall)
781 {
782   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[0]);
783 }
784 static inline void simcall_mutex_trylock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
785 {
786   simgrid::simix::marshal<smx_mutex_t>(simcall->args[0], arg);
787 }
788 static inline int simcall_mutex_trylock__get__result(smx_simcall_t simcall)
789 {
790   return simgrid::simix::unmarshal<int>(simcall->result);
791 }
792 static inline int simcall_mutex_trylock__getraw__result(smx_simcall_t simcall)
793 {
794   return simgrid::simix::unmarshal_raw<int>(simcall->result);
795 }
796 static inline void simcall_mutex_trylock__set__result(smx_simcall_t simcall, int result)
797 {
798   simgrid::simix::marshal<int>(simcall->result, result);
799 }
800
801 static inline smx_mutex_t simcall_mutex_unlock__get__mutex(smx_simcall_t simcall)
802 {
803   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[0]);
804 }
805 static inline smx_mutex_t simcall_mutex_unlock__getraw__mutex(smx_simcall_t simcall)
806 {
807   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[0]);
808 }
809 static inline void simcall_mutex_unlock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
810 {
811   simgrid::simix::marshal<smx_mutex_t>(simcall->args[0], arg);
812 }
813
814 static inline smx_cond_t simcall_cond_wait__get__cond(smx_simcall_t simcall)
815 {
816   return simgrid::simix::unmarshal<smx_cond_t>(simcall->args[0]);
817 }
818 static inline smx_cond_t simcall_cond_wait__getraw__cond(smx_simcall_t simcall)
819 {
820   return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->args[0]);
821 }
822 static inline void simcall_cond_wait__set__cond(smx_simcall_t simcall, smx_cond_t arg)
823 {
824   simgrid::simix::marshal<smx_cond_t>(simcall->args[0], arg);
825 }
826 static inline smx_mutex_t simcall_cond_wait__get__mutex(smx_simcall_t simcall)
827 {
828   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[1]);
829 }
830 static inline smx_mutex_t simcall_cond_wait__getraw__mutex(smx_simcall_t simcall)
831 {
832   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[1]);
833 }
834 static inline void simcall_cond_wait__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
835 {
836   simgrid::simix::marshal<smx_mutex_t>(simcall->args[1], arg);
837 }
838
839 static inline smx_cond_t simcall_cond_wait_timeout__get__cond(smx_simcall_t simcall)
840 {
841   return simgrid::simix::unmarshal<smx_cond_t>(simcall->args[0]);
842 }
843 static inline smx_cond_t simcall_cond_wait_timeout__getraw__cond(smx_simcall_t simcall)
844 {
845   return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->args[0]);
846 }
847 static inline void simcall_cond_wait_timeout__set__cond(smx_simcall_t simcall, smx_cond_t arg)
848 {
849   simgrid::simix::marshal<smx_cond_t>(simcall->args[0], arg);
850 }
851 static inline smx_mutex_t simcall_cond_wait_timeout__get__mutex(smx_simcall_t simcall)
852 {
853   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[1]);
854 }
855 static inline smx_mutex_t simcall_cond_wait_timeout__getraw__mutex(smx_simcall_t simcall)
856 {
857   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[1]);
858 }
859 static inline void simcall_cond_wait_timeout__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
860 {
861   simgrid::simix::marshal<smx_mutex_t>(simcall->args[1], arg);
862 }
863 static inline double simcall_cond_wait_timeout__get__timeout(smx_simcall_t simcall)
864 {
865   return simgrid::simix::unmarshal<double>(simcall->args[2]);
866 }
867 static inline double simcall_cond_wait_timeout__getraw__timeout(smx_simcall_t simcall)
868 {
869   return simgrid::simix::unmarshal_raw<double>(simcall->args[2]);
870 }
871 static inline void simcall_cond_wait_timeout__set__timeout(smx_simcall_t simcall, double arg)
872 {
873   simgrid::simix::marshal<double>(simcall->args[2], arg);
874 }
875 static inline int simcall_cond_wait_timeout__get__result(smx_simcall_t simcall)
876 {
877   return simgrid::simix::unmarshal<int>(simcall->result);
878 }
879 static inline int simcall_cond_wait_timeout__getraw__result(smx_simcall_t simcall)
880 {
881   return simgrid::simix::unmarshal_raw<int>(simcall->result);
882 }
883 static inline void simcall_cond_wait_timeout__set__result(smx_simcall_t simcall, int result)
884 {
885   simgrid::simix::marshal<int>(simcall->result, result);
886 }
887
888 static inline smx_sem_t simcall_sem_acquire__get__sem(smx_simcall_t simcall)
889 {
890   return simgrid::simix::unmarshal<smx_sem_t>(simcall->args[0]);
891 }
892 static inline smx_sem_t simcall_sem_acquire__getraw__sem(smx_simcall_t simcall)
893 {
894   return simgrid::simix::unmarshal_raw<smx_sem_t>(simcall->args[0]);
895 }
896 static inline void simcall_sem_acquire__set__sem(smx_simcall_t simcall, smx_sem_t arg)
897 {
898   simgrid::simix::marshal<smx_sem_t>(simcall->args[0], arg);
899 }
900
901 static inline smx_sem_t simcall_sem_acquire_timeout__get__sem(smx_simcall_t simcall)
902 {
903   return simgrid::simix::unmarshal<smx_sem_t>(simcall->args[0]);
904 }
905 static inline smx_sem_t simcall_sem_acquire_timeout__getraw__sem(smx_simcall_t simcall)
906 {
907   return simgrid::simix::unmarshal_raw<smx_sem_t>(simcall->args[0]);
908 }
909 static inline void simcall_sem_acquire_timeout__set__sem(smx_simcall_t simcall, smx_sem_t arg)
910 {
911   simgrid::simix::marshal<smx_sem_t>(simcall->args[0], arg);
912 }
913 static inline double simcall_sem_acquire_timeout__get__timeout(smx_simcall_t simcall)
914 {
915   return simgrid::simix::unmarshal<double>(simcall->args[1]);
916 }
917 static inline double simcall_sem_acquire_timeout__getraw__timeout(smx_simcall_t simcall)
918 {
919   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
920 }
921 static inline void simcall_sem_acquire_timeout__set__timeout(smx_simcall_t simcall, double arg)
922 {
923   simgrid::simix::marshal<double>(simcall->args[1], arg);
924 }
925 static inline int simcall_sem_acquire_timeout__get__result(smx_simcall_t simcall)
926 {
927   return simgrid::simix::unmarshal<int>(simcall->result);
928 }
929 static inline int simcall_sem_acquire_timeout__getraw__result(smx_simcall_t simcall)
930 {
931   return simgrid::simix::unmarshal_raw<int>(simcall->result);
932 }
933 static inline void simcall_sem_acquire_timeout__set__result(smx_simcall_t simcall, int result)
934 {
935   simgrid::simix::marshal<int>(simcall->result, result);
936 }
937
938 static inline simgrid::kernel::activity::IoImpl* simcall_io_wait__get__io(smx_simcall_t simcall)
939 {
940   return simgrid::simix::unmarshal<simgrid::kernel::activity::IoImpl*>(simcall->args[0]);
941 }
942 static inline simgrid::kernel::activity::IoImpl* simcall_io_wait__getraw__io(smx_simcall_t simcall)
943 {
944   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::IoImpl*>(simcall->args[0]);
945 }
946 static inline void simcall_io_wait__set__io(smx_simcall_t simcall, simgrid::kernel::activity::IoImpl* arg)
947 {
948   simgrid::simix::marshal<simgrid::kernel::activity::IoImpl*>(simcall->args[0], arg);
949 }
950 static inline sg_size_t simcall_io_wait__get__result(smx_simcall_t simcall)
951 {
952   return simgrid::simix::unmarshal<sg_size_t>(simcall->result);
953 }
954 static inline sg_size_t simcall_io_wait__getraw__result(smx_simcall_t simcall)
955 {
956   return simgrid::simix::unmarshal_raw<sg_size_t>(simcall->result);
957 }
958 static inline void simcall_io_wait__set__result(smx_simcall_t simcall, sg_size_t result)
959 {
960   simgrid::simix::marshal<sg_size_t>(simcall->result, result);
961 }
962
963 static inline int simcall_mc_random__get__min(smx_simcall_t simcall)
964 {
965   return simgrid::simix::unmarshal<int>(simcall->args[0]);
966 }
967 static inline int simcall_mc_random__getraw__min(smx_simcall_t simcall)
968 {
969   return simgrid::simix::unmarshal_raw<int>(simcall->args[0]);
970 }
971 static inline void simcall_mc_random__set__min(smx_simcall_t simcall, int arg)
972 {
973   simgrid::simix::marshal<int>(simcall->args[0], arg);
974 }
975 static inline int simcall_mc_random__get__max(smx_simcall_t simcall)
976 {
977   return simgrid::simix::unmarshal<int>(simcall->args[1]);
978 }
979 static inline int simcall_mc_random__getraw__max(smx_simcall_t simcall)
980 {
981   return simgrid::simix::unmarshal_raw<int>(simcall->args[1]);
982 }
983 static inline void simcall_mc_random__set__max(smx_simcall_t simcall, int arg)
984 {
985   simgrid::simix::marshal<int>(simcall->args[1], arg);
986 }
987 static inline int simcall_mc_random__get__result(smx_simcall_t simcall)
988 {
989   return simgrid::simix::unmarshal<int>(simcall->result);
990 }
991 static inline int simcall_mc_random__getraw__result(smx_simcall_t simcall)
992 {
993   return simgrid::simix::unmarshal_raw<int>(simcall->result);
994 }
995 static inline void simcall_mc_random__set__result(smx_simcall_t simcall, int result)
996 {
997   simgrid::simix::marshal<int>(simcall->result, result);
998 }
999
1000 static inline std::function<void()> const* simcall_run_kernel__get__code(smx_simcall_t simcall)
1001 {
1002   return simgrid::simix::unmarshal<std::function<void()> const*>(simcall->args[0]);
1003 }
1004 static inline std::function<void()> const* simcall_run_kernel__getraw__code(smx_simcall_t simcall)
1005 {
1006   return simgrid::simix::unmarshal_raw<std::function<void()> const*>(simcall->args[0]);
1007 }
1008 static inline void simcall_run_kernel__set__code(smx_simcall_t simcall, std::function<void()> const* arg)
1009 {
1010   simgrid::simix::marshal<std::function<void()> const*>(simcall->args[0], arg);
1011 }
1012
1013 static inline std::function<void()> const* simcall_run_blocking__get__code(smx_simcall_t simcall)
1014 {
1015   return simgrid::simix::unmarshal<std::function<void()> const*>(simcall->args[0]);
1016 }
1017 static inline std::function<void()> const* simcall_run_blocking__getraw__code(smx_simcall_t simcall)
1018 {
1019   return simgrid::simix::unmarshal_raw<std::function<void()> const*>(simcall->args[0]);
1020 }
1021 static inline void simcall_run_blocking__set__code(smx_simcall_t simcall, std::function<void()> const* arg)
1022 {
1023   simgrid::simix::marshal<std::function<void()> const*>(simcall->args[0], arg);
1024 }
1025
1026 /* The prototype of all simcall handlers, automatically generated for you */
1027
1028 XBT_PRIVATE void simcall_HANDLER_process_suspend(smx_simcall_t simcall, smx_actor_t process);
1029 XBT_PRIVATE void simcall_HANDLER_process_join(smx_simcall_t simcall, smx_actor_t process, double timeout);
1030 XBT_PRIVATE void simcall_HANDLER_process_sleep(smx_simcall_t simcall, double duration);
1031 XBT_PRIVATE void simcall_HANDLER_execution_wait(smx_simcall_t simcall, simgrid::kernel::activity::ExecImpl* execution);
1032 XBT_PRIVATE void simcall_HANDLER_execution_test(smx_simcall_t simcall, simgrid::kernel::activity::ExecImpl* execution);
1033 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);
1034 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, bool detached);
1035 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);
1036 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);
1037 XBT_PRIVATE void simcall_HANDLER_comm_waitany(smx_simcall_t simcall, simgrid::kernel::activity::CommImpl** comms, size_t count, double timeout);
1038 XBT_PRIVATE void simcall_HANDLER_comm_wait(smx_simcall_t simcall, simgrid::kernel::activity::CommImpl* comm, double timeout);
1039 XBT_PRIVATE void simcall_HANDLER_comm_test(smx_simcall_t simcall, simgrid::kernel::activity::CommImpl* comm);
1040 XBT_PRIVATE void simcall_HANDLER_comm_testany(smx_simcall_t simcall, simgrid::kernel::activity::CommImpl** comms, size_t count);
1041 XBT_PRIVATE void simcall_HANDLER_mutex_lock(smx_simcall_t simcall, smx_mutex_t mutex);
1042 XBT_PRIVATE int simcall_HANDLER_mutex_trylock(smx_simcall_t simcall, smx_mutex_t mutex);
1043 XBT_PRIVATE void simcall_HANDLER_mutex_unlock(smx_simcall_t simcall, smx_mutex_t mutex);
1044 XBT_PRIVATE void simcall_HANDLER_cond_wait(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex);
1045 XBT_PRIVATE void simcall_HANDLER_cond_wait_timeout(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex, double timeout);
1046 XBT_PRIVATE void simcall_HANDLER_sem_acquire(smx_simcall_t simcall, smx_sem_t sem);
1047 XBT_PRIVATE void simcall_HANDLER_sem_acquire_timeout(smx_simcall_t simcall, smx_sem_t sem, double timeout);
1048 XBT_PRIVATE void simcall_HANDLER_io_wait(smx_simcall_t simcall, simgrid::kernel::activity::IoImpl* io);
1049 XBT_PRIVATE int simcall_HANDLER_mc_random(smx_simcall_t simcall, int min, int max);