src/simix/popping_accessors.h

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