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