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