Logo AND Algorithmique Numérique Distribuée

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