src/simix/popping_accessors.h

   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.h"
  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     simgrid::simix::marshal<int>(simcall->result, result);
  91 }
  92
  93 static inline double simcall_process_sleep__get__duration(smx_simcall_t simcall)
  94 {
  95   return simgrid::simix::unmarshal<double>(simcall->args[0]);
  96 }
  97 static inline double simcall_process_sleep__getraw__duration(smx_simcall_t simcall)
  98 {
  99   return simgrid::simix::unmarshal_raw<double>(simcall->args[0]);
 100 }
 101 static inline void simcall_process_sleep__set__duration(smx_simcall_t simcall, double arg)
 102 {
 103   simgrid::simix::marshal<double>(simcall->args[0], arg);
 104 }
 105 static inline int simcall_process_sleep__get__result(smx_simcall_t simcall)
 106 {
 107   return simgrid::simix::unmarshal<int>(simcall->result);
 108 }
 109 static inline int simcall_process_sleep__getraw__result(smx_simcall_t simcall)
 110 {
 111   return simgrid::simix::unmarshal_raw<int>(simcall->result);
 112 }
 113 static inline void simcall_process_sleep__set__result(smx_simcall_t simcall, int result){
 114     simgrid::simix::marshal<int>(simcall->result, result);
 115 }
 116
 117 static inline const char* simcall_execution_start__get__name(smx_simcall_t simcall)
 118 {
 119   return simgrid::simix::unmarshal<const char*>(simcall->args[0]);
 120 }
 121 static inline const char* simcall_execution_start__getraw__name(smx_simcall_t simcall)
 122 {
 123   return simgrid::simix::unmarshal_raw<const char*>(simcall->args[0]);
 124 }
 125 static inline void simcall_execution_start__set__name(smx_simcall_t simcall, const char* arg)
 126 {
 127   simgrid::simix::marshal<const char*>(simcall->args[0], arg);
 128 }
 129 static inline double simcall_execution_start__get__flops_amount(smx_simcall_t simcall)
 130 {
 131   return simgrid::simix::unmarshal<double>(simcall->args[1]);
 132 }
 133 static inline double simcall_execution_start__getraw__flops_amount(smx_simcall_t simcall)
 134 {
 135   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
 136 }
 137 static inline void simcall_execution_start__set__flops_amount(smx_simcall_t simcall, double arg)
 138 {
 139   simgrid::simix::marshal<double>(simcall->args[1], arg);
 140 }
 141 static inline double simcall_execution_start__get__priority(smx_simcall_t simcall)
 142 {
 143   return simgrid::simix::unmarshal<double>(simcall->args[2]);
 144 }
 145 static inline double simcall_execution_start__getraw__priority(smx_simcall_t simcall)
 146 {
 147   return simgrid::simix::unmarshal_raw<double>(simcall->args[2]);
 148 }
 149 static inline void simcall_execution_start__set__priority(smx_simcall_t simcall, double arg)
 150 {
 151   simgrid::simix::marshal<double>(simcall->args[2], arg);
 152 }
 153 static inline double simcall_execution_start__get__bound(smx_simcall_t simcall)
 154 {
 155   return simgrid::simix::unmarshal<double>(simcall->args[3]);
 156 }
 157 static inline double simcall_execution_start__getraw__bound(smx_simcall_t simcall)
 158 {
 159   return simgrid::simix::unmarshal_raw<double>(simcall->args[3]);
 160 }
 161 static inline void simcall_execution_start__set__bound(smx_simcall_t simcall, double arg)
 162 {
 163   simgrid::simix::marshal<double>(simcall->args[3], arg);
 164 }
 165 static inline boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl>
 166 simcall_execution_start__get__result(smx_simcall_t simcall)
 167 {
 168   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl>>(simcall->result);
 169 }
 170 static inline simgrid::kernel::activity::ExecImpl* simcall_execution_start__getraw__result(smx_simcall_t simcall)
 171 {
 172   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ExecImpl*>(simcall->result);
 173 }
 174 static inline void
 175 simcall_execution_start__set__result(smx_simcall_t simcall,
 176                                      boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl> result)
 177 {
 178   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl>>(simcall->result, result);
 179 }
 180
 181 static inline const char* simcall_execution_parallel_start__get__name(smx_simcall_t simcall)
 182 {
 183   return simgrid::simix::unmarshal<const char*>(simcall->args[0]);
 184 }
 185 static inline const char* simcall_execution_parallel_start__getraw__name(smx_simcall_t simcall)
 186 {
 187   return simgrid::simix::unmarshal_raw<const char*>(simcall->args[0]);
 188 }
 189 static inline void simcall_execution_parallel_start__set__name(smx_simcall_t simcall, const char* arg)
 190 {
 191   simgrid::simix::marshal<const char*>(simcall->args[0], arg);
 192 }
 193 static inline int simcall_execution_parallel_start__get__host_nb(smx_simcall_t simcall)
 194 {
 195   return simgrid::simix::unmarshal<int>(simcall->args[1]);
 196 }
 197 static inline int simcall_execution_parallel_start__getraw__host_nb(smx_simcall_t simcall)
 198 {
 199   return simgrid::simix::unmarshal_raw<int>(simcall->args[1]);
 200 }
 201 static inline void simcall_execution_parallel_start__set__host_nb(smx_simcall_t simcall, int arg)
 202 {
 203   simgrid::simix::marshal<int>(simcall->args[1], arg);
 204 }
 205 static inline sg_host_t* simcall_execution_parallel_start__get__host_list(smx_simcall_t simcall)
 206 {
 207   return simgrid::simix::unmarshal<sg_host_t*>(simcall->args[2]);
 208 }
 209 static inline sg_host_t* simcall_execution_parallel_start__getraw__host_list(smx_simcall_t simcall)
 210 {
 211   return simgrid::simix::unmarshal_raw<sg_host_t*>(simcall->args[2]);
 212 }
 213 static inline void simcall_execution_parallel_start__set__host_list(smx_simcall_t simcall, sg_host_t* arg)
 214 {
 215   simgrid::simix::marshal<sg_host_t*>(simcall->args[2], arg);
 216 }
 217 static inline double* simcall_execution_parallel_start__get__flops_amount(smx_simcall_t simcall)
 218 {
 219   return simgrid::simix::unmarshal<double*>(simcall->args[3]);
 220 }
 221 static inline double* simcall_execution_parallel_start__getraw__flops_amount(smx_simcall_t simcall)
 222 {
 223   return simgrid::simix::unmarshal_raw<double*>(simcall->args[3]);
 224 }
 225 static inline void simcall_execution_parallel_start__set__flops_amount(smx_simcall_t simcall, double* arg)
 226 {
 227   simgrid::simix::marshal<double*>(simcall->args[3], arg);
 228 }
 229 static inline double* simcall_execution_parallel_start__get__bytes_amount(smx_simcall_t simcall)
 230 {
 231   return simgrid::simix::unmarshal<double*>(simcall->args[4]);
 232 }
 233 static inline double* simcall_execution_parallel_start__getraw__bytes_amount(smx_simcall_t simcall)
 234 {
 235   return simgrid::simix::unmarshal_raw<double*>(simcall->args[4]);
 236 }
 237 static inline void simcall_execution_parallel_start__set__bytes_amount(smx_simcall_t simcall, double* arg)
 238 {
 239   simgrid::simix::marshal<double*>(simcall->args[4], arg);
 240 }
 241 static inline double simcall_execution_parallel_start__get__rate(smx_simcall_t simcall)
 242 {
 243   return simgrid::simix::unmarshal<double>(simcall->args[5]);
 244 }
 245 static inline double simcall_execution_parallel_start__getraw__rate(smx_simcall_t simcall)
 246 {
 247   return simgrid::simix::unmarshal_raw<double>(simcall->args[5]);
 248 }
 249 static inline void simcall_execution_parallel_start__set__rate(smx_simcall_t simcall, double arg)
 250 {
 251   simgrid::simix::marshal<double>(simcall->args[5], arg);
 252 }
 253 static inline double simcall_execution_parallel_start__get__timeout(smx_simcall_t simcall)
 254 {
 255   return simgrid::simix::unmarshal<double>(simcall->args[6]);
 256 }
 257 static inline double simcall_execution_parallel_start__getraw__timeout(smx_simcall_t simcall)
 258 {
 259   return simgrid::simix::unmarshal_raw<double>(simcall->args[6]);
 260 }
 261 static inline void simcall_execution_parallel_start__set__timeout(smx_simcall_t simcall, double arg)
 262 {
 263   simgrid::simix::marshal<double>(simcall->args[6], arg);
 264 }
 265 static inline boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl>
 266 simcall_execution_parallel_start__get__result(smx_simcall_t simcall)
 267 {
 268   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl>>(simcall->result);
 269 }
 270 static inline simgrid::kernel::activity::ExecImpl*
 271 simcall_execution_parallel_start__getraw__result(smx_simcall_t simcall)
 272 {
 273   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ExecImpl*>(simcall->result);
 274 }
 275 static inline void
 276 simcall_execution_parallel_start__set__result(smx_simcall_t simcall,
 277                                               boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl> result)
 278 {
 279   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl>>(simcall->result, result);
 280 }
 281
 282 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
 283 simcall_execution_wait__get__execution(smx_simcall_t simcall)
 284 {
 285   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
 286 }
 287 static inline simgrid::kernel::activity::ActivityImpl* simcall_execution_wait__getraw__execution(smx_simcall_t simcall)
 288 {
 289   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
 290 }
 291 static inline void
 292 simcall_execution_wait__set__execution(smx_simcall_t simcall,
 293                                        boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
 294 {
 295   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
 296 }
 297 static inline int simcall_execution_wait__get__result(smx_simcall_t simcall)
 298 {
 299   return simgrid::simix::unmarshal<int>(simcall->result);
 300 }
 301 static inline int simcall_execution_wait__getraw__result(smx_simcall_t simcall)
 302 {
 303   return simgrid::simix::unmarshal_raw<int>(simcall->result);
 304 }
 305 static inline void simcall_execution_wait__set__result(smx_simcall_t simcall, int result){
 306     simgrid::simix::marshal<int>(simcall->result, result);
 307 }
 308
 309 static inline smx_actor_t simcall_process_on_exit__get__process(smx_simcall_t simcall)
 310 {
 311   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
 312 }
 313 static inline smx_actor_t simcall_process_on_exit__getraw__process(smx_simcall_t simcall)
 314 {
 315   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
 316 }
 317 static inline void simcall_process_on_exit__set__process(smx_simcall_t simcall, smx_actor_t arg)
 318 {
 319   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
 320 }
 321 static inline int_f_pvoid_pvoid_t simcall_process_on_exit__get__fun(smx_simcall_t simcall)
 322 {
 323   return simgrid::simix::unmarshal<int_f_pvoid_pvoid_t>(simcall->args[1]);
 324 }
 325 static inline int_f_pvoid_pvoid_t simcall_process_on_exit__getraw__fun(smx_simcall_t simcall)
 326 {
 327   return simgrid::simix::unmarshal_raw<int_f_pvoid_pvoid_t>(simcall->args[1]);
 328 }
 329 static inline void simcall_process_on_exit__set__fun(smx_simcall_t simcall, int_f_pvoid_pvoid_t arg)
 330 {
 331   simgrid::simix::marshal<int_f_pvoid_pvoid_t>(simcall->args[1], arg);
 332 }
 333 static inline void* simcall_process_on_exit__get__data(smx_simcall_t simcall)
 334 {
 335   return simgrid::simix::unmarshal<void*>(simcall->args[2]);
 336 }
 337 static inline void* simcall_process_on_exit__getraw__data(smx_simcall_t simcall)
 338 {
 339   return simgrid::simix::unmarshal_raw<void*>(simcall->args[2]);
 340 }
 341 static inline void simcall_process_on_exit__set__data(smx_simcall_t simcall, void* arg)
 342 {
 343   simgrid::simix::marshal<void*>(simcall->args[2], arg);
 344 }
 345
 346 static inline smx_mailbox_t simcall_comm_iprobe__get__mbox(smx_simcall_t simcall)
 347 {
 348   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[0]);
 349 }
 350 static inline smx_mailbox_t simcall_comm_iprobe__getraw__mbox(smx_simcall_t simcall)
 351 {
 352   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[0]);
 353 }
 354 static inline void simcall_comm_iprobe__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
 355 {
 356   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[0], arg);
 357 }
 358 static inline int simcall_comm_iprobe__get__type(smx_simcall_t simcall)
 359 {
 360   return simgrid::simix::unmarshal<int>(simcall->args[1]);
 361 }
 362 static inline int simcall_comm_iprobe__getraw__type(smx_simcall_t simcall)
 363 {
 364   return simgrid::simix::unmarshal_raw<int>(simcall->args[1]);
 365 }
 366 static inline void simcall_comm_iprobe__set__type(smx_simcall_t simcall, int arg)
 367 {
 368   simgrid::simix::marshal<int>(simcall->args[1], arg);
 369 }
 370 static inline simix_match_func_t simcall_comm_iprobe__get__match_fun(smx_simcall_t simcall)
 371 {
 372   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[2]);
 373 }
 374 static inline simix_match_func_t simcall_comm_iprobe__getraw__match_fun(smx_simcall_t simcall)
 375 {
 376   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[2]);
 377 }
 378 static inline void simcall_comm_iprobe__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
 379 {
 380   simgrid::simix::marshal<simix_match_func_t>(simcall->args[2], arg);
 381 }
 382 static inline void* simcall_comm_iprobe__get__data(smx_simcall_t simcall)
 383 {
 384   return simgrid::simix::unmarshal<void*>(simcall->args[3]);
 385 }
 386 static inline void* simcall_comm_iprobe__getraw__data(smx_simcall_t simcall)
 387 {
 388   return simgrid::simix::unmarshal_raw<void*>(simcall->args[3]);
 389 }
 390 static inline void simcall_comm_iprobe__set__data(smx_simcall_t simcall, void* arg)
 391 {
 392   simgrid::simix::marshal<void*>(simcall->args[3], arg);
 393 }
 394 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
 395 simcall_comm_iprobe__get__result(smx_simcall_t simcall)
 396 {
 397   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result);
 398 }
 399 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_iprobe__getraw__result(smx_simcall_t simcall)
 400 {
 401   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->result);
 402 }
 403 static inline void
 404 simcall_comm_iprobe__set__result(smx_simcall_t simcall,
 405                                  boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> result)
 406 {
 407   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result, result);
 408 }
 409
 410 static inline smx_actor_t simcall_comm_send__get__sender(smx_simcall_t simcall)
 411 {
 412   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
 413 }
 414 static inline smx_actor_t simcall_comm_send__getraw__sender(smx_simcall_t simcall)
 415 {
 416   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
 417 }
 418 static inline void simcall_comm_send__set__sender(smx_simcall_t simcall, smx_actor_t arg)
 419 {
 420   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
 421 }
 422 static inline smx_mailbox_t simcall_comm_send__get__mbox(smx_simcall_t simcall)
 423 {
 424   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[1]);
 425 }
 426 static inline smx_mailbox_t simcall_comm_send__getraw__mbox(smx_simcall_t simcall)
 427 {
 428   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[1]);
 429 }
 430 static inline void simcall_comm_send__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
 431 {
 432   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[1], arg);
 433 }
 434 static inline double simcall_comm_send__get__task_size(smx_simcall_t simcall)
 435 {
 436   return simgrid::simix::unmarshal<double>(simcall->args[2]);
 437 }
 438 static inline double simcall_comm_send__getraw__task_size(smx_simcall_t simcall)
 439 {
 440   return simgrid::simix::unmarshal_raw<double>(simcall->args[2]);
 441 }
 442 static inline void simcall_comm_send__set__task_size(smx_simcall_t simcall, double arg)
 443 {
 444   simgrid::simix::marshal<double>(simcall->args[2], arg);
 445 }
 446 static inline double simcall_comm_send__get__rate(smx_simcall_t simcall)
 447 {
 448   return simgrid::simix::unmarshal<double>(simcall->args[3]);
 449 }
 450 static inline double simcall_comm_send__getraw__rate(smx_simcall_t simcall)
 451 {
 452   return simgrid::simix::unmarshal_raw<double>(simcall->args[3]);
 453 }
 454 static inline void simcall_comm_send__set__rate(smx_simcall_t simcall, double arg)
 455 {
 456   simgrid::simix::marshal<double>(simcall->args[3], arg);
 457 }
 458 static inline void* simcall_comm_send__get__src_buff(smx_simcall_t simcall)
 459 {
 460   return simgrid::simix::unmarshal<void*>(simcall->args[4]);
 461 }
 462 static inline void* simcall_comm_send__getraw__src_buff(smx_simcall_t simcall)
 463 {
 464   return simgrid::simix::unmarshal_raw<void*>(simcall->args[4]);
 465 }
 466 static inline void simcall_comm_send__set__src_buff(smx_simcall_t simcall, void* arg)
 467 {
 468   simgrid::simix::marshal<void*>(simcall->args[4], arg);
 469 }
 470 static inline size_t simcall_comm_send__get__src_buff_size(smx_simcall_t simcall)
 471 {
 472   return simgrid::simix::unmarshal<size_t>(simcall->args[5]);
 473 }
 474 static inline size_t simcall_comm_send__getraw__src_buff_size(smx_simcall_t simcall)
 475 {
 476   return simgrid::simix::unmarshal_raw<size_t>(simcall->args[5]);
 477 }
 478 static inline void simcall_comm_send__set__src_buff_size(smx_simcall_t simcall, size_t arg)
 479 {
 480   simgrid::simix::marshal<size_t>(simcall->args[5], arg);
 481 }
 482 static inline simix_match_func_t simcall_comm_send__get__match_fun(smx_simcall_t simcall)
 483 {
 484   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[6]);
 485 }
 486 static inline simix_match_func_t simcall_comm_send__getraw__match_fun(smx_simcall_t simcall)
 487 {
 488   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[6]);
 489 }
 490 static inline void simcall_comm_send__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
 491 {
 492   simgrid::simix::marshal<simix_match_func_t>(simcall->args[6], arg);
 493 }
 494 static inline simix_copy_data_func_t simcall_comm_send__get__copy_data_fun(smx_simcall_t simcall)
 495 {
 496   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[7]);
 497 }
 498 static inline simix_copy_data_func_t simcall_comm_send__getraw__copy_data_fun(smx_simcall_t simcall)
 499 {
 500   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args[7]);
 501 }
 502 static inline void simcall_comm_send__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
 503 {
 504   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[7], arg);
 505 }
 506 static inline void* simcall_comm_send__get__data(smx_simcall_t simcall)
 507 {
 508   return simgrid::simix::unmarshal<void*>(simcall->args[8]);
 509 }
 510 static inline void* simcall_comm_send__getraw__data(smx_simcall_t simcall)
 511 {
 512   return simgrid::simix::unmarshal_raw<void*>(simcall->args[8]);
 513 }
 514 static inline void simcall_comm_send__set__data(smx_simcall_t simcall, void* arg)
 515 {
 516   simgrid::simix::marshal<void*>(simcall->args[8], arg);
 517 }
 518 static inline double simcall_comm_send__get__timeout(smx_simcall_t simcall)
 519 {
 520   return simgrid::simix::unmarshal<double>(simcall->args[9]);
 521 }
 522 static inline double simcall_comm_send__getraw__timeout(smx_simcall_t simcall)
 523 {
 524   return simgrid::simix::unmarshal_raw<double>(simcall->args[9]);
 525 }
 526 static inline void simcall_comm_send__set__timeout(smx_simcall_t simcall, double arg)
 527 {
 528   simgrid::simix::marshal<double>(simcall->args[9], arg);
 529 }
 530
 531 static inline smx_actor_t simcall_comm_isend__get__sender(smx_simcall_t simcall)
 532 {
 533   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
 534 }
 535 static inline smx_actor_t simcall_comm_isend__getraw__sender(smx_simcall_t simcall)
 536 {
 537   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
 538 }
 539 static inline void simcall_comm_isend__set__sender(smx_simcall_t simcall, smx_actor_t arg)
 540 {
 541   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
 542 }
 543 static inline smx_mailbox_t simcall_comm_isend__get__mbox(smx_simcall_t simcall)
 544 {
 545   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[1]);
 546 }
 547 static inline smx_mailbox_t simcall_comm_isend__getraw__mbox(smx_simcall_t simcall)
 548 {
 549   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[1]);
 550 }
 551 static inline void simcall_comm_isend__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
 552 {
 553   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[1], arg);
 554 }
 555 static inline double simcall_comm_isend__get__task_size(smx_simcall_t simcall)
 556 {
 557   return simgrid::simix::unmarshal<double>(simcall->args[2]);
 558 }
 559 static inline double simcall_comm_isend__getraw__task_size(smx_simcall_t simcall)
 560 {
 561   return simgrid::simix::unmarshal_raw<double>(simcall->args[2]);
 562 }
 563 static inline void simcall_comm_isend__set__task_size(smx_simcall_t simcall, double arg)
 564 {
 565   simgrid::simix::marshal<double>(simcall->args[2], arg);
 566 }
 567 static inline double simcall_comm_isend__get__rate(smx_simcall_t simcall)
 568 {
 569   return simgrid::simix::unmarshal<double>(simcall->args[3]);
 570 }
 571 static inline double simcall_comm_isend__getraw__rate(smx_simcall_t simcall)
 572 {
 573   return simgrid::simix::unmarshal_raw<double>(simcall->args[3]);
 574 }
 575 static inline void simcall_comm_isend__set__rate(smx_simcall_t simcall, double arg)
 576 {
 577   simgrid::simix::marshal<double>(simcall->args[3], arg);
 578 }
 579 static inline void* simcall_comm_isend__get__src_buff(smx_simcall_t simcall)
 580 {
 581   return simgrid::simix::unmarshal<void*>(simcall->args[4]);
 582 }
 583 static inline void* simcall_comm_isend__getraw__src_buff(smx_simcall_t simcall)
 584 {
 585   return simgrid::simix::unmarshal_raw<void*>(simcall->args[4]);
 586 }
 587 static inline void simcall_comm_isend__set__src_buff(smx_simcall_t simcall, void* arg)
 588 {
 589   simgrid::simix::marshal<void*>(simcall->args[4], arg);
 590 }
 591 static inline size_t simcall_comm_isend__get__src_buff_size(smx_simcall_t simcall)
 592 {
 593   return simgrid::simix::unmarshal<size_t>(simcall->args[5]);
 594 }
 595 static inline size_t simcall_comm_isend__getraw__src_buff_size(smx_simcall_t simcall)
 596 {
 597   return simgrid::simix::unmarshal_raw<size_t>(simcall->args[5]);
 598 }
 599 static inline void simcall_comm_isend__set__src_buff_size(smx_simcall_t simcall, size_t arg)
 600 {
 601   simgrid::simix::marshal<size_t>(simcall->args[5], arg);
 602 }
 603 static inline simix_match_func_t simcall_comm_isend__get__match_fun(smx_simcall_t simcall)
 604 {
 605   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[6]);
 606 }
 607 static inline simix_match_func_t simcall_comm_isend__getraw__match_fun(smx_simcall_t simcall)
 608 {
 609   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[6]);
 610 }
 611 static inline void simcall_comm_isend__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
 612 {
 613   simgrid::simix::marshal<simix_match_func_t>(simcall->args[6], arg);
 614 }
 615 static inline simix_clean_func_t simcall_comm_isend__get__clean_fun(smx_simcall_t simcall)
 616 {
 617   return simgrid::simix::unmarshal<simix_clean_func_t>(simcall->args[7]);
 618 }
 619 static inline simix_clean_func_t simcall_comm_isend__getraw__clean_fun(smx_simcall_t simcall)
 620 {
 621   return simgrid::simix::unmarshal_raw<simix_clean_func_t>(simcall->args[7]);
 622 }
 623 static inline void simcall_comm_isend__set__clean_fun(smx_simcall_t simcall, simix_clean_func_t arg)
 624 {
 625   simgrid::simix::marshal<simix_clean_func_t>(simcall->args[7], arg);
 626 }
 627 static inline simix_copy_data_func_t simcall_comm_isend__get__copy_data_fun(smx_simcall_t simcall)
 628 {
 629   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[8]);
 630 }
 631 static inline simix_copy_data_func_t simcall_comm_isend__getraw__copy_data_fun(smx_simcall_t simcall)
 632 {
 633   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args[8]);
 634 }
 635 static inline void simcall_comm_isend__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
 636 {
 637   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[8], arg);
 638 }
 639 static inline void* simcall_comm_isend__get__data(smx_simcall_t simcall)
 640 {
 641   return simgrid::simix::unmarshal<void*>(simcall->args[9]);
 642 }
 643 static inline void* simcall_comm_isend__getraw__data(smx_simcall_t simcall)
 644 {
 645   return simgrid::simix::unmarshal_raw<void*>(simcall->args[9]);
 646 }
 647 static inline void simcall_comm_isend__set__data(smx_simcall_t simcall, void* arg)
 648 {
 649   simgrid::simix::marshal<void*>(simcall->args[9], arg);
 650 }
 651 static inline int simcall_comm_isend__get__detached(smx_simcall_t simcall)
 652 {
 653   return simgrid::simix::unmarshal<int>(simcall->args[10]);
 654 }
 655 static inline int simcall_comm_isend__getraw__detached(smx_simcall_t simcall)
 656 {
 657   return simgrid::simix::unmarshal_raw<int>(simcall->args[10]);
 658 }
 659 static inline void simcall_comm_isend__set__detached(smx_simcall_t simcall, int arg)
 660 {
 661   simgrid::simix::marshal<int>(simcall->args[10], arg);
 662 }
 663 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
 664 simcall_comm_isend__get__result(smx_simcall_t simcall)
 665 {
 666   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result);
 667 }
 668 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_isend__getraw__result(smx_simcall_t simcall)
 669 {
 670   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->result);
 671 }
 672 static inline void simcall_comm_isend__set__result(smx_simcall_t simcall,
 673                                                    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>
 884 simcall_comm_irecv__get__result(smx_simcall_t simcall)
 885 {
 886   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result);
 887 }
 888 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_irecv__getraw__result(smx_simcall_t simcall)
 889 {
 890   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->result);
 891 }
 892 static inline void simcall_comm_irecv__set__result(smx_simcall_t simcall,
 893                                                    boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> result)
 894 {
 895   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result, result);
 896 }
 897
 898 static inline xbt_dynar_t simcall_comm_waitany__get__comms(smx_simcall_t simcall)
 899 {
 900   return simgrid::simix::unmarshal<xbt_dynar_t>(simcall->args[0]);
 901 }
 902 static inline xbt_dynar_t simcall_comm_waitany__getraw__comms(smx_simcall_t simcall)
 903 {
 904   return simgrid::simix::unmarshal_raw<xbt_dynar_t>(simcall->args[0]);
 905 }
 906 static inline void simcall_comm_waitany__set__comms(smx_simcall_t simcall, xbt_dynar_t arg)
 907 {
 908   simgrid::simix::marshal<xbt_dynar_t>(simcall->args[0], arg);
 909 }
 910 static inline double simcall_comm_waitany__get__timeout(smx_simcall_t simcall)
 911 {
 912   return simgrid::simix::unmarshal<double>(simcall->args[1]);
 913 }
 914 static inline double simcall_comm_waitany__getraw__timeout(smx_simcall_t simcall)
 915 {
 916   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
 917 }
 918 static inline void simcall_comm_waitany__set__timeout(smx_simcall_t simcall, double arg)
 919 {
 920   simgrid::simix::marshal<double>(simcall->args[1], arg);
 921 }
 922 static inline int simcall_comm_waitany__get__result(smx_simcall_t simcall)
 923 {
 924   return simgrid::simix::unmarshal<int>(simcall->result);
 925 }
 926 static inline int simcall_comm_waitany__getraw__result(smx_simcall_t simcall)
 927 {
 928   return simgrid::simix::unmarshal_raw<int>(simcall->result);
 929 }
 930 static inline void simcall_comm_waitany__set__result(smx_simcall_t simcall, int result){
 931     simgrid::simix::marshal<int>(simcall->result, result);
 932 }
 933
 934 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
 935 simcall_comm_wait__get__comm(smx_simcall_t simcall)
 936 {
 937   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
 938 }
 939 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_wait__getraw__comm(smx_simcall_t simcall)
 940 {
 941   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
 942 }
 943 static inline void simcall_comm_wait__set__comm(smx_simcall_t simcall,
 944                                                 boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
 945 {
 946   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
 947 }
 948 static inline double simcall_comm_wait__get__timeout(smx_simcall_t simcall)
 949 {
 950   return simgrid::simix::unmarshal<double>(simcall->args[1]);
 951 }
 952 static inline double simcall_comm_wait__getraw__timeout(smx_simcall_t simcall)
 953 {
 954   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
 955 }
 956 static inline void simcall_comm_wait__set__timeout(smx_simcall_t simcall, double arg)
 957 {
 958   simgrid::simix::marshal<double>(simcall->args[1], arg);
 959 }
 960
 961 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
 962 simcall_comm_test__get__comm(smx_simcall_t simcall)
 963 {
 964   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
 965 }
 966 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_test__getraw__comm(smx_simcall_t simcall)
 967 {
 968   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
 969 }
 970 static inline void simcall_comm_test__set__comm(smx_simcall_t simcall,
 971                                                 boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
 972 {
 973   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
 974 }
 975 static inline int simcall_comm_test__get__result(smx_simcall_t simcall)
 976 {
 977   return simgrid::simix::unmarshal<int>(simcall->result);
 978 }
 979 static inline int simcall_comm_test__getraw__result(smx_simcall_t simcall)
 980 {
 981   return simgrid::simix::unmarshal_raw<int>(simcall->result);
 982 }
 983 static inline void simcall_comm_test__set__result(smx_simcall_t simcall, int result){
 984     simgrid::simix::marshal<int>(simcall->result, result);
 985 }
 986
 987 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>*
 988 simcall_comm_testany__get__comms(smx_simcall_t simcall)
 989 {
 990   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>*>(simcall->args[0]);
 991 }
 992 static inline simgrid::kernel::activity::ActivityImpl** simcall_comm_testany__getraw__comms(smx_simcall_t simcall)
 993 {
 994   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl**>(simcall->args[0]);
 995 }
 996 static inline void simcall_comm_testany__set__comms(smx_simcall_t simcall,
 997                                                     boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>* arg)
 998 {
 999   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>*>(simcall->args[0], arg);
1000 }
1001 static inline size_t simcall_comm_testany__get__count(smx_simcall_t simcall)
1002 {
1003   return simgrid::simix::unmarshal<size_t>(simcall->args[1]);
1004 }
1005 static inline size_t simcall_comm_testany__getraw__count(smx_simcall_t simcall)
1006 {
1007   return simgrid::simix::unmarshal_raw<size_t>(simcall->args[1]);
1008 }
1009 static inline void simcall_comm_testany__set__count(smx_simcall_t simcall, size_t arg)
1010 {
1011   simgrid::simix::marshal<size_t>(simcall->args[1], arg);
1012 }
1013 static inline int simcall_comm_testany__get__result(smx_simcall_t simcall)
1014 {
1015   return simgrid::simix::unmarshal<int>(simcall->result);
1016 }
1017 static inline int simcall_comm_testany__getraw__result(smx_simcall_t simcall)
1018 {
1019   return simgrid::simix::unmarshal_raw<int>(simcall->result);
1020 }
1021 static inline void simcall_comm_testany__set__result(smx_simcall_t simcall, int result){
1022     simgrid::simix::marshal<int>(simcall->result, result);
1023 }
1024
1025 static inline smx_mutex_t simcall_mutex_lock__get__mutex(smx_simcall_t simcall)
1026 {
1027   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[0]);
1028 }
1029 static inline smx_mutex_t simcall_mutex_lock__getraw__mutex(smx_simcall_t simcall)
1030 {
1031   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[0]);
1032 }
1033 static inline void simcall_mutex_lock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
1034 {
1035   simgrid::simix::marshal<smx_mutex_t>(simcall->args[0], arg);
1036 }
1037
1038 static inline smx_mutex_t simcall_mutex_trylock__get__mutex(smx_simcall_t simcall)
1039 {
1040   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[0]);
1041 }
1042 static inline smx_mutex_t simcall_mutex_trylock__getraw__mutex(smx_simcall_t simcall)
1043 {
1044   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[0]);
1045 }
1046 static inline void simcall_mutex_trylock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
1047 {
1048   simgrid::simix::marshal<smx_mutex_t>(simcall->args[0], arg);
1049 }
1050 static inline int simcall_mutex_trylock__get__result(smx_simcall_t simcall)
1051 {
1052   return simgrid::simix::unmarshal<int>(simcall->result);
1053 }
1054 static inline int simcall_mutex_trylock__getraw__result(smx_simcall_t simcall)
1055 {
1056   return simgrid::simix::unmarshal_raw<int>(simcall->result);
1057 }
1058 static inline void simcall_mutex_trylock__set__result(smx_simcall_t simcall, int result){
1059     simgrid::simix::marshal<int>(simcall->result, result);
1060 }
1061
1062 static inline smx_mutex_t simcall_mutex_unlock__get__mutex(smx_simcall_t simcall)
1063 {
1064   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[0]);
1065 }
1066 static inline smx_mutex_t simcall_mutex_unlock__getraw__mutex(smx_simcall_t simcall)
1067 {
1068   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[0]);
1069 }
1070 static inline void simcall_mutex_unlock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
1071 {
1072   simgrid::simix::marshal<smx_mutex_t>(simcall->args[0], arg);
1073 }
1074
1075 static inline smx_cond_t simcall_cond_init__get__result(smx_simcall_t simcall)
1076 {
1077   return simgrid::simix::unmarshal<smx_cond_t>(simcall->result);
1078 }
1079 static inline smx_cond_t simcall_cond_init__getraw__result(smx_simcall_t simcall)
1080 {
1081   return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->result);
1082 }
1083 static inline void simcall_cond_init__set__result(smx_simcall_t simcall, smx_cond_t result){
1084     simgrid::simix::marshal<smx_cond_t>(simcall->result, result);
1085 }
1086
1087 static inline smx_cond_t simcall_cond_signal__get__cond(smx_simcall_t simcall)
1088 {
1089   return simgrid::simix::unmarshal<smx_cond_t>(simcall->args[0]);
1090 }
1091 static inline smx_cond_t simcall_cond_signal__getraw__cond(smx_simcall_t simcall)
1092 {
1093   return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->args[0]);
1094 }
1095 static inline void simcall_cond_signal__set__cond(smx_simcall_t simcall, smx_cond_t arg)
1096 {
1097   simgrid::simix::marshal<smx_cond_t>(simcall->args[0], arg);
1098 }
1099
1100 static inline smx_cond_t simcall_cond_wait__get__cond(smx_simcall_t simcall)
1101 {
1102   return simgrid::simix::unmarshal<smx_cond_t>(simcall->args[0]);
1103 }
1104 static inline smx_cond_t simcall_cond_wait__getraw__cond(smx_simcall_t simcall)
1105 {
1106   return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->args[0]);
1107 }
1108 static inline void simcall_cond_wait__set__cond(smx_simcall_t simcall, smx_cond_t arg)
1109 {
1110   simgrid::simix::marshal<smx_cond_t>(simcall->args[0], arg);
1111 }
1112 static inline smx_mutex_t simcall_cond_wait__get__mutex(smx_simcall_t simcall)
1113 {
1114   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[1]);
1115 }
1116 static inline smx_mutex_t simcall_cond_wait__getraw__mutex(smx_simcall_t simcall)
1117 {
1118   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[1]);
1119 }
1120 static inline void simcall_cond_wait__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
1121 {
1122   simgrid::simix::marshal<smx_mutex_t>(simcall->args[1], arg);
1123 }
1124
1125 static inline smx_cond_t simcall_cond_wait_timeout__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_timeout__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_timeout__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_timeout__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_timeout__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_timeout__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
1146 {
1147   simgrid::simix::marshal<smx_mutex_t>(simcall->args[1], arg);
1148 }
1149 static inline double simcall_cond_wait_timeout__get__timeout(smx_simcall_t simcall)
1150 {
1151   return simgrid::simix::unmarshal<double>(simcall->args[2]);
1152 }
1153 static inline double simcall_cond_wait_timeout__getraw__timeout(smx_simcall_t simcall)
1154 {
1155   return simgrid::simix::unmarshal_raw<double>(simcall->args[2]);
1156 }
1157 static inline void simcall_cond_wait_timeout__set__timeout(smx_simcall_t simcall, double arg)
1158 {
1159   simgrid::simix::marshal<double>(simcall->args[2], arg);
1160 }
1161
1162 static inline smx_cond_t simcall_cond_broadcast__get__cond(smx_simcall_t simcall)
1163 {
1164   return simgrid::simix::unmarshal<smx_cond_t>(simcall->args[0]);
1165 }
1166 static inline smx_cond_t simcall_cond_broadcast__getraw__cond(smx_simcall_t simcall)
1167 {
1168   return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->args[0]);
1169 }
1170 static inline void simcall_cond_broadcast__set__cond(smx_simcall_t simcall, smx_cond_t arg)
1171 {
1172   simgrid::simix::marshal<smx_cond_t>(simcall->args[0], arg);
1173 }
1174
1175 static inline smx_sem_t simcall_sem_acquire__get__sem(smx_simcall_t simcall)
1176 {
1177   return simgrid::simix::unmarshal<smx_sem_t>(simcall->args[0]);
1178 }
1179 static inline smx_sem_t simcall_sem_acquire__getraw__sem(smx_simcall_t simcall)
1180 {
1181   return simgrid::simix::unmarshal_raw<smx_sem_t>(simcall->args[0]);
1182 }
1183 static inline void simcall_sem_acquire__set__sem(smx_simcall_t simcall, smx_sem_t arg)
1184 {
1185   simgrid::simix::marshal<smx_sem_t>(simcall->args[0], arg);
1186 }
1187
1188 static inline smx_sem_t simcall_sem_acquire_timeout__get__sem(smx_simcall_t simcall)
1189 {
1190   return simgrid::simix::unmarshal<smx_sem_t>(simcall->args[0]);
1191 }
1192 static inline smx_sem_t simcall_sem_acquire_timeout__getraw__sem(smx_simcall_t simcall)
1193 {
1194   return simgrid::simix::unmarshal_raw<smx_sem_t>(simcall->args[0]);
1195 }
1196 static inline void simcall_sem_acquire_timeout__set__sem(smx_simcall_t simcall, smx_sem_t arg)
1197 {
1198   simgrid::simix::marshal<smx_sem_t>(simcall->args[0], arg);
1199 }
1200 static inline double simcall_sem_acquire_timeout__get__timeout(smx_simcall_t simcall)
1201 {
1202   return simgrid::simix::unmarshal<double>(simcall->args[1]);
1203 }
1204 static inline double simcall_sem_acquire_timeout__getraw__timeout(smx_simcall_t simcall)
1205 {
1206   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
1207 }
1208 static inline void simcall_sem_acquire_timeout__set__timeout(smx_simcall_t simcall, double arg)
1209 {
1210   simgrid::simix::marshal<double>(simcall->args[1], arg);
1211 }
1212
1213 static inline surf_file_t simcall_file_read__get__fd(smx_simcall_t simcall)
1214 {
1215   return simgrid::simix::unmarshal<surf_file_t>(simcall->args[0]);
1216 }
1217 static inline surf_file_t simcall_file_read__getraw__fd(smx_simcall_t simcall)
1218 {
1219   return simgrid::simix::unmarshal_raw<surf_file_t>(simcall->args[0]);
1220 }
1221 static inline void simcall_file_read__set__fd(smx_simcall_t simcall, surf_file_t arg)
1222 {
1223   simgrid::simix::marshal<surf_file_t>(simcall->args[0], arg);
1224 }
1225 static inline sg_size_t simcall_file_read__get__size(smx_simcall_t simcall)
1226 {
1227   return simgrid::simix::unmarshal<sg_size_t>(simcall->args[1]);
1228 }
1229 static inline sg_size_t simcall_file_read__getraw__size(smx_simcall_t simcall)
1230 {
1231   return simgrid::simix::unmarshal_raw<sg_size_t>(simcall->args[1]);
1232 }
1233 static inline void simcall_file_read__set__size(smx_simcall_t simcall, sg_size_t arg)
1234 {
1235   simgrid::simix::marshal<sg_size_t>(simcall->args[1], arg);
1236 }
1237 static inline sg_size_t simcall_file_read__get__result(smx_simcall_t simcall)
1238 {
1239   return simgrid::simix::unmarshal<sg_size_t>(simcall->result);
1240 }
1241 static inline sg_size_t simcall_file_read__getraw__result(smx_simcall_t simcall)
1242 {
1243   return simgrid::simix::unmarshal_raw<sg_size_t>(simcall->result);
1244 }
1245 static inline void simcall_file_read__set__result(smx_simcall_t simcall, sg_size_t result){
1246     simgrid::simix::marshal<sg_size_t>(simcall->result, result);
1247 }
1248
1249 static inline surf_file_t simcall_file_write__get__fd(smx_simcall_t simcall)
1250 {
1251   return simgrid::simix::unmarshal<surf_file_t>(simcall->args[0]);
1252 }
1253 static inline surf_file_t simcall_file_write__getraw__fd(smx_simcall_t simcall)
1254 {
1255   return simgrid::simix::unmarshal_raw<surf_file_t>(simcall->args[0]);
1256 }
1257 static inline void simcall_file_write__set__fd(smx_simcall_t simcall, surf_file_t arg)
1258 {
1259   simgrid::simix::marshal<surf_file_t>(simcall->args[0], arg);
1260 }
1261 static inline sg_size_t simcall_file_write__get__size(smx_simcall_t simcall)
1262 {
1263   return simgrid::simix::unmarshal<sg_size_t>(simcall->args[1]);
1264 }
1265 static inline sg_size_t simcall_file_write__getraw__size(smx_simcall_t simcall)
1266 {
1267   return simgrid::simix::unmarshal_raw<sg_size_t>(simcall->args[1]);
1268 }
1269 static inline void simcall_file_write__set__size(smx_simcall_t simcall, sg_size_t arg)
1270 {
1271   simgrid::simix::marshal<sg_size_t>(simcall->args[1], arg);
1272 }
1273 static inline sg_size_t simcall_file_write__get__result(smx_simcall_t simcall)
1274 {
1275   return simgrid::simix::unmarshal<sg_size_t>(simcall->result);
1276 }
1277 static inline sg_size_t simcall_file_write__getraw__result(smx_simcall_t simcall)
1278 {
1279   return simgrid::simix::unmarshal_raw<sg_size_t>(simcall->result);
1280 }
1281 static inline void simcall_file_write__set__result(smx_simcall_t simcall, sg_size_t result){
1282     simgrid::simix::marshal<sg_size_t>(simcall->result, result);
1283 }
1284
1285 static inline int simcall_mc_random__get__min(smx_simcall_t simcall)
1286 {
1287   return simgrid::simix::unmarshal<int>(simcall->args[0]);
1288 }
1289 static inline int simcall_mc_random__getraw__min(smx_simcall_t simcall)
1290 {
1291   return simgrid::simix::unmarshal_raw<int>(simcall->args[0]);
1292 }
1293 static inline void simcall_mc_random__set__min(smx_simcall_t simcall, int arg)
1294 {
1295   simgrid::simix::marshal<int>(simcall->args[0], arg);
1296 }
1297 static inline int simcall_mc_random__get__max(smx_simcall_t simcall)
1298 {
1299   return simgrid::simix::unmarshal<int>(simcall->args[1]);
1300 }
1301 static inline int simcall_mc_random__getraw__max(smx_simcall_t simcall)
1302 {
1303   return simgrid::simix::unmarshal_raw<int>(simcall->args[1]);
1304 }
1305 static inline void simcall_mc_random__set__max(smx_simcall_t simcall, int arg)
1306 {
1307   simgrid::simix::marshal<int>(simcall->args[1], arg);
1308 }
1309 static inline int simcall_mc_random__get__result(smx_simcall_t simcall)
1310 {
1311   return simgrid::simix::unmarshal<int>(simcall->result);
1312 }
1313 static inline int simcall_mc_random__getraw__result(smx_simcall_t simcall)
1314 {
1315   return simgrid::simix::unmarshal_raw<int>(simcall->result);
1316 }
1317 static inline void simcall_mc_random__set__result(smx_simcall_t simcall, int result){
1318     simgrid::simix::marshal<int>(simcall->result, result);
1319 }
1320
1321 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
1322 simcall_set_category__get__synchro(smx_simcall_t simcall)
1323 {
1324   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
1325 }
1326 static inline simgrid::kernel::activity::ActivityImpl* simcall_set_category__getraw__synchro(smx_simcall_t simcall)
1327 {
1328   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
1329 }
1330 static inline void simcall_set_category__set__synchro(smx_simcall_t simcall,
1331                                                       boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
1332 {
1333   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
1334 }
1335 static inline const char* simcall_set_category__get__category(smx_simcall_t simcall)
1336 {
1337   return simgrid::simix::unmarshal<const char*>(simcall->args[1]);
1338 }
1339 static inline const char* simcall_set_category__getraw__category(smx_simcall_t simcall)
1340 {
1341   return simgrid::simix::unmarshal_raw<const char*>(simcall->args[1]);
1342 }
1343 static inline void simcall_set_category__set__category(smx_simcall_t simcall, const char* arg)
1344 {
1345   simgrid::simix::marshal<const char*>(simcall->args[1], arg);
1346 }
1347
1348 static inline std::function<void()> const* simcall_run_kernel__get__code(smx_simcall_t simcall)
1349 {
1350   return simgrid::simix::unmarshal<std::function<void()> const*>(simcall->args[0]);
1351 }
1352 static inline std::function<void()> const* simcall_run_kernel__getraw__code(smx_simcall_t simcall)
1353 {
1354   return simgrid::simix::unmarshal_raw<std::function<void()> const*>(simcall->args[0]);
1355 }
1356 static inline void simcall_run_kernel__set__code(smx_simcall_t simcall, std::function<void()> const* arg)
1357 {
1358   simgrid::simix::marshal<std::function<void()> const*>(simcall->args[0], arg);
1359 }
1360
1361 static inline std::function<void()> const* simcall_run_blocking__get__code(smx_simcall_t simcall)
1362 {
1363   return simgrid::simix::unmarshal<std::function<void()> const*>(simcall->args[0]);
1364 }
1365 static inline std::function<void()> const* simcall_run_blocking__getraw__code(smx_simcall_t simcall)
1366 {
1367   return simgrid::simix::unmarshal_raw<std::function<void()> const*>(simcall->args[0]);
1368 }
1369 static inline void simcall_run_blocking__set__code(smx_simcall_t simcall, std::function<void()> const* arg)
1370 {
1371   simgrid::simix::marshal<std::function<void()> const*>(simcall->args[0], arg);
1372 }
1373
1374 /* The prototype of all simcall handlers, automatically generated for you */
1375
1376 XBT_PRIVATE void simcall_HANDLER_process_killall(smx_simcall_t simcall, int reset_pid);
1377 XBT_PRIVATE void simcall_HANDLER_process_suspend(smx_simcall_t simcall, smx_actor_t process);
1378 XBT_PRIVATE void simcall_HANDLER_process_join(smx_simcall_t simcall, smx_actor_t process, double timeout);
1379 XBT_PRIVATE void simcall_HANDLER_process_sleep(smx_simcall_t simcall, double duration);
1380 XBT_PRIVATE boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl>
1381 simcall_HANDLER_execution_start(smx_simcall_t simcall, const char* name, double flops_amount, double priority,
1382                                 double bound);
1383 XBT_PRIVATE void
1384 simcall_HANDLER_execution_wait(smx_simcall_t simcall,
1385                                boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> execution);
1386 XBT_PRIVATE boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
1387 simcall_HANDLER_comm_iprobe(smx_simcall_t simcall, smx_mailbox_t mbox, int type, simix_match_func_t match_fun,
1388                             void* data);
1389 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);
1390 XBT_PRIVATE boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
1391 simcall_HANDLER_comm_isend(smx_simcall_t simcall, smx_actor_t sender, smx_mailbox_t mbox, double task_size, double rate,
1392                            void* src_buff, size_t src_buff_size, simix_match_func_t match_fun,
1393                            simix_clean_func_t clean_fun, simix_copy_data_func_t copy_data_fun, void* data,
1394                            int detached);
1395 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);
1396 XBT_PRIVATE boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
1397 simcall_HANDLER_comm_irecv(smx_simcall_t simcall, smx_actor_t receiver, smx_mailbox_t mbox, void* dst_buff,
1398                            size_t* dst_buff_size, simix_match_func_t match_fun, simix_copy_data_func_t copy_data_fun,
1399                            void* data, double rate);
1400 XBT_PRIVATE void simcall_HANDLER_comm_waitany(smx_simcall_t simcall, xbt_dynar_t comms, double timeout);
1401 XBT_PRIVATE void simcall_HANDLER_comm_wait(smx_simcall_t simcall,
1402                                            boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> comm,
1403                                            double timeout);
1404 XBT_PRIVATE void simcall_HANDLER_comm_test(smx_simcall_t simcall,
1405                                            boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> comm);
1406 XBT_PRIVATE void simcall_HANDLER_comm_testany(smx_simcall_t simcall,
1407                                               boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>* comms,
1408                                               size_t count);
1409 XBT_PRIVATE void simcall_HANDLER_mutex_lock(smx_simcall_t simcall, smx_mutex_t mutex);
1410 XBT_PRIVATE int simcall_HANDLER_mutex_trylock(smx_simcall_t simcall, smx_mutex_t mutex);
1411 XBT_PRIVATE void simcall_HANDLER_mutex_unlock(smx_simcall_t simcall, smx_mutex_t mutex);
1412 XBT_PRIVATE void simcall_HANDLER_cond_wait(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex);
1413 XBT_PRIVATE void simcall_HANDLER_cond_wait_timeout(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex, double timeout);
1414 XBT_PRIVATE void simcall_HANDLER_sem_acquire(smx_simcall_t simcall, smx_sem_t sem);
1415 XBT_PRIVATE void simcall_HANDLER_sem_acquire_timeout(smx_simcall_t simcall, smx_sem_t sem, double timeout);
1416 XBT_PRIVATE void simcall_HANDLER_file_read(smx_simcall_t simcall, surf_file_t fd, sg_size_t size);
1417 XBT_PRIVATE void simcall_HANDLER_file_write(smx_simcall_t simcall, surf_file_t fd, sg_size_t size);
1418 XBT_PRIVATE int simcall_HANDLER_mc_random(smx_simcall_t simcall, int min, int max);