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