Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
5d8c7d1ae1250e1526ef2606225dceaa13480400
[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_actor_t simcall_process_on_exit__get__process(smx_simcall_t simcall)
317 {
318   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
319 }
320 static inline smx_actor_t simcall_process_on_exit__getraw__process(smx_simcall_t simcall)
321 {
322   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
323 }
324 static inline void simcall_process_on_exit__set__process(smx_simcall_t simcall, smx_actor_t arg)
325 {
326   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
327 }
328 static inline int_f_pvoid_pvoid_t simcall_process_on_exit__get__fun(smx_simcall_t simcall)
329 {
330   return simgrid::simix::unmarshal<int_f_pvoid_pvoid_t>(simcall->args[1]);
331 }
332 static inline int_f_pvoid_pvoid_t simcall_process_on_exit__getraw__fun(smx_simcall_t simcall)
333 {
334   return simgrid::simix::unmarshal_raw<int_f_pvoid_pvoid_t>(simcall->args[1]);
335 }
336 static inline void simcall_process_on_exit__set__fun(smx_simcall_t simcall, int_f_pvoid_pvoid_t arg)
337 {
338   simgrid::simix::marshal<int_f_pvoid_pvoid_t>(simcall->args[1], arg);
339 }
340 static inline void* simcall_process_on_exit__get__data(smx_simcall_t simcall)
341 {
342   return simgrid::simix::unmarshal<void*>(simcall->args[2]);
343 }
344 static inline void* simcall_process_on_exit__getraw__data(smx_simcall_t simcall)
345 {
346   return simgrid::simix::unmarshal_raw<void*>(simcall->args[2]);
347 }
348 static inline void simcall_process_on_exit__set__data(smx_simcall_t simcall, void* arg)
349 {
350   simgrid::simix::marshal<void*>(simcall->args[2], arg);
351 }
352
353 static inline smx_mailbox_t simcall_comm_iprobe__get__mbox(smx_simcall_t simcall)
354 {
355   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[0]);
356 }
357 static inline smx_mailbox_t simcall_comm_iprobe__getraw__mbox(smx_simcall_t simcall)
358 {
359   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[0]);
360 }
361 static inline void simcall_comm_iprobe__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
362 {
363   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[0], arg);
364 }
365 static inline int simcall_comm_iprobe__get__type(smx_simcall_t simcall)
366 {
367   return simgrid::simix::unmarshal<int>(simcall->args[1]);
368 }
369 static inline int simcall_comm_iprobe__getraw__type(smx_simcall_t simcall)
370 {
371   return simgrid::simix::unmarshal_raw<int>(simcall->args[1]);
372 }
373 static inline void simcall_comm_iprobe__set__type(smx_simcall_t simcall, int arg)
374 {
375   simgrid::simix::marshal<int>(simcall->args[1], arg);
376 }
377 static inline simix_match_func_t simcall_comm_iprobe__get__match_fun(smx_simcall_t simcall)
378 {
379   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[2]);
380 }
381 static inline simix_match_func_t simcall_comm_iprobe__getraw__match_fun(smx_simcall_t simcall)
382 {
383   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[2]);
384 }
385 static inline void simcall_comm_iprobe__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
386 {
387   simgrid::simix::marshal<simix_match_func_t>(simcall->args[2], arg);
388 }
389 static inline void* simcall_comm_iprobe__get__data(smx_simcall_t simcall)
390 {
391   return simgrid::simix::unmarshal<void*>(simcall->args[3]);
392 }
393 static inline void* simcall_comm_iprobe__getraw__data(smx_simcall_t simcall)
394 {
395   return simgrid::simix::unmarshal_raw<void*>(simcall->args[3]);
396 }
397 static inline void simcall_comm_iprobe__set__data(smx_simcall_t simcall, void* arg)
398 {
399   simgrid::simix::marshal<void*>(simcall->args[3], arg);
400 }
401 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_comm_iprobe__get__result(smx_simcall_t simcall)
402 {
403   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result);
404 }
405 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_iprobe__getraw__result(smx_simcall_t simcall)
406 {
407   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->result);
408 }
409 static inline void simcall_comm_iprobe__set__result(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> result)
410 {
411   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result, result);
412 }
413
414 static inline smx_actor_t simcall_comm_send__get__sender(smx_simcall_t simcall)
415 {
416   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
417 }
418 static inline smx_actor_t simcall_comm_send__getraw__sender(smx_simcall_t simcall)
419 {
420   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
421 }
422 static inline void simcall_comm_send__set__sender(smx_simcall_t simcall, smx_actor_t arg)
423 {
424   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
425 }
426 static inline smx_mailbox_t simcall_comm_send__get__mbox(smx_simcall_t simcall)
427 {
428   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[1]);
429 }
430 static inline smx_mailbox_t simcall_comm_send__getraw__mbox(smx_simcall_t simcall)
431 {
432   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[1]);
433 }
434 static inline void simcall_comm_send__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
435 {
436   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[1], arg);
437 }
438 static inline double simcall_comm_send__get__task_size(smx_simcall_t simcall)
439 {
440   return simgrid::simix::unmarshal<double>(simcall->args[2]);
441 }
442 static inline double simcall_comm_send__getraw__task_size(smx_simcall_t simcall)
443 {
444   return simgrid::simix::unmarshal_raw<double>(simcall->args[2]);
445 }
446 static inline void simcall_comm_send__set__task_size(smx_simcall_t simcall, double arg)
447 {
448   simgrid::simix::marshal<double>(simcall->args[2], arg);
449 }
450 static inline double simcall_comm_send__get__rate(smx_simcall_t simcall)
451 {
452   return simgrid::simix::unmarshal<double>(simcall->args[3]);
453 }
454 static inline double simcall_comm_send__getraw__rate(smx_simcall_t simcall)
455 {
456   return simgrid::simix::unmarshal_raw<double>(simcall->args[3]);
457 }
458 static inline void simcall_comm_send__set__rate(smx_simcall_t simcall, double arg)
459 {
460   simgrid::simix::marshal<double>(simcall->args[3], arg);
461 }
462 static inline void* simcall_comm_send__get__src_buff(smx_simcall_t simcall)
463 {
464   return simgrid::simix::unmarshal<void*>(simcall->args[4]);
465 }
466 static inline void* simcall_comm_send__getraw__src_buff(smx_simcall_t simcall)
467 {
468   return simgrid::simix::unmarshal_raw<void*>(simcall->args[4]);
469 }
470 static inline void simcall_comm_send__set__src_buff(smx_simcall_t simcall, void* arg)
471 {
472   simgrid::simix::marshal<void*>(simcall->args[4], arg);
473 }
474 static inline size_t simcall_comm_send__get__src_buff_size(smx_simcall_t simcall)
475 {
476   return simgrid::simix::unmarshal<size_t>(simcall->args[5]);
477 }
478 static inline size_t simcall_comm_send__getraw__src_buff_size(smx_simcall_t simcall)
479 {
480   return simgrid::simix::unmarshal_raw<size_t>(simcall->args[5]);
481 }
482 static inline void simcall_comm_send__set__src_buff_size(smx_simcall_t simcall, size_t arg)
483 {
484   simgrid::simix::marshal<size_t>(simcall->args[5], arg);
485 }
486 static inline simix_match_func_t simcall_comm_send__get__match_fun(smx_simcall_t simcall)
487 {
488   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[6]);
489 }
490 static inline simix_match_func_t simcall_comm_send__getraw__match_fun(smx_simcall_t simcall)
491 {
492   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[6]);
493 }
494 static inline void simcall_comm_send__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
495 {
496   simgrid::simix::marshal<simix_match_func_t>(simcall->args[6], arg);
497 }
498 static inline simix_copy_data_func_t simcall_comm_send__get__copy_data_fun(smx_simcall_t simcall)
499 {
500   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[7]);
501 }
502 static inline simix_copy_data_func_t simcall_comm_send__getraw__copy_data_fun(smx_simcall_t simcall)
503 {
504   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args[7]);
505 }
506 static inline void simcall_comm_send__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
507 {
508   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[7], arg);
509 }
510 static inline void* simcall_comm_send__get__data(smx_simcall_t simcall)
511 {
512   return simgrid::simix::unmarshal<void*>(simcall->args[8]);
513 }
514 static inline void* simcall_comm_send__getraw__data(smx_simcall_t simcall)
515 {
516   return simgrid::simix::unmarshal_raw<void*>(simcall->args[8]);
517 }
518 static inline void simcall_comm_send__set__data(smx_simcall_t simcall, void* arg)
519 {
520   simgrid::simix::marshal<void*>(simcall->args[8], arg);
521 }
522 static inline double simcall_comm_send__get__timeout(smx_simcall_t simcall)
523 {
524   return simgrid::simix::unmarshal<double>(simcall->args[9]);
525 }
526 static inline double simcall_comm_send__getraw__timeout(smx_simcall_t simcall)
527 {
528   return simgrid::simix::unmarshal_raw<double>(simcall->args[9]);
529 }
530 static inline void simcall_comm_send__set__timeout(smx_simcall_t simcall, double arg)
531 {
532   simgrid::simix::marshal<double>(simcall->args[9], arg);
533 }
534
535 static inline smx_actor_t simcall_comm_isend__get__sender(smx_simcall_t simcall)
536 {
537   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
538 }
539 static inline smx_actor_t simcall_comm_isend__getraw__sender(smx_simcall_t simcall)
540 {
541   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
542 }
543 static inline void simcall_comm_isend__set__sender(smx_simcall_t simcall, smx_actor_t arg)
544 {
545   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
546 }
547 static inline smx_mailbox_t simcall_comm_isend__get__mbox(smx_simcall_t simcall)
548 {
549   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[1]);
550 }
551 static inline smx_mailbox_t simcall_comm_isend__getraw__mbox(smx_simcall_t simcall)
552 {
553   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[1]);
554 }
555 static inline void simcall_comm_isend__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
556 {
557   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[1], arg);
558 }
559 static inline double simcall_comm_isend__get__task_size(smx_simcall_t simcall)
560 {
561   return simgrid::simix::unmarshal<double>(simcall->args[2]);
562 }
563 static inline double simcall_comm_isend__getraw__task_size(smx_simcall_t simcall)
564 {
565   return simgrid::simix::unmarshal_raw<double>(simcall->args[2]);
566 }
567 static inline void simcall_comm_isend__set__task_size(smx_simcall_t simcall, double arg)
568 {
569   simgrid::simix::marshal<double>(simcall->args[2], arg);
570 }
571 static inline double simcall_comm_isend__get__rate(smx_simcall_t simcall)
572 {
573   return simgrid::simix::unmarshal<double>(simcall->args[3]);
574 }
575 static inline double simcall_comm_isend__getraw__rate(smx_simcall_t simcall)
576 {
577   return simgrid::simix::unmarshal_raw<double>(simcall->args[3]);
578 }
579 static inline void simcall_comm_isend__set__rate(smx_simcall_t simcall, double arg)
580 {
581   simgrid::simix::marshal<double>(simcall->args[3], arg);
582 }
583 static inline void* simcall_comm_isend__get__src_buff(smx_simcall_t simcall)
584 {
585   return simgrid::simix::unmarshal<void*>(simcall->args[4]);
586 }
587 static inline void* simcall_comm_isend__getraw__src_buff(smx_simcall_t simcall)
588 {
589   return simgrid::simix::unmarshal_raw<void*>(simcall->args[4]);
590 }
591 static inline void simcall_comm_isend__set__src_buff(smx_simcall_t simcall, void* arg)
592 {
593   simgrid::simix::marshal<void*>(simcall->args[4], arg);
594 }
595 static inline size_t simcall_comm_isend__get__src_buff_size(smx_simcall_t simcall)
596 {
597   return simgrid::simix::unmarshal<size_t>(simcall->args[5]);
598 }
599 static inline size_t simcall_comm_isend__getraw__src_buff_size(smx_simcall_t simcall)
600 {
601   return simgrid::simix::unmarshal_raw<size_t>(simcall->args[5]);
602 }
603 static inline void simcall_comm_isend__set__src_buff_size(smx_simcall_t simcall, size_t arg)
604 {
605   simgrid::simix::marshal<size_t>(simcall->args[5], arg);
606 }
607 static inline simix_match_func_t simcall_comm_isend__get__match_fun(smx_simcall_t simcall)
608 {
609   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[6]);
610 }
611 static inline simix_match_func_t simcall_comm_isend__getraw__match_fun(smx_simcall_t simcall)
612 {
613   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[6]);
614 }
615 static inline void simcall_comm_isend__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
616 {
617   simgrid::simix::marshal<simix_match_func_t>(simcall->args[6], arg);
618 }
619 static inline simix_clean_func_t simcall_comm_isend__get__clean_fun(smx_simcall_t simcall)
620 {
621   return simgrid::simix::unmarshal<simix_clean_func_t>(simcall->args[7]);
622 }
623 static inline simix_clean_func_t simcall_comm_isend__getraw__clean_fun(smx_simcall_t simcall)
624 {
625   return simgrid::simix::unmarshal_raw<simix_clean_func_t>(simcall->args[7]);
626 }
627 static inline void simcall_comm_isend__set__clean_fun(smx_simcall_t simcall, simix_clean_func_t arg)
628 {
629   simgrid::simix::marshal<simix_clean_func_t>(simcall->args[7], arg);
630 }
631 static inline simix_copy_data_func_t simcall_comm_isend__get__copy_data_fun(smx_simcall_t simcall)
632 {
633   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[8]);
634 }
635 static inline simix_copy_data_func_t simcall_comm_isend__getraw__copy_data_fun(smx_simcall_t simcall)
636 {
637   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args[8]);
638 }
639 static inline void simcall_comm_isend__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
640 {
641   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[8], arg);
642 }
643 static inline void* simcall_comm_isend__get__data(smx_simcall_t simcall)
644 {
645   return simgrid::simix::unmarshal<void*>(simcall->args[9]);
646 }
647 static inline void* simcall_comm_isend__getraw__data(smx_simcall_t simcall)
648 {
649   return simgrid::simix::unmarshal_raw<void*>(simcall->args[9]);
650 }
651 static inline void simcall_comm_isend__set__data(smx_simcall_t simcall, void* arg)
652 {
653   simgrid::simix::marshal<void*>(simcall->args[9], arg);
654 }
655 static inline int simcall_comm_isend__get__detached(smx_simcall_t simcall)
656 {
657   return simgrid::simix::unmarshal<int>(simcall->args[10]);
658 }
659 static inline int simcall_comm_isend__getraw__detached(smx_simcall_t simcall)
660 {
661   return simgrid::simix::unmarshal_raw<int>(simcall->args[10]);
662 }
663 static inline void simcall_comm_isend__set__detached(smx_simcall_t simcall, int arg)
664 {
665   simgrid::simix::marshal<int>(simcall->args[10], arg);
666 }
667 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_comm_isend__get__result(smx_simcall_t simcall)
668 {
669   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result);
670 }
671 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_isend__getraw__result(smx_simcall_t simcall)
672 {
673   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->result);
674 }
675 static inline void simcall_comm_isend__set__result(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> result)
676 {
677   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result, result);
678 }
679
680 static inline smx_actor_t simcall_comm_recv__get__receiver(smx_simcall_t simcall)
681 {
682   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
683 }
684 static inline smx_actor_t simcall_comm_recv__getraw__receiver(smx_simcall_t simcall)
685 {
686   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
687 }
688 static inline void simcall_comm_recv__set__receiver(smx_simcall_t simcall, smx_actor_t arg)
689 {
690   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
691 }
692 static inline smx_mailbox_t simcall_comm_recv__get__mbox(smx_simcall_t simcall)
693 {
694   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[1]);
695 }
696 static inline smx_mailbox_t simcall_comm_recv__getraw__mbox(smx_simcall_t simcall)
697 {
698   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[1]);
699 }
700 static inline void simcall_comm_recv__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
701 {
702   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[1], arg);
703 }
704 static inline void* simcall_comm_recv__get__dst_buff(smx_simcall_t simcall)
705 {
706   return simgrid::simix::unmarshal<void*>(simcall->args[2]);
707 }
708 static inline void* simcall_comm_recv__getraw__dst_buff(smx_simcall_t simcall)
709 {
710   return simgrid::simix::unmarshal_raw<void*>(simcall->args[2]);
711 }
712 static inline void simcall_comm_recv__set__dst_buff(smx_simcall_t simcall, void* arg)
713 {
714   simgrid::simix::marshal<void*>(simcall->args[2], arg);
715 }
716 static inline size_t* simcall_comm_recv__get__dst_buff_size(smx_simcall_t simcall)
717 {
718   return simgrid::simix::unmarshal<size_t*>(simcall->args[3]);
719 }
720 static inline size_t* simcall_comm_recv__getraw__dst_buff_size(smx_simcall_t simcall)
721 {
722   return simgrid::simix::unmarshal_raw<size_t*>(simcall->args[3]);
723 }
724 static inline void simcall_comm_recv__set__dst_buff_size(smx_simcall_t simcall, size_t* arg)
725 {
726   simgrid::simix::marshal<size_t*>(simcall->args[3], arg);
727 }
728 static inline simix_match_func_t simcall_comm_recv__get__match_fun(smx_simcall_t simcall)
729 {
730   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[4]);
731 }
732 static inline simix_match_func_t simcall_comm_recv__getraw__match_fun(smx_simcall_t simcall)
733 {
734   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[4]);
735 }
736 static inline void simcall_comm_recv__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
737 {
738   simgrid::simix::marshal<simix_match_func_t>(simcall->args[4], arg);
739 }
740 static inline simix_copy_data_func_t simcall_comm_recv__get__copy_data_fun(smx_simcall_t simcall)
741 {
742   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[5]);
743 }
744 static inline simix_copy_data_func_t simcall_comm_recv__getraw__copy_data_fun(smx_simcall_t simcall)
745 {
746   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args[5]);
747 }
748 static inline void simcall_comm_recv__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
749 {
750   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[5], arg);
751 }
752 static inline void* simcall_comm_recv__get__data(smx_simcall_t simcall)
753 {
754   return simgrid::simix::unmarshal<void*>(simcall->args[6]);
755 }
756 static inline void* simcall_comm_recv__getraw__data(smx_simcall_t simcall)
757 {
758   return simgrid::simix::unmarshal_raw<void*>(simcall->args[6]);
759 }
760 static inline void simcall_comm_recv__set__data(smx_simcall_t simcall, void* arg)
761 {
762   simgrid::simix::marshal<void*>(simcall->args[6], arg);
763 }
764 static inline double simcall_comm_recv__get__timeout(smx_simcall_t simcall)
765 {
766   return simgrid::simix::unmarshal<double>(simcall->args[7]);
767 }
768 static inline double simcall_comm_recv__getraw__timeout(smx_simcall_t simcall)
769 {
770   return simgrid::simix::unmarshal_raw<double>(simcall->args[7]);
771 }
772 static inline void simcall_comm_recv__set__timeout(smx_simcall_t simcall, double arg)
773 {
774   simgrid::simix::marshal<double>(simcall->args[7], arg);
775 }
776 static inline double simcall_comm_recv__get__rate(smx_simcall_t simcall)
777 {
778   return simgrid::simix::unmarshal<double>(simcall->args[8]);
779 }
780 static inline double simcall_comm_recv__getraw__rate(smx_simcall_t simcall)
781 {
782   return simgrid::simix::unmarshal_raw<double>(simcall->args[8]);
783 }
784 static inline void simcall_comm_recv__set__rate(smx_simcall_t simcall, double arg)
785 {
786   simgrid::simix::marshal<double>(simcall->args[8], arg);
787 }
788
789 static inline smx_actor_t simcall_comm_irecv__get__receiver(smx_simcall_t simcall)
790 {
791   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
792 }
793 static inline smx_actor_t simcall_comm_irecv__getraw__receiver(smx_simcall_t simcall)
794 {
795   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
796 }
797 static inline void simcall_comm_irecv__set__receiver(smx_simcall_t simcall, smx_actor_t arg)
798 {
799   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
800 }
801 static inline smx_mailbox_t simcall_comm_irecv__get__mbox(smx_simcall_t simcall)
802 {
803   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[1]);
804 }
805 static inline smx_mailbox_t simcall_comm_irecv__getraw__mbox(smx_simcall_t simcall)
806 {
807   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[1]);
808 }
809 static inline void simcall_comm_irecv__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
810 {
811   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[1], arg);
812 }
813 static inline void* simcall_comm_irecv__get__dst_buff(smx_simcall_t simcall)
814 {
815   return simgrid::simix::unmarshal<void*>(simcall->args[2]);
816 }
817 static inline void* simcall_comm_irecv__getraw__dst_buff(smx_simcall_t simcall)
818 {
819   return simgrid::simix::unmarshal_raw<void*>(simcall->args[2]);
820 }
821 static inline void simcall_comm_irecv__set__dst_buff(smx_simcall_t simcall, void* arg)
822 {
823   simgrid::simix::marshal<void*>(simcall->args[2], arg);
824 }
825 static inline size_t* simcall_comm_irecv__get__dst_buff_size(smx_simcall_t simcall)
826 {
827   return simgrid::simix::unmarshal<size_t*>(simcall->args[3]);
828 }
829 static inline size_t* simcall_comm_irecv__getraw__dst_buff_size(smx_simcall_t simcall)
830 {
831   return simgrid::simix::unmarshal_raw<size_t*>(simcall->args[3]);
832 }
833 static inline void simcall_comm_irecv__set__dst_buff_size(smx_simcall_t simcall, size_t* arg)
834 {
835   simgrid::simix::marshal<size_t*>(simcall->args[3], arg);
836 }
837 static inline simix_match_func_t simcall_comm_irecv__get__match_fun(smx_simcall_t simcall)
838 {
839   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[4]);
840 }
841 static inline simix_match_func_t simcall_comm_irecv__getraw__match_fun(smx_simcall_t simcall)
842 {
843   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[4]);
844 }
845 static inline void simcall_comm_irecv__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
846 {
847   simgrid::simix::marshal<simix_match_func_t>(simcall->args[4], arg);
848 }
849 static inline simix_copy_data_func_t simcall_comm_irecv__get__copy_data_fun(smx_simcall_t simcall)
850 {
851   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[5]);
852 }
853 static inline simix_copy_data_func_t simcall_comm_irecv__getraw__copy_data_fun(smx_simcall_t simcall)
854 {
855   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args[5]);
856 }
857 static inline void simcall_comm_irecv__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
858 {
859   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[5], arg);
860 }
861 static inline void* simcall_comm_irecv__get__data(smx_simcall_t simcall)
862 {
863   return simgrid::simix::unmarshal<void*>(simcall->args[6]);
864 }
865 static inline void* simcall_comm_irecv__getraw__data(smx_simcall_t simcall)
866 {
867   return simgrid::simix::unmarshal_raw<void*>(simcall->args[6]);
868 }
869 static inline void simcall_comm_irecv__set__data(smx_simcall_t simcall, void* arg)
870 {
871   simgrid::simix::marshal<void*>(simcall->args[6], arg);
872 }
873 static inline double simcall_comm_irecv__get__rate(smx_simcall_t simcall)
874 {
875   return simgrid::simix::unmarshal<double>(simcall->args[7]);
876 }
877 static inline double simcall_comm_irecv__getraw__rate(smx_simcall_t simcall)
878 {
879   return simgrid::simix::unmarshal_raw<double>(simcall->args[7]);
880 }
881 static inline void simcall_comm_irecv__set__rate(smx_simcall_t simcall, double arg)
882 {
883   simgrid::simix::marshal<double>(simcall->args[7], arg);
884 }
885 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_comm_irecv__get__result(smx_simcall_t simcall)
886 {
887   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result);
888 }
889 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_irecv__getraw__result(smx_simcall_t simcall)
890 {
891   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->result);
892 }
893 static inline void simcall_comm_irecv__set__result(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> result)
894 {
895   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result, result);
896 }
897
898 static inline xbt_dynar_t simcall_comm_waitany__get__comms(smx_simcall_t simcall)
899 {
900   return simgrid::simix::unmarshal<xbt_dynar_t>(simcall->args[0]);
901 }
902 static inline xbt_dynar_t simcall_comm_waitany__getraw__comms(smx_simcall_t simcall)
903 {
904   return simgrid::simix::unmarshal_raw<xbt_dynar_t>(simcall->args[0]);
905 }
906 static inline void simcall_comm_waitany__set__comms(smx_simcall_t simcall, xbt_dynar_t arg)
907 {
908   simgrid::simix::marshal<xbt_dynar_t>(simcall->args[0], arg);
909 }
910 static inline double simcall_comm_waitany__get__timeout(smx_simcall_t simcall)
911 {
912   return simgrid::simix::unmarshal<double>(simcall->args[1]);
913 }
914 static inline double simcall_comm_waitany__getraw__timeout(smx_simcall_t simcall)
915 {
916   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
917 }
918 static inline void simcall_comm_waitany__set__timeout(smx_simcall_t simcall, double arg)
919 {
920   simgrid::simix::marshal<double>(simcall->args[1], arg);
921 }
922 static inline int simcall_comm_waitany__get__result(smx_simcall_t simcall)
923 {
924   return simgrid::simix::unmarshal<int>(simcall->result);
925 }
926 static inline int simcall_comm_waitany__getraw__result(smx_simcall_t simcall)
927 {
928   return simgrid::simix::unmarshal_raw<int>(simcall->result);
929 }
930 static inline void simcall_comm_waitany__set__result(smx_simcall_t simcall, int result)
931 {
932   simgrid::simix::marshal<int>(simcall->result, result);
933 }
934
935 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_comm_wait__get__comm(smx_simcall_t simcall)
936 {
937   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
938 }
939 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_wait__getraw__comm(smx_simcall_t simcall)
940 {
941   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
942 }
943 static inline void simcall_comm_wait__set__comm(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
944 {
945   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
946 }
947 static inline double simcall_comm_wait__get__timeout(smx_simcall_t simcall)
948 {
949   return simgrid::simix::unmarshal<double>(simcall->args[1]);
950 }
951 static inline double simcall_comm_wait__getraw__timeout(smx_simcall_t simcall)
952 {
953   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
954 }
955 static inline void simcall_comm_wait__set__timeout(smx_simcall_t simcall, double arg)
956 {
957   simgrid::simix::marshal<double>(simcall->args[1], arg);
958 }
959
960 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_comm_test__get__comm(smx_simcall_t simcall)
961 {
962   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
963 }
964 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_test__getraw__comm(smx_simcall_t simcall)
965 {
966   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
967 }
968 static inline void simcall_comm_test__set__comm(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
969 {
970   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
971 }
972 static inline int simcall_comm_test__get__result(smx_simcall_t simcall)
973 {
974   return simgrid::simix::unmarshal<int>(simcall->result);
975 }
976 static inline int simcall_comm_test__getraw__result(smx_simcall_t simcall)
977 {
978   return simgrid::simix::unmarshal_raw<int>(simcall->result);
979 }
980 static inline void simcall_comm_test__set__result(smx_simcall_t simcall, int result)
981 {
982   simgrid::simix::marshal<int>(simcall->result, result);
983 }
984
985 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>* simcall_comm_testany__get__comms(smx_simcall_t simcall)
986 {
987   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>*>(simcall->args[0]);
988 }
989 static inline simgrid::kernel::activity::ActivityImpl** simcall_comm_testany__getraw__comms(smx_simcall_t simcall)
990 {
991   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl**>(simcall->args[0]);
992 }
993 static inline void simcall_comm_testany__set__comms(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>* arg)
994 {
995   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>*>(simcall->args[0], arg);
996 }
997 static inline size_t simcall_comm_testany__get__count(smx_simcall_t simcall)
998 {
999   return simgrid::simix::unmarshal<size_t>(simcall->args[1]);
1000 }
1001 static inline size_t simcall_comm_testany__getraw__count(smx_simcall_t simcall)
1002 {
1003   return simgrid::simix::unmarshal_raw<size_t>(simcall->args[1]);
1004 }
1005 static inline void simcall_comm_testany__set__count(smx_simcall_t simcall, size_t arg)
1006 {
1007   simgrid::simix::marshal<size_t>(simcall->args[1], arg);
1008 }
1009 static inline int simcall_comm_testany__get__result(smx_simcall_t simcall)
1010 {
1011   return simgrid::simix::unmarshal<int>(simcall->result);
1012 }
1013 static inline int simcall_comm_testany__getraw__result(smx_simcall_t simcall)
1014 {
1015   return simgrid::simix::unmarshal_raw<int>(simcall->result);
1016 }
1017 static inline void simcall_comm_testany__set__result(smx_simcall_t simcall, int result)
1018 {
1019   simgrid::simix::marshal<int>(simcall->result, result);
1020 }
1021
1022 static inline smx_mutex_t simcall_mutex_lock__get__mutex(smx_simcall_t simcall)
1023 {
1024   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[0]);
1025 }
1026 static inline smx_mutex_t simcall_mutex_lock__getraw__mutex(smx_simcall_t simcall)
1027 {
1028   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[0]);
1029 }
1030 static inline void simcall_mutex_lock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
1031 {
1032   simgrid::simix::marshal<smx_mutex_t>(simcall->args[0], arg);
1033 }
1034
1035 static inline smx_mutex_t simcall_mutex_trylock__get__mutex(smx_simcall_t simcall)
1036 {
1037   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[0]);
1038 }
1039 static inline smx_mutex_t simcall_mutex_trylock__getraw__mutex(smx_simcall_t simcall)
1040 {
1041   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[0]);
1042 }
1043 static inline void simcall_mutex_trylock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
1044 {
1045   simgrid::simix::marshal<smx_mutex_t>(simcall->args[0], arg);
1046 }
1047 static inline int simcall_mutex_trylock__get__result(smx_simcall_t simcall)
1048 {
1049   return simgrid::simix::unmarshal<int>(simcall->result);
1050 }
1051 static inline int simcall_mutex_trylock__getraw__result(smx_simcall_t simcall)
1052 {
1053   return simgrid::simix::unmarshal_raw<int>(simcall->result);
1054 }
1055 static inline void simcall_mutex_trylock__set__result(smx_simcall_t simcall, int result)
1056 {
1057   simgrid::simix::marshal<int>(simcall->result, result);
1058 }
1059
1060 static inline smx_mutex_t simcall_mutex_unlock__get__mutex(smx_simcall_t simcall)
1061 {
1062   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[0]);
1063 }
1064 static inline smx_mutex_t simcall_mutex_unlock__getraw__mutex(smx_simcall_t simcall)
1065 {
1066   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[0]);
1067 }
1068 static inline void simcall_mutex_unlock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
1069 {
1070   simgrid::simix::marshal<smx_mutex_t>(simcall->args[0], arg);
1071 }
1072
1073 static inline smx_cond_t simcall_cond_init__get__result(smx_simcall_t simcall)
1074 {
1075   return simgrid::simix::unmarshal<smx_cond_t>(simcall->result);
1076 }
1077 static inline smx_cond_t simcall_cond_init__getraw__result(smx_simcall_t simcall)
1078 {
1079   return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->result);
1080 }
1081 static inline void simcall_cond_init__set__result(smx_simcall_t simcall, smx_cond_t result)
1082 {
1083   simgrid::simix::marshal<smx_cond_t>(simcall->result, result);
1084 }
1085
1086 static inline smx_cond_t simcall_cond_wait__get__cond(smx_simcall_t simcall)
1087 {
1088   return simgrid::simix::unmarshal<smx_cond_t>(simcall->args[0]);
1089 }
1090 static inline smx_cond_t simcall_cond_wait__getraw__cond(smx_simcall_t simcall)
1091 {
1092   return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->args[0]);
1093 }
1094 static inline void simcall_cond_wait__set__cond(smx_simcall_t simcall, smx_cond_t arg)
1095 {
1096   simgrid::simix::marshal<smx_cond_t>(simcall->args[0], arg);
1097 }
1098 static inline smx_mutex_t simcall_cond_wait__get__mutex(smx_simcall_t simcall)
1099 {
1100   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[1]);
1101 }
1102 static inline smx_mutex_t simcall_cond_wait__getraw__mutex(smx_simcall_t simcall)
1103 {
1104   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[1]);
1105 }
1106 static inline void simcall_cond_wait__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
1107 {
1108   simgrid::simix::marshal<smx_mutex_t>(simcall->args[1], arg);
1109 }
1110
1111 static inline smx_cond_t simcall_cond_wait_timeout__get__cond(smx_simcall_t simcall)
1112 {
1113   return simgrid::simix::unmarshal<smx_cond_t>(simcall->args[0]);
1114 }
1115 static inline smx_cond_t simcall_cond_wait_timeout__getraw__cond(smx_simcall_t simcall)
1116 {
1117   return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->args[0]);
1118 }
1119 static inline void simcall_cond_wait_timeout__set__cond(smx_simcall_t simcall, smx_cond_t arg)
1120 {
1121   simgrid::simix::marshal<smx_cond_t>(simcall->args[0], arg);
1122 }
1123 static inline smx_mutex_t simcall_cond_wait_timeout__get__mutex(smx_simcall_t simcall)
1124 {
1125   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[1]);
1126 }
1127 static inline smx_mutex_t simcall_cond_wait_timeout__getraw__mutex(smx_simcall_t simcall)
1128 {
1129   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[1]);
1130 }
1131 static inline void simcall_cond_wait_timeout__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
1132 {
1133   simgrid::simix::marshal<smx_mutex_t>(simcall->args[1], arg);
1134 }
1135 static inline double simcall_cond_wait_timeout__get__timeout(smx_simcall_t simcall)
1136 {
1137   return simgrid::simix::unmarshal<double>(simcall->args[2]);
1138 }
1139 static inline double simcall_cond_wait_timeout__getraw__timeout(smx_simcall_t simcall)
1140 {
1141   return simgrid::simix::unmarshal_raw<double>(simcall->args[2]);
1142 }
1143 static inline void simcall_cond_wait_timeout__set__timeout(smx_simcall_t simcall, double arg)
1144 {
1145   simgrid::simix::marshal<double>(simcall->args[2], arg);
1146 }
1147
1148 static inline smx_sem_t simcall_sem_acquire__get__sem(smx_simcall_t simcall)
1149 {
1150   return simgrid::simix::unmarshal<smx_sem_t>(simcall->args[0]);
1151 }
1152 static inline smx_sem_t simcall_sem_acquire__getraw__sem(smx_simcall_t simcall)
1153 {
1154   return simgrid::simix::unmarshal_raw<smx_sem_t>(simcall->args[0]);
1155 }
1156 static inline void simcall_sem_acquire__set__sem(smx_simcall_t simcall, smx_sem_t arg)
1157 {
1158   simgrid::simix::marshal<smx_sem_t>(simcall->args[0], arg);
1159 }
1160
1161 static inline smx_sem_t simcall_sem_acquire_timeout__get__sem(smx_simcall_t simcall)
1162 {
1163   return simgrid::simix::unmarshal<smx_sem_t>(simcall->args[0]);
1164 }
1165 static inline smx_sem_t simcall_sem_acquire_timeout__getraw__sem(smx_simcall_t simcall)
1166 {
1167   return simgrid::simix::unmarshal_raw<smx_sem_t>(simcall->args[0]);
1168 }
1169 static inline void simcall_sem_acquire_timeout__set__sem(smx_simcall_t simcall, smx_sem_t arg)
1170 {
1171   simgrid::simix::marshal<smx_sem_t>(simcall->args[0], arg);
1172 }
1173 static inline double simcall_sem_acquire_timeout__get__timeout(smx_simcall_t simcall)
1174 {
1175   return simgrid::simix::unmarshal<double>(simcall->args[1]);
1176 }
1177 static inline double simcall_sem_acquire_timeout__getraw__timeout(smx_simcall_t simcall)
1178 {
1179   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
1180 }
1181 static inline void simcall_sem_acquire_timeout__set__timeout(smx_simcall_t simcall, double arg)
1182 {
1183   simgrid::simix::marshal<double>(simcall->args[1], arg);
1184 }
1185
1186 static inline surf_storage_t simcall_storage_read__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_read__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_read__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_read__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_read__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_read__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_read__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_read__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_read__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 surf_storage_t simcall_storage_write__get__st(smx_simcall_t simcall)
1224 {
1225   return simgrid::simix::unmarshal<surf_storage_t>(simcall->args[0]);
1226 }
1227 static inline surf_storage_t simcall_storage_write__getraw__st(smx_simcall_t simcall)
1228 {
1229   return simgrid::simix::unmarshal_raw<surf_storage_t>(simcall->args[0]);
1230 }
1231 static inline void simcall_storage_write__set__st(smx_simcall_t simcall, surf_storage_t arg)
1232 {
1233   simgrid::simix::marshal<surf_storage_t>(simcall->args[0], arg);
1234 }
1235 static inline sg_size_t simcall_storage_write__get__size(smx_simcall_t simcall)
1236 {
1237   return simgrid::simix::unmarshal<sg_size_t>(simcall->args[1]);
1238 }
1239 static inline sg_size_t simcall_storage_write__getraw__size(smx_simcall_t simcall)
1240 {
1241   return simgrid::simix::unmarshal_raw<sg_size_t>(simcall->args[1]);
1242 }
1243 static inline void simcall_storage_write__set__size(smx_simcall_t simcall, sg_size_t arg)
1244 {
1245   simgrid::simix::marshal<sg_size_t>(simcall->args[1], arg);
1246 }
1247 static inline sg_size_t simcall_storage_write__get__result(smx_simcall_t simcall)
1248 {
1249   return simgrid::simix::unmarshal<sg_size_t>(simcall->result);
1250 }
1251 static inline sg_size_t simcall_storage_write__getraw__result(smx_simcall_t simcall)
1252 {
1253   return simgrid::simix::unmarshal_raw<sg_size_t>(simcall->result);
1254 }
1255 static inline void simcall_storage_write__set__result(smx_simcall_t simcall, sg_size_t result)
1256 {
1257   simgrid::simix::marshal<sg_size_t>(simcall->result, result);
1258 }
1259
1260 static inline int simcall_mc_random__get__min(smx_simcall_t simcall)
1261 {
1262   return simgrid::simix::unmarshal<int>(simcall->args[0]);
1263 }
1264 static inline int simcall_mc_random__getraw__min(smx_simcall_t simcall)
1265 {
1266   return simgrid::simix::unmarshal_raw<int>(simcall->args[0]);
1267 }
1268 static inline void simcall_mc_random__set__min(smx_simcall_t simcall, int arg)
1269 {
1270   simgrid::simix::marshal<int>(simcall->args[0], arg);
1271 }
1272 static inline int simcall_mc_random__get__max(smx_simcall_t simcall)
1273 {
1274   return simgrid::simix::unmarshal<int>(simcall->args[1]);
1275 }
1276 static inline int simcall_mc_random__getraw__max(smx_simcall_t simcall)
1277 {
1278   return simgrid::simix::unmarshal_raw<int>(simcall->args[1]);
1279 }
1280 static inline void simcall_mc_random__set__max(smx_simcall_t simcall, int arg)
1281 {
1282   simgrid::simix::marshal<int>(simcall->args[1], arg);
1283 }
1284 static inline int simcall_mc_random__get__result(smx_simcall_t simcall)
1285 {
1286   return simgrid::simix::unmarshal<int>(simcall->result);
1287 }
1288 static inline int simcall_mc_random__getraw__result(smx_simcall_t simcall)
1289 {
1290   return simgrid::simix::unmarshal_raw<int>(simcall->result);
1291 }
1292 static inline void simcall_mc_random__set__result(smx_simcall_t simcall, int result)
1293 {
1294   simgrid::simix::marshal<int>(simcall->result, result);
1295 }
1296
1297 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_set_category__get__synchro(smx_simcall_t simcall)
1298 {
1299   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
1300 }
1301 static inline simgrid::kernel::activity::ActivityImpl* simcall_set_category__getraw__synchro(smx_simcall_t simcall)
1302 {
1303   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
1304 }
1305 static inline void simcall_set_category__set__synchro(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
1306 {
1307   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
1308 }
1309 static inline const char* simcall_set_category__get__category(smx_simcall_t simcall)
1310 {
1311   return simgrid::simix::unmarshal<const char*>(simcall->args[1]);
1312 }
1313 static inline const char* simcall_set_category__getraw__category(smx_simcall_t simcall)
1314 {
1315   return simgrid::simix::unmarshal_raw<const char*>(simcall->args[1]);
1316 }
1317 static inline void simcall_set_category__set__category(smx_simcall_t simcall, const char* arg)
1318 {
1319   simgrid::simix::marshal<const char*>(simcall->args[1], arg);
1320 }
1321
1322 static inline std::function<void()> const* simcall_run_kernel__get__code(smx_simcall_t simcall)
1323 {
1324   return simgrid::simix::unmarshal<std::function<void()> const*>(simcall->args[0]);
1325 }
1326 static inline std::function<void()> const* simcall_run_kernel__getraw__code(smx_simcall_t simcall)
1327 {
1328   return simgrid::simix::unmarshal_raw<std::function<void()> const*>(simcall->args[0]);
1329 }
1330 static inline void simcall_run_kernel__set__code(smx_simcall_t simcall, std::function<void()> const* arg)
1331 {
1332   simgrid::simix::marshal<std::function<void()> const*>(simcall->args[0], arg);
1333 }
1334
1335 static inline std::function<void()> const* simcall_run_blocking__get__code(smx_simcall_t simcall)
1336 {
1337   return simgrid::simix::unmarshal<std::function<void()> const*>(simcall->args[0]);
1338 }
1339 static inline std::function<void()> const* simcall_run_blocking__getraw__code(smx_simcall_t simcall)
1340 {
1341   return simgrid::simix::unmarshal_raw<std::function<void()> const*>(simcall->args[0]);
1342 }
1343 static inline void simcall_run_blocking__set__code(smx_simcall_t simcall, std::function<void()> const* arg)
1344 {
1345   simgrid::simix::marshal<std::function<void()> const*>(simcall->args[0], arg);
1346 }
1347
1348 /* The prototype of all simcall handlers, automatically generated for you */
1349
1350 XBT_PRIVATE void simcall_HANDLER_process_suspend(smx_simcall_t simcall, smx_actor_t process);
1351 XBT_PRIVATE void simcall_HANDLER_process_join(smx_simcall_t simcall, smx_actor_t process, double timeout);
1352 XBT_PRIVATE void simcall_HANDLER_process_sleep(smx_simcall_t simcall, double duration);
1353 XBT_PRIVATE void simcall_HANDLER_execution_wait(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> execution);
1354 XBT_PRIVATE void
1355 simcall_HANDLER_execution_test(smx_simcall_t simcall,
1356                                boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> execution);
1357 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);
1358 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);
1359 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);
1360 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);
1361 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);
1362 XBT_PRIVATE void simcall_HANDLER_comm_waitany(smx_simcall_t simcall, xbt_dynar_t comms, double timeout);
1363 XBT_PRIVATE void simcall_HANDLER_comm_wait(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> comm, double timeout);
1364 XBT_PRIVATE void simcall_HANDLER_comm_test(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> comm);
1365 XBT_PRIVATE void simcall_HANDLER_comm_testany(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>* comms, size_t count);
1366 XBT_PRIVATE void simcall_HANDLER_mutex_lock(smx_simcall_t simcall, smx_mutex_t mutex);
1367 XBT_PRIVATE int simcall_HANDLER_mutex_trylock(smx_simcall_t simcall, smx_mutex_t mutex);
1368 XBT_PRIVATE void simcall_HANDLER_mutex_unlock(smx_simcall_t simcall, smx_mutex_t mutex);
1369 XBT_PRIVATE void simcall_HANDLER_cond_wait(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex);
1370 XBT_PRIVATE void simcall_HANDLER_cond_wait_timeout(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex, double timeout);
1371 XBT_PRIVATE void simcall_HANDLER_sem_acquire(smx_simcall_t simcall, smx_sem_t sem);
1372 XBT_PRIVATE void simcall_HANDLER_sem_acquire_timeout(smx_simcall_t simcall, smx_sem_t sem, double timeout);
1373 XBT_PRIVATE void simcall_HANDLER_storage_read(smx_simcall_t simcall, surf_storage_t st, sg_size_t size);
1374 XBT_PRIVATE void simcall_HANDLER_storage_write(smx_simcall_t simcall, surf_storage_t st, sg_size_t size);
1375 XBT_PRIVATE int simcall_HANDLER_mc_random(smx_simcall_t simcall, int min, int max);