src/simix/popping_accessors.hpp

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