src/simix/popping_accessors.hpp

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