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