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_auto_restart_set__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_auto_restart_set__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_auto_restart_set__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 int simcall_process_auto_restart_set__get__auto_restart(smx_simcall_t simcall)
 459 {
 460   return simgrid::simix::unmarshal<int>(simcall->args[1]);
 461 }
 462 static inline int simcall_process_auto_restart_set__getraw__auto_restart(smx_simcall_t simcall)
 463 {
 464   return simgrid::simix::unmarshal_raw<int>(simcall->args[1]);
 465 }
 466 static inline void simcall_process_auto_restart_set__set__auto_restart(smx_simcall_t simcall, int arg)
 467 {
 468   simgrid::simix::marshal<int>(simcall->args[1], arg);
 469 }
 470
 471 static inline smx_actor_t simcall_process_restart__get__process(smx_simcall_t simcall)
 472 {
 473   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
 474 }
 475 static inline smx_actor_t simcall_process_restart__getraw__process(smx_simcall_t simcall)
 476 {
 477   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
 478 }
 479 static inline void simcall_process_restart__set__process(smx_simcall_t simcall, smx_actor_t arg)
 480 {
 481   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
 482 }
 483 static inline smx_actor_t simcall_process_restart__get__result(smx_simcall_t simcall)
 484 {
 485   return simgrid::simix::unmarshal<smx_actor_t>(simcall->result);
 486 }
 487 static inline smx_actor_t simcall_process_restart__getraw__result(smx_simcall_t simcall)
 488 {
 489   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->result);
 490 }
 491 static inline void simcall_process_restart__set__result(smx_simcall_t simcall, smx_actor_t result){
 492     simgrid::simix::marshal<smx_actor_t>(simcall->result, result);
 493 }
 494
 495 static inline smx_mailbox_t simcall_comm_iprobe__get__mbox(smx_simcall_t simcall)
 496 {
 497   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[0]);
 498 }
 499 static inline smx_mailbox_t simcall_comm_iprobe__getraw__mbox(smx_simcall_t simcall)
 500 {
 501   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[0]);
 502 }
 503 static inline void simcall_comm_iprobe__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
 504 {
 505   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[0], arg);
 506 }
 507 static inline int simcall_comm_iprobe__get__type(smx_simcall_t simcall)
 508 {
 509   return simgrid::simix::unmarshal<int>(simcall->args[1]);
 510 }
 511 static inline int simcall_comm_iprobe__getraw__type(smx_simcall_t simcall)
 512 {
 513   return simgrid::simix::unmarshal_raw<int>(simcall->args[1]);
 514 }
 515 static inline void simcall_comm_iprobe__set__type(smx_simcall_t simcall, int arg)
 516 {
 517   simgrid::simix::marshal<int>(simcall->args[1], arg);
 518 }
 519 static inline int simcall_comm_iprobe__get__src(smx_simcall_t simcall)
 520 {
 521   return simgrid::simix::unmarshal<int>(simcall->args[2]);
 522 }
 523 static inline int simcall_comm_iprobe__getraw__src(smx_simcall_t simcall)
 524 {
 525   return simgrid::simix::unmarshal_raw<int>(simcall->args[2]);
 526 }
 527 static inline void simcall_comm_iprobe__set__src(smx_simcall_t simcall, int arg)
 528 {
 529   simgrid::simix::marshal<int>(simcall->args[2], arg);
 530 }
 531 static inline int simcall_comm_iprobe__get__tag(smx_simcall_t simcall)
 532 {
 533   return simgrid::simix::unmarshal<int>(simcall->args[3]);
 534 }
 535 static inline int simcall_comm_iprobe__getraw__tag(smx_simcall_t simcall)
 536 {
 537   return simgrid::simix::unmarshal_raw<int>(simcall->args[3]);
 538 }
 539 static inline void simcall_comm_iprobe__set__tag(smx_simcall_t simcall, int arg)
 540 {
 541   simgrid::simix::marshal<int>(simcall->args[3], arg);
 542 }
 543 static inline simix_match_func_t simcall_comm_iprobe__get__match_fun(smx_simcall_t simcall)
 544 {
 545   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[4]);
 546 }
 547 static inline simix_match_func_t simcall_comm_iprobe__getraw__match_fun(smx_simcall_t simcall)
 548 {
 549   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[4]);
 550 }
 551 static inline void simcall_comm_iprobe__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
 552 {
 553   simgrid::simix::marshal<simix_match_func_t>(simcall->args[4], arg);
 554 }
 555 static inline void* simcall_comm_iprobe__get__data(smx_simcall_t simcall)
 556 {
 557   return simgrid::simix::unmarshal<void*>(simcall->args[5]);
 558 }
 559 static inline void* simcall_comm_iprobe__getraw__data(smx_simcall_t simcall)
 560 {
 561   return simgrid::simix::unmarshal_raw<void*>(simcall->args[5]);
 562 }
 563 static inline void simcall_comm_iprobe__set__data(smx_simcall_t simcall, void* arg)
 564 {
 565   simgrid::simix::marshal<void*>(simcall->args[5], arg);
 566 }
 567 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
 568 simcall_comm_iprobe__get__result(smx_simcall_t simcall)
 569 {
 570   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result);
 571 }
 572 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_iprobe__getraw__result(smx_simcall_t simcall)
 573 {
 574   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->result);
 575 }
 576 static inline void
 577 simcall_comm_iprobe__set__result(smx_simcall_t simcall,
 578                                  boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> result)
 579 {
 580   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result, result);
 581 }
 582
 583 static inline smx_actor_t simcall_comm_send__get__sender(smx_simcall_t simcall)
 584 {
 585   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
 586 }
 587 static inline smx_actor_t simcall_comm_send__getraw__sender(smx_simcall_t simcall)
 588 {
 589   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
 590 }
 591 static inline void simcall_comm_send__set__sender(smx_simcall_t simcall, smx_actor_t arg)
 592 {
 593   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
 594 }
 595 static inline smx_mailbox_t simcall_comm_send__get__mbox(smx_simcall_t simcall)
 596 {
 597   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[1]);
 598 }
 599 static inline smx_mailbox_t simcall_comm_send__getraw__mbox(smx_simcall_t simcall)
 600 {
 601   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[1]);
 602 }
 603 static inline void simcall_comm_send__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
 604 {
 605   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[1], arg);
 606 }
 607 static inline double simcall_comm_send__get__task_size(smx_simcall_t simcall)
 608 {
 609   return simgrid::simix::unmarshal<double>(simcall->args[2]);
 610 }
 611 static inline double simcall_comm_send__getraw__task_size(smx_simcall_t simcall)
 612 {
 613   return simgrid::simix::unmarshal_raw<double>(simcall->args[2]);
 614 }
 615 static inline void simcall_comm_send__set__task_size(smx_simcall_t simcall, double arg)
 616 {
 617   simgrid::simix::marshal<double>(simcall->args[2], arg);
 618 }
 619 static inline double simcall_comm_send__get__rate(smx_simcall_t simcall)
 620 {
 621   return simgrid::simix::unmarshal<double>(simcall->args[3]);
 622 }
 623 static inline double simcall_comm_send__getraw__rate(smx_simcall_t simcall)
 624 {
 625   return simgrid::simix::unmarshal_raw<double>(simcall->args[3]);
 626 }
 627 static inline void simcall_comm_send__set__rate(smx_simcall_t simcall, double arg)
 628 {
 629   simgrid::simix::marshal<double>(simcall->args[3], arg);
 630 }
 631 static inline void* simcall_comm_send__get__src_buff(smx_simcall_t simcall)
 632 {
 633   return simgrid::simix::unmarshal<void*>(simcall->args[4]);
 634 }
 635 static inline void* simcall_comm_send__getraw__src_buff(smx_simcall_t simcall)
 636 {
 637   return simgrid::simix::unmarshal_raw<void*>(simcall->args[4]);
 638 }
 639 static inline void simcall_comm_send__set__src_buff(smx_simcall_t simcall, void* arg)
 640 {
 641   simgrid::simix::marshal<void*>(simcall->args[4], arg);
 642 }
 643 static inline size_t simcall_comm_send__get__src_buff_size(smx_simcall_t simcall)
 644 {
 645   return simgrid::simix::unmarshal<size_t>(simcall->args[5]);
 646 }
 647 static inline size_t simcall_comm_send__getraw__src_buff_size(smx_simcall_t simcall)
 648 {
 649   return simgrid::simix::unmarshal_raw<size_t>(simcall->args[5]);
 650 }
 651 static inline void simcall_comm_send__set__src_buff_size(smx_simcall_t simcall, size_t arg)
 652 {
 653   simgrid::simix::marshal<size_t>(simcall->args[5], arg);
 654 }
 655 static inline simix_match_func_t simcall_comm_send__get__match_fun(smx_simcall_t simcall)
 656 {
 657   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[6]);
 658 }
 659 static inline simix_match_func_t simcall_comm_send__getraw__match_fun(smx_simcall_t simcall)
 660 {
 661   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[6]);
 662 }
 663 static inline void simcall_comm_send__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
 664 {
 665   simgrid::simix::marshal<simix_match_func_t>(simcall->args[6], arg);
 666 }
 667 static inline simix_copy_data_func_t simcall_comm_send__get__copy_data_fun(smx_simcall_t simcall)
 668 {
 669   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[7]);
 670 }
 671 static inline simix_copy_data_func_t simcall_comm_send__getraw__copy_data_fun(smx_simcall_t simcall)
 672 {
 673   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args[7]);
 674 }
 675 static inline void simcall_comm_send__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
 676 {
 677   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[7], arg);
 678 }
 679 static inline void* simcall_comm_send__get__data(smx_simcall_t simcall)
 680 {
 681   return simgrid::simix::unmarshal<void*>(simcall->args[8]);
 682 }
 683 static inline void* simcall_comm_send__getraw__data(smx_simcall_t simcall)
 684 {
 685   return simgrid::simix::unmarshal_raw<void*>(simcall->args[8]);
 686 }
 687 static inline void simcall_comm_send__set__data(smx_simcall_t simcall, void* arg)
 688 {
 689   simgrid::simix::marshal<void*>(simcall->args[8], arg);
 690 }
 691 static inline double simcall_comm_send__get__timeout(smx_simcall_t simcall)
 692 {
 693   return simgrid::simix::unmarshal<double>(simcall->args[9]);
 694 }
 695 static inline double simcall_comm_send__getraw__timeout(smx_simcall_t simcall)
 696 {
 697   return simgrid::simix::unmarshal_raw<double>(simcall->args[9]);
 698 }
 699 static inline void simcall_comm_send__set__timeout(smx_simcall_t simcall, double arg)
 700 {
 701   simgrid::simix::marshal<double>(simcall->args[9], arg);
 702 }
 703
 704 static inline smx_actor_t simcall_comm_isend__get__sender(smx_simcall_t simcall)
 705 {
 706   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
 707 }
 708 static inline smx_actor_t simcall_comm_isend__getraw__sender(smx_simcall_t simcall)
 709 {
 710   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
 711 }
 712 static inline void simcall_comm_isend__set__sender(smx_simcall_t simcall, smx_actor_t arg)
 713 {
 714   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
 715 }
 716 static inline smx_mailbox_t simcall_comm_isend__get__mbox(smx_simcall_t simcall)
 717 {
 718   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[1]);
 719 }
 720 static inline smx_mailbox_t simcall_comm_isend__getraw__mbox(smx_simcall_t simcall)
 721 {
 722   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[1]);
 723 }
 724 static inline void simcall_comm_isend__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
 725 {
 726   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[1], arg);
 727 }
 728 static inline double simcall_comm_isend__get__task_size(smx_simcall_t simcall)
 729 {
 730   return simgrid::simix::unmarshal<double>(simcall->args[2]);
 731 }
 732 static inline double simcall_comm_isend__getraw__task_size(smx_simcall_t simcall)
 733 {
 734   return simgrid::simix::unmarshal_raw<double>(simcall->args[2]);
 735 }
 736 static inline void simcall_comm_isend__set__task_size(smx_simcall_t simcall, double arg)
 737 {
 738   simgrid::simix::marshal<double>(simcall->args[2], arg);
 739 }
 740 static inline double simcall_comm_isend__get__rate(smx_simcall_t simcall)
 741 {
 742   return simgrid::simix::unmarshal<double>(simcall->args[3]);
 743 }
 744 static inline double simcall_comm_isend__getraw__rate(smx_simcall_t simcall)
 745 {
 746   return simgrid::simix::unmarshal_raw<double>(simcall->args[3]);
 747 }
 748 static inline void simcall_comm_isend__set__rate(smx_simcall_t simcall, double arg)
 749 {
 750   simgrid::simix::marshal<double>(simcall->args[3], arg);
 751 }
 752 static inline void* simcall_comm_isend__get__src_buff(smx_simcall_t simcall)
 753 {
 754   return simgrid::simix::unmarshal<void*>(simcall->args[4]);
 755 }
 756 static inline void* simcall_comm_isend__getraw__src_buff(smx_simcall_t simcall)
 757 {
 758   return simgrid::simix::unmarshal_raw<void*>(simcall->args[4]);
 759 }
 760 static inline void simcall_comm_isend__set__src_buff(smx_simcall_t simcall, void* arg)
 761 {
 762   simgrid::simix::marshal<void*>(simcall->args[4], arg);
 763 }
 764 static inline size_t simcall_comm_isend__get__src_buff_size(smx_simcall_t simcall)
 765 {
 766   return simgrid::simix::unmarshal<size_t>(simcall->args[5]);
 767 }
 768 static inline size_t simcall_comm_isend__getraw__src_buff_size(smx_simcall_t simcall)
 769 {
 770   return simgrid::simix::unmarshal_raw<size_t>(simcall->args[5]);
 771 }
 772 static inline void simcall_comm_isend__set__src_buff_size(smx_simcall_t simcall, size_t arg)
 773 {
 774   simgrid::simix::marshal<size_t>(simcall->args[5], arg);
 775 }
 776 static inline simix_match_func_t simcall_comm_isend__get__match_fun(smx_simcall_t simcall)
 777 {
 778   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[6]);
 779 }
 780 static inline simix_match_func_t simcall_comm_isend__getraw__match_fun(smx_simcall_t simcall)
 781 {
 782   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[6]);
 783 }
 784 static inline void simcall_comm_isend__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
 785 {
 786   simgrid::simix::marshal<simix_match_func_t>(simcall->args[6], arg);
 787 }
 788 static inline simix_clean_func_t simcall_comm_isend__get__clean_fun(smx_simcall_t simcall)
 789 {
 790   return simgrid::simix::unmarshal<simix_clean_func_t>(simcall->args[7]);
 791 }
 792 static inline simix_clean_func_t simcall_comm_isend__getraw__clean_fun(smx_simcall_t simcall)
 793 {
 794   return simgrid::simix::unmarshal_raw<simix_clean_func_t>(simcall->args[7]);
 795 }
 796 static inline void simcall_comm_isend__set__clean_fun(smx_simcall_t simcall, simix_clean_func_t arg)
 797 {
 798   simgrid::simix::marshal<simix_clean_func_t>(simcall->args[7], arg);
 799 }
 800 static inline simix_copy_data_func_t simcall_comm_isend__get__copy_data_fun(smx_simcall_t simcall)
 801 {
 802   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[8]);
 803 }
 804 static inline simix_copy_data_func_t simcall_comm_isend__getraw__copy_data_fun(smx_simcall_t simcall)
 805 {
 806   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args[8]);
 807 }
 808 static inline void simcall_comm_isend__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
 809 {
 810   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[8], arg);
 811 }
 812 static inline void* simcall_comm_isend__get__data(smx_simcall_t simcall)
 813 {
 814   return simgrid::simix::unmarshal<void*>(simcall->args[9]);
 815 }
 816 static inline void* simcall_comm_isend__getraw__data(smx_simcall_t simcall)
 817 {
 818   return simgrid::simix::unmarshal_raw<void*>(simcall->args[9]);
 819 }
 820 static inline void simcall_comm_isend__set__data(smx_simcall_t simcall, void* arg)
 821 {
 822   simgrid::simix::marshal<void*>(simcall->args[9], arg);
 823 }
 824 static inline int simcall_comm_isend__get__detached(smx_simcall_t simcall)
 825 {
 826   return simgrid::simix::unmarshal<int>(simcall->args[10]);
 827 }
 828 static inline int simcall_comm_isend__getraw__detached(smx_simcall_t simcall)
 829 {
 830   return simgrid::simix::unmarshal_raw<int>(simcall->args[10]);
 831 }
 832 static inline void simcall_comm_isend__set__detached(smx_simcall_t simcall, int arg)
 833 {
 834   simgrid::simix::marshal<int>(simcall->args[10], arg);
 835 }
 836 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
 837 simcall_comm_isend__get__result(smx_simcall_t simcall)
 838 {
 839   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result);
 840 }
 841 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_isend__getraw__result(smx_simcall_t simcall)
 842 {
 843   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->result);
 844 }
 845 static inline void simcall_comm_isend__set__result(smx_simcall_t simcall,
 846                                                    boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> result)
 847 {
 848   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result, result);
 849 }
 850
 851 static inline smx_actor_t simcall_comm_recv__get__receiver(smx_simcall_t simcall)
 852 {
 853   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
 854 }
 855 static inline smx_actor_t simcall_comm_recv__getraw__receiver(smx_simcall_t simcall)
 856 {
 857   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
 858 }
 859 static inline void simcall_comm_recv__set__receiver(smx_simcall_t simcall, smx_actor_t arg)
 860 {
 861   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
 862 }
 863 static inline smx_mailbox_t simcall_comm_recv__get__mbox(smx_simcall_t simcall)
 864 {
 865   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[1]);
 866 }
 867 static inline smx_mailbox_t simcall_comm_recv__getraw__mbox(smx_simcall_t simcall)
 868 {
 869   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[1]);
 870 }
 871 static inline void simcall_comm_recv__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
 872 {
 873   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[1], arg);
 874 }
 875 static inline void* simcall_comm_recv__get__dst_buff(smx_simcall_t simcall)
 876 {
 877   return simgrid::simix::unmarshal<void*>(simcall->args[2]);
 878 }
 879 static inline void* simcall_comm_recv__getraw__dst_buff(smx_simcall_t simcall)
 880 {
 881   return simgrid::simix::unmarshal_raw<void*>(simcall->args[2]);
 882 }
 883 static inline void simcall_comm_recv__set__dst_buff(smx_simcall_t simcall, void* arg)
 884 {
 885   simgrid::simix::marshal<void*>(simcall->args[2], arg);
 886 }
 887 static inline size_t* simcall_comm_recv__get__dst_buff_size(smx_simcall_t simcall)
 888 {
 889   return simgrid::simix::unmarshal<size_t*>(simcall->args[3]);
 890 }
 891 static inline size_t* simcall_comm_recv__getraw__dst_buff_size(smx_simcall_t simcall)
 892 {
 893   return simgrid::simix::unmarshal_raw<size_t*>(simcall->args[3]);
 894 }
 895 static inline void simcall_comm_recv__set__dst_buff_size(smx_simcall_t simcall, size_t* arg)
 896 {
 897   simgrid::simix::marshal<size_t*>(simcall->args[3], arg);
 898 }
 899 static inline simix_match_func_t simcall_comm_recv__get__match_fun(smx_simcall_t simcall)
 900 {
 901   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[4]);
 902 }
 903 static inline simix_match_func_t simcall_comm_recv__getraw__match_fun(smx_simcall_t simcall)
 904 {
 905   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[4]);
 906 }
 907 static inline void simcall_comm_recv__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
 908 {
 909   simgrid::simix::marshal<simix_match_func_t>(simcall->args[4], arg);
 910 }
 911 static inline simix_copy_data_func_t simcall_comm_recv__get__copy_data_fun(smx_simcall_t simcall)
 912 {
 913   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[5]);
 914 }
 915 static inline simix_copy_data_func_t simcall_comm_recv__getraw__copy_data_fun(smx_simcall_t simcall)
 916 {
 917   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args[5]);
 918 }
 919 static inline void simcall_comm_recv__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
 920 {
 921   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[5], arg);
 922 }
 923 static inline void* simcall_comm_recv__get__data(smx_simcall_t simcall)
 924 {
 925   return simgrid::simix::unmarshal<void*>(simcall->args[6]);
 926 }
 927 static inline void* simcall_comm_recv__getraw__data(smx_simcall_t simcall)
 928 {
 929   return simgrid::simix::unmarshal_raw<void*>(simcall->args[6]);
 930 }
 931 static inline void simcall_comm_recv__set__data(smx_simcall_t simcall, void* arg)
 932 {
 933   simgrid::simix::marshal<void*>(simcall->args[6], arg);
 934 }
 935 static inline double simcall_comm_recv__get__timeout(smx_simcall_t simcall)
 936 {
 937   return simgrid::simix::unmarshal<double>(simcall->args[7]);
 938 }
 939 static inline double simcall_comm_recv__getraw__timeout(smx_simcall_t simcall)
 940 {
 941   return simgrid::simix::unmarshal_raw<double>(simcall->args[7]);
 942 }
 943 static inline void simcall_comm_recv__set__timeout(smx_simcall_t simcall, double arg)
 944 {
 945   simgrid::simix::marshal<double>(simcall->args[7], arg);
 946 }
 947 static inline double simcall_comm_recv__get__rate(smx_simcall_t simcall)
 948 {
 949   return simgrid::simix::unmarshal<double>(simcall->args[8]);
 950 }
 951 static inline double simcall_comm_recv__getraw__rate(smx_simcall_t simcall)
 952 {
 953   return simgrid::simix::unmarshal_raw<double>(simcall->args[8]);
 954 }
 955 static inline void simcall_comm_recv__set__rate(smx_simcall_t simcall, double arg)
 956 {
 957   simgrid::simix::marshal<double>(simcall->args[8], arg);
 958 }
 959
 960 static inline smx_actor_t simcall_comm_irecv__get__receiver(smx_simcall_t simcall)
 961 {
 962   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
 963 }
 964 static inline smx_actor_t simcall_comm_irecv__getraw__receiver(smx_simcall_t simcall)
 965 {
 966   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
 967 }
 968 static inline void simcall_comm_irecv__set__receiver(smx_simcall_t simcall, smx_actor_t arg)
 969 {
 970   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
 971 }
 972 static inline smx_mailbox_t simcall_comm_irecv__get__mbox(smx_simcall_t simcall)
 973 {
 974   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[1]);
 975 }
 976 static inline smx_mailbox_t simcall_comm_irecv__getraw__mbox(smx_simcall_t simcall)
 977 {
 978   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[1]);
 979 }
 980 static inline void simcall_comm_irecv__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
 981 {
 982   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[1], arg);
 983 }
 984 static inline void* simcall_comm_irecv__get__dst_buff(smx_simcall_t simcall)
 985 {
 986   return simgrid::simix::unmarshal<void*>(simcall->args[2]);
 987 }
 988 static inline void* simcall_comm_irecv__getraw__dst_buff(smx_simcall_t simcall)
 989 {
 990   return simgrid::simix::unmarshal_raw<void*>(simcall->args[2]);
 991 }
 992 static inline void simcall_comm_irecv__set__dst_buff(smx_simcall_t simcall, void* arg)
 993 {
 994   simgrid::simix::marshal<void*>(simcall->args[2], arg);
 995 }
 996 static inline size_t* simcall_comm_irecv__get__dst_buff_size(smx_simcall_t simcall)
 997 {
 998   return simgrid::simix::unmarshal<size_t*>(simcall->args[3]);
 999 }
1000 static inline size_t* simcall_comm_irecv__getraw__dst_buff_size(smx_simcall_t simcall)
1001 {
1002   return simgrid::simix::unmarshal_raw<size_t*>(simcall->args[3]);
1003 }
1004 static inline void simcall_comm_irecv__set__dst_buff_size(smx_simcall_t simcall, size_t* arg)
1005 {
1006   simgrid::simix::marshal<size_t*>(simcall->args[3], arg);
1007 }
1008 static inline simix_match_func_t simcall_comm_irecv__get__match_fun(smx_simcall_t simcall)
1009 {
1010   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[4]);
1011 }
1012 static inline simix_match_func_t simcall_comm_irecv__getraw__match_fun(smx_simcall_t simcall)
1013 {
1014   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[4]);
1015 }
1016 static inline void simcall_comm_irecv__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
1017 {
1018   simgrid::simix::marshal<simix_match_func_t>(simcall->args[4], arg);
1019 }
1020 static inline simix_copy_data_func_t simcall_comm_irecv__get__copy_data_fun(smx_simcall_t simcall)
1021 {
1022   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[5]);
1023 }
1024 static inline simix_copy_data_func_t simcall_comm_irecv__getraw__copy_data_fun(smx_simcall_t simcall)
1025 {
1026   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args[5]);
1027 }
1028 static inline void simcall_comm_irecv__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
1029 {
1030   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[5], arg);
1031 }
1032 static inline void* simcall_comm_irecv__get__data(smx_simcall_t simcall)
1033 {
1034   return simgrid::simix::unmarshal<void*>(simcall->args[6]);
1035 }
1036 static inline void* simcall_comm_irecv__getraw__data(smx_simcall_t simcall)
1037 {
1038   return simgrid::simix::unmarshal_raw<void*>(simcall->args[6]);
1039 }
1040 static inline void simcall_comm_irecv__set__data(smx_simcall_t simcall, void* arg)
1041 {
1042   simgrid::simix::marshal<void*>(simcall->args[6], arg);
1043 }
1044 static inline double simcall_comm_irecv__get__rate(smx_simcall_t simcall)
1045 {
1046   return simgrid::simix::unmarshal<double>(simcall->args[7]);
1047 }
1048 static inline double simcall_comm_irecv__getraw__rate(smx_simcall_t simcall)
1049 {
1050   return simgrid::simix::unmarshal_raw<double>(simcall->args[7]);
1051 }
1052 static inline void simcall_comm_irecv__set__rate(smx_simcall_t simcall, double arg)
1053 {
1054   simgrid::simix::marshal<double>(simcall->args[7], arg);
1055 }
1056 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
1057 simcall_comm_irecv__get__result(smx_simcall_t simcall)
1058 {
1059   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result);
1060 }
1061 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_irecv__getraw__result(smx_simcall_t simcall)
1062 {
1063   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->result);
1064 }
1065 static inline void simcall_comm_irecv__set__result(smx_simcall_t simcall,
1066                                                    boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> result)
1067 {
1068   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result, result);
1069 }
1070
1071 static inline xbt_dynar_t simcall_comm_waitany__get__comms(smx_simcall_t simcall)
1072 {
1073   return simgrid::simix::unmarshal<xbt_dynar_t>(simcall->args[0]);
1074 }
1075 static inline xbt_dynar_t simcall_comm_waitany__getraw__comms(smx_simcall_t simcall)
1076 {
1077   return simgrid::simix::unmarshal_raw<xbt_dynar_t>(simcall->args[0]);
1078 }
1079 static inline void simcall_comm_waitany__set__comms(smx_simcall_t simcall, xbt_dynar_t arg)
1080 {
1081   simgrid::simix::marshal<xbt_dynar_t>(simcall->args[0], arg);
1082 }
1083 static inline double simcall_comm_waitany__get__timeout(smx_simcall_t simcall)
1084 {
1085   return simgrid::simix::unmarshal<double>(simcall->args[1]);
1086 }
1087 static inline double simcall_comm_waitany__getraw__timeout(smx_simcall_t simcall)
1088 {
1089   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
1090 }
1091 static inline void simcall_comm_waitany__set__timeout(smx_simcall_t simcall, double arg)
1092 {
1093   simgrid::simix::marshal<double>(simcall->args[1], arg);
1094 }
1095 static inline int simcall_comm_waitany__get__result(smx_simcall_t simcall)
1096 {
1097   return simgrid::simix::unmarshal<int>(simcall->result);
1098 }
1099 static inline int simcall_comm_waitany__getraw__result(smx_simcall_t simcall)
1100 {
1101   return simgrid::simix::unmarshal_raw<int>(simcall->result);
1102 }
1103 static inline void simcall_comm_waitany__set__result(smx_simcall_t simcall, int result){
1104     simgrid::simix::marshal<int>(simcall->result, result);
1105 }
1106
1107 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
1108 simcall_comm_wait__get__comm(smx_simcall_t simcall)
1109 {
1110   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
1111 }
1112 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_wait__getraw__comm(smx_simcall_t simcall)
1113 {
1114   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
1115 }
1116 static inline void simcall_comm_wait__set__comm(smx_simcall_t simcall,
1117                                                 boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
1118 {
1119   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
1120 }
1121 static inline double simcall_comm_wait__get__timeout(smx_simcall_t simcall)
1122 {
1123   return simgrid::simix::unmarshal<double>(simcall->args[1]);
1124 }
1125 static inline double simcall_comm_wait__getraw__timeout(smx_simcall_t simcall)
1126 {
1127   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
1128 }
1129 static inline void simcall_comm_wait__set__timeout(smx_simcall_t simcall, double arg)
1130 {
1131   simgrid::simix::marshal<double>(simcall->args[1], arg);
1132 }
1133
1134 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
1135 simcall_comm_test__get__comm(smx_simcall_t simcall)
1136 {
1137   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
1138 }
1139 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_test__getraw__comm(smx_simcall_t simcall)
1140 {
1141   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
1142 }
1143 static inline void simcall_comm_test__set__comm(smx_simcall_t simcall,
1144                                                 boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
1145 {
1146   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
1147 }
1148 static inline int simcall_comm_test__get__result(smx_simcall_t simcall)
1149 {
1150   return simgrid::simix::unmarshal<int>(simcall->result);
1151 }
1152 static inline int simcall_comm_test__getraw__result(smx_simcall_t simcall)
1153 {
1154   return simgrid::simix::unmarshal_raw<int>(simcall->result);
1155 }
1156 static inline void simcall_comm_test__set__result(smx_simcall_t simcall, int result){
1157     simgrid::simix::marshal<int>(simcall->result, result);
1158 }
1159
1160 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>*
1161 simcall_comm_testany__get__comms(smx_simcall_t simcall)
1162 {
1163   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>*>(simcall->args[0]);
1164 }
1165 static inline simgrid::kernel::activity::ActivityImpl** simcall_comm_testany__getraw__comms(smx_simcall_t simcall)
1166 {
1167   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl**>(simcall->args[0]);
1168 }
1169 static inline void simcall_comm_testany__set__comms(smx_simcall_t simcall,
1170                                                     boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>* arg)
1171 {
1172   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>*>(simcall->args[0], arg);
1173 }
1174 static inline size_t simcall_comm_testany__get__count(smx_simcall_t simcall)
1175 {
1176   return simgrid::simix::unmarshal<size_t>(simcall->args[1]);
1177 }
1178 static inline size_t simcall_comm_testany__getraw__count(smx_simcall_t simcall)
1179 {
1180   return simgrid::simix::unmarshal_raw<size_t>(simcall->args[1]);
1181 }
1182 static inline void simcall_comm_testany__set__count(smx_simcall_t simcall, size_t arg)
1183 {
1184   simgrid::simix::marshal<size_t>(simcall->args[1], arg);
1185 }
1186 static inline int simcall_comm_testany__get__result(smx_simcall_t simcall)
1187 {
1188   return simgrid::simix::unmarshal<int>(simcall->result);
1189 }
1190 static inline int simcall_comm_testany__getraw__result(smx_simcall_t simcall)
1191 {
1192   return simgrid::simix::unmarshal_raw<int>(simcall->result);
1193 }
1194 static inline void simcall_comm_testany__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_init__get__result(smx_simcall_t simcall)
1199 {
1200   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->result);
1201 }
1202 static inline smx_mutex_t simcall_mutex_init__getraw__result(smx_simcall_t simcall)
1203 {
1204   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->result);
1205 }
1206 static inline void simcall_mutex_init__set__result(smx_simcall_t simcall, smx_mutex_t result){
1207     simgrid::simix::marshal<smx_mutex_t>(simcall->result, result);
1208 }
1209
1210 static inline smx_mutex_t simcall_mutex_lock__get__mutex(smx_simcall_t simcall)
1211 {
1212   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[0]);
1213 }
1214 static inline smx_mutex_t simcall_mutex_lock__getraw__mutex(smx_simcall_t simcall)
1215 {
1216   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[0]);
1217 }
1218 static inline void simcall_mutex_lock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
1219 {
1220   simgrid::simix::marshal<smx_mutex_t>(simcall->args[0], arg);
1221 }
1222
1223 static inline smx_mutex_t simcall_mutex_trylock__get__mutex(smx_simcall_t simcall)
1224 {
1225   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[0]);
1226 }
1227 static inline smx_mutex_t simcall_mutex_trylock__getraw__mutex(smx_simcall_t simcall)
1228 {
1229   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[0]);
1230 }
1231 static inline void simcall_mutex_trylock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
1232 {
1233   simgrid::simix::marshal<smx_mutex_t>(simcall->args[0], arg);
1234 }
1235 static inline int simcall_mutex_trylock__get__result(smx_simcall_t simcall)
1236 {
1237   return simgrid::simix::unmarshal<int>(simcall->result);
1238 }
1239 static inline int simcall_mutex_trylock__getraw__result(smx_simcall_t simcall)
1240 {
1241   return simgrid::simix::unmarshal_raw<int>(simcall->result);
1242 }
1243 static inline void simcall_mutex_trylock__set__result(smx_simcall_t simcall, int result){
1244     simgrid::simix::marshal<int>(simcall->result, result);
1245 }
1246
1247 static inline smx_mutex_t simcall_mutex_unlock__get__mutex(smx_simcall_t simcall)
1248 {
1249   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[0]);
1250 }
1251 static inline smx_mutex_t simcall_mutex_unlock__getraw__mutex(smx_simcall_t simcall)
1252 {
1253   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[0]);
1254 }
1255 static inline void simcall_mutex_unlock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
1256 {
1257   simgrid::simix::marshal<smx_mutex_t>(simcall->args[0], arg);
1258 }
1259
1260 static inline smx_cond_t simcall_cond_init__get__result(smx_simcall_t simcall)
1261 {
1262   return simgrid::simix::unmarshal<smx_cond_t>(simcall->result);
1263 }
1264 static inline smx_cond_t simcall_cond_init__getraw__result(smx_simcall_t simcall)
1265 {
1266   return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->result);
1267 }
1268 static inline void simcall_cond_init__set__result(smx_simcall_t simcall, smx_cond_t result){
1269     simgrid::simix::marshal<smx_cond_t>(simcall->result, result);
1270 }
1271
1272 static inline smx_cond_t simcall_cond_signal__get__cond(smx_simcall_t simcall)
1273 {
1274   return simgrid::simix::unmarshal<smx_cond_t>(simcall->args[0]);
1275 }
1276 static inline smx_cond_t simcall_cond_signal__getraw__cond(smx_simcall_t simcall)
1277 {
1278   return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->args[0]);
1279 }
1280 static inline void simcall_cond_signal__set__cond(smx_simcall_t simcall, smx_cond_t arg)
1281 {
1282   simgrid::simix::marshal<smx_cond_t>(simcall->args[0], arg);
1283 }
1284
1285 static inline smx_cond_t simcall_cond_wait__get__cond(smx_simcall_t simcall)
1286 {
1287   return simgrid::simix::unmarshal<smx_cond_t>(simcall->args[0]);
1288 }
1289 static inline smx_cond_t simcall_cond_wait__getraw__cond(smx_simcall_t simcall)
1290 {
1291   return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->args[0]);
1292 }
1293 static inline void simcall_cond_wait__set__cond(smx_simcall_t simcall, smx_cond_t arg)
1294 {
1295   simgrid::simix::marshal<smx_cond_t>(simcall->args[0], arg);
1296 }
1297 static inline smx_mutex_t simcall_cond_wait__get__mutex(smx_simcall_t simcall)
1298 {
1299   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[1]);
1300 }
1301 static inline smx_mutex_t simcall_cond_wait__getraw__mutex(smx_simcall_t simcall)
1302 {
1303   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[1]);
1304 }
1305 static inline void simcall_cond_wait__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
1306 {
1307   simgrid::simix::marshal<smx_mutex_t>(simcall->args[1], arg);
1308 }
1309
1310 static inline smx_cond_t simcall_cond_wait_timeout__get__cond(smx_simcall_t simcall)
1311 {
1312   return simgrid::simix::unmarshal<smx_cond_t>(simcall->args[0]);
1313 }
1314 static inline smx_cond_t simcall_cond_wait_timeout__getraw__cond(smx_simcall_t simcall)
1315 {
1316   return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->args[0]);
1317 }
1318 static inline void simcall_cond_wait_timeout__set__cond(smx_simcall_t simcall, smx_cond_t arg)
1319 {
1320   simgrid::simix::marshal<smx_cond_t>(simcall->args[0], arg);
1321 }
1322 static inline smx_mutex_t simcall_cond_wait_timeout__get__mutex(smx_simcall_t simcall)
1323 {
1324   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[1]);
1325 }
1326 static inline smx_mutex_t simcall_cond_wait_timeout__getraw__mutex(smx_simcall_t simcall)
1327 {
1328   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[1]);
1329 }
1330 static inline void simcall_cond_wait_timeout__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
1331 {
1332   simgrid::simix::marshal<smx_mutex_t>(simcall->args[1], arg);
1333 }
1334 static inline double simcall_cond_wait_timeout__get__timeout(smx_simcall_t simcall)
1335 {
1336   return simgrid::simix::unmarshal<double>(simcall->args[2]);
1337 }
1338 static inline double simcall_cond_wait_timeout__getraw__timeout(smx_simcall_t simcall)
1339 {
1340   return simgrid::simix::unmarshal_raw<double>(simcall->args[2]);
1341 }
1342 static inline void simcall_cond_wait_timeout__set__timeout(smx_simcall_t simcall, double arg)
1343 {
1344   simgrid::simix::marshal<double>(simcall->args[2], arg);
1345 }
1346
1347 static inline smx_cond_t simcall_cond_broadcast__get__cond(smx_simcall_t simcall)
1348 {
1349   return simgrid::simix::unmarshal<smx_cond_t>(simcall->args[0]);
1350 }
1351 static inline smx_cond_t simcall_cond_broadcast__getraw__cond(smx_simcall_t simcall)
1352 {
1353   return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->args[0]);
1354 }
1355 static inline void simcall_cond_broadcast__set__cond(smx_simcall_t simcall, smx_cond_t arg)
1356 {
1357   simgrid::simix::marshal<smx_cond_t>(simcall->args[0], arg);
1358 }
1359
1360 static inline unsigned int simcall_sem_init__get__capacity(smx_simcall_t simcall)
1361 {
1362   return simgrid::simix::unmarshal<unsigned int>(simcall->args[0]);
1363 }
1364 static inline unsigned int simcall_sem_init__getraw__capacity(smx_simcall_t simcall)
1365 {
1366   return simgrid::simix::unmarshal_raw<unsigned int>(simcall->args[0]);
1367 }
1368 static inline void simcall_sem_init__set__capacity(smx_simcall_t simcall, unsigned int arg)
1369 {
1370   simgrid::simix::marshal<unsigned int>(simcall->args[0], arg);
1371 }
1372 static inline smx_sem_t simcall_sem_init__get__result(smx_simcall_t simcall)
1373 {
1374   return simgrid::simix::unmarshal<smx_sem_t>(simcall->result);
1375 }
1376 static inline smx_sem_t simcall_sem_init__getraw__result(smx_simcall_t simcall)
1377 {
1378   return simgrid::simix::unmarshal_raw<smx_sem_t>(simcall->result);
1379 }
1380 static inline void simcall_sem_init__set__result(smx_simcall_t simcall, smx_sem_t result){
1381     simgrid::simix::marshal<smx_sem_t>(simcall->result, result);
1382 }
1383
1384 static inline smx_sem_t simcall_sem_release__get__sem(smx_simcall_t simcall)
1385 {
1386   return simgrid::simix::unmarshal<smx_sem_t>(simcall->args[0]);
1387 }
1388 static inline smx_sem_t simcall_sem_release__getraw__sem(smx_simcall_t simcall)
1389 {
1390   return simgrid::simix::unmarshal_raw<smx_sem_t>(simcall->args[0]);
1391 }
1392 static inline void simcall_sem_release__set__sem(smx_simcall_t simcall, smx_sem_t arg)
1393 {
1394   simgrid::simix::marshal<smx_sem_t>(simcall->args[0], arg);
1395 }
1396
1397 static inline smx_sem_t simcall_sem_would_block__get__sem(smx_simcall_t simcall)
1398 {
1399   return simgrid::simix::unmarshal<smx_sem_t>(simcall->args[0]);
1400 }
1401 static inline smx_sem_t simcall_sem_would_block__getraw__sem(smx_simcall_t simcall)
1402 {
1403   return simgrid::simix::unmarshal_raw<smx_sem_t>(simcall->args[0]);
1404 }
1405 static inline void simcall_sem_would_block__set__sem(smx_simcall_t simcall, smx_sem_t arg)
1406 {
1407   simgrid::simix::marshal<smx_sem_t>(simcall->args[0], arg);
1408 }
1409 static inline int simcall_sem_would_block__get__result(smx_simcall_t simcall)
1410 {
1411   return simgrid::simix::unmarshal<int>(simcall->result);
1412 }
1413 static inline int simcall_sem_would_block__getraw__result(smx_simcall_t simcall)
1414 {
1415   return simgrid::simix::unmarshal_raw<int>(simcall->result);
1416 }
1417 static inline void simcall_sem_would_block__set__result(smx_simcall_t simcall, int result){
1418     simgrid::simix::marshal<int>(simcall->result, result);
1419 }
1420
1421 static inline smx_sem_t simcall_sem_acquire__get__sem(smx_simcall_t simcall)
1422 {
1423   return simgrid::simix::unmarshal<smx_sem_t>(simcall->args[0]);
1424 }
1425 static inline smx_sem_t simcall_sem_acquire__getraw__sem(smx_simcall_t simcall)
1426 {
1427   return simgrid::simix::unmarshal_raw<smx_sem_t>(simcall->args[0]);
1428 }
1429 static inline void simcall_sem_acquire__set__sem(smx_simcall_t simcall, smx_sem_t arg)
1430 {
1431   simgrid::simix::marshal<smx_sem_t>(simcall->args[0], arg);
1432 }
1433
1434 static inline smx_sem_t simcall_sem_acquire_timeout__get__sem(smx_simcall_t simcall)
1435 {
1436   return simgrid::simix::unmarshal<smx_sem_t>(simcall->args[0]);
1437 }
1438 static inline smx_sem_t simcall_sem_acquire_timeout__getraw__sem(smx_simcall_t simcall)
1439 {
1440   return simgrid::simix::unmarshal_raw<smx_sem_t>(simcall->args[0]);
1441 }
1442 static inline void simcall_sem_acquire_timeout__set__sem(smx_simcall_t simcall, smx_sem_t arg)
1443 {
1444   simgrid::simix::marshal<smx_sem_t>(simcall->args[0], arg);
1445 }
1446 static inline double simcall_sem_acquire_timeout__get__timeout(smx_simcall_t simcall)
1447 {
1448   return simgrid::simix::unmarshal<double>(simcall->args[1]);
1449 }
1450 static inline double simcall_sem_acquire_timeout__getraw__timeout(smx_simcall_t simcall)
1451 {
1452   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
1453 }
1454 static inline void simcall_sem_acquire_timeout__set__timeout(smx_simcall_t simcall, double arg)
1455 {
1456   simgrid::simix::marshal<double>(simcall->args[1], arg);
1457 }
1458
1459 static inline smx_sem_t simcall_sem_get_capacity__get__sem(smx_simcall_t simcall)
1460 {
1461   return simgrid::simix::unmarshal<smx_sem_t>(simcall->args[0]);
1462 }
1463 static inline smx_sem_t simcall_sem_get_capacity__getraw__sem(smx_simcall_t simcall)
1464 {
1465   return simgrid::simix::unmarshal_raw<smx_sem_t>(simcall->args[0]);
1466 }
1467 static inline void simcall_sem_get_capacity__set__sem(smx_simcall_t simcall, smx_sem_t arg)
1468 {
1469   simgrid::simix::marshal<smx_sem_t>(simcall->args[0], arg);
1470 }
1471 static inline int simcall_sem_get_capacity__get__result(smx_simcall_t simcall)
1472 {
1473   return simgrid::simix::unmarshal<int>(simcall->result);
1474 }
1475 static inline int simcall_sem_get_capacity__getraw__result(smx_simcall_t simcall)
1476 {
1477   return simgrid::simix::unmarshal_raw<int>(simcall->result);
1478 }
1479 static inline void simcall_sem_get_capacity__set__result(smx_simcall_t simcall, int result){
1480     simgrid::simix::marshal<int>(simcall->result, result);
1481 }
1482
1483 static inline surf_file_t simcall_file_read__get__fd(smx_simcall_t simcall)
1484 {
1485   return simgrid::simix::unmarshal<surf_file_t>(simcall->args[0]);
1486 }
1487 static inline surf_file_t simcall_file_read__getraw__fd(smx_simcall_t simcall)
1488 {
1489   return simgrid::simix::unmarshal_raw<surf_file_t>(simcall->args[0]);
1490 }
1491 static inline void simcall_file_read__set__fd(smx_simcall_t simcall, surf_file_t arg)
1492 {
1493   simgrid::simix::marshal<surf_file_t>(simcall->args[0], arg);
1494 }
1495 static inline sg_size_t simcall_file_read__get__size(smx_simcall_t simcall)
1496 {
1497   return simgrid::simix::unmarshal<sg_size_t>(simcall->args[1]);
1498 }
1499 static inline sg_size_t simcall_file_read__getraw__size(smx_simcall_t simcall)
1500 {
1501   return simgrid::simix::unmarshal_raw<sg_size_t>(simcall->args[1]);
1502 }
1503 static inline void simcall_file_read__set__size(smx_simcall_t simcall, sg_size_t arg)
1504 {
1505   simgrid::simix::marshal<sg_size_t>(simcall->args[1], arg);
1506 }
1507 static inline sg_host_t simcall_file_read__get__host(smx_simcall_t simcall)
1508 {
1509   return simgrid::simix::unmarshal<sg_host_t>(simcall->args[2]);
1510 }
1511 static inline sg_host_t simcall_file_read__getraw__host(smx_simcall_t simcall)
1512 {
1513   return simgrid::simix::unmarshal_raw<sg_host_t>(simcall->args[2]);
1514 }
1515 static inline void simcall_file_read__set__host(smx_simcall_t simcall, sg_host_t arg)
1516 {
1517   simgrid::simix::marshal<sg_host_t>(simcall->args[2], arg);
1518 }
1519 static inline sg_size_t simcall_file_read__get__result(smx_simcall_t simcall)
1520 {
1521   return simgrid::simix::unmarshal<sg_size_t>(simcall->result);
1522 }
1523 static inline sg_size_t simcall_file_read__getraw__result(smx_simcall_t simcall)
1524 {
1525   return simgrid::simix::unmarshal_raw<sg_size_t>(simcall->result);
1526 }
1527 static inline void simcall_file_read__set__result(smx_simcall_t simcall, sg_size_t result){
1528     simgrid::simix::marshal<sg_size_t>(simcall->result, result);
1529 }
1530
1531 static inline surf_file_t simcall_file_write__get__fd(smx_simcall_t simcall)
1532 {
1533   return simgrid::simix::unmarshal<surf_file_t>(simcall->args[0]);
1534 }
1535 static inline surf_file_t simcall_file_write__getraw__fd(smx_simcall_t simcall)
1536 {
1537   return simgrid::simix::unmarshal_raw<surf_file_t>(simcall->args[0]);
1538 }
1539 static inline void simcall_file_write__set__fd(smx_simcall_t simcall, surf_file_t arg)
1540 {
1541   simgrid::simix::marshal<surf_file_t>(simcall->args[0], arg);
1542 }
1543 static inline sg_size_t simcall_file_write__get__size(smx_simcall_t simcall)
1544 {
1545   return simgrid::simix::unmarshal<sg_size_t>(simcall->args[1]);
1546 }
1547 static inline sg_size_t simcall_file_write__getraw__size(smx_simcall_t simcall)
1548 {
1549   return simgrid::simix::unmarshal_raw<sg_size_t>(simcall->args[1]);
1550 }
1551 static inline void simcall_file_write__set__size(smx_simcall_t simcall, sg_size_t arg)
1552 {
1553   simgrid::simix::marshal<sg_size_t>(simcall->args[1], arg);
1554 }
1555 static inline sg_host_t simcall_file_write__get__host(smx_simcall_t simcall)
1556 {
1557   return simgrid::simix::unmarshal<sg_host_t>(simcall->args[2]);
1558 }
1559 static inline sg_host_t simcall_file_write__getraw__host(smx_simcall_t simcall)
1560 {
1561   return simgrid::simix::unmarshal_raw<sg_host_t>(simcall->args[2]);
1562 }
1563 static inline void simcall_file_write__set__host(smx_simcall_t simcall, sg_host_t arg)
1564 {
1565   simgrid::simix::marshal<sg_host_t>(simcall->args[2], arg);
1566 }
1567 static inline sg_size_t simcall_file_write__get__result(smx_simcall_t simcall)
1568 {
1569   return simgrid::simix::unmarshal<sg_size_t>(simcall->result);
1570 }
1571 static inline sg_size_t simcall_file_write__getraw__result(smx_simcall_t simcall)
1572 {
1573   return simgrid::simix::unmarshal_raw<sg_size_t>(simcall->result);
1574 }
1575 static inline void simcall_file_write__set__result(smx_simcall_t simcall, sg_size_t result){
1576     simgrid::simix::marshal<sg_size_t>(simcall->result, result);
1577 }
1578
1579 static inline const char* simcall_file_open__get__mount(smx_simcall_t simcall)
1580 {
1581   return simgrid::simix::unmarshal<const char*>(simcall->args[0]);
1582 }
1583 static inline const char* simcall_file_open__getraw__mount(smx_simcall_t simcall)
1584 {
1585   return simgrid::simix::unmarshal_raw<const char*>(simcall->args[0]);
1586 }
1587 static inline void simcall_file_open__set__mount(smx_simcall_t simcall, const char* arg)
1588 {
1589   simgrid::simix::marshal<const char*>(simcall->args[0], arg);
1590 }
1591 static inline const char* simcall_file_open__get__path(smx_simcall_t simcall)
1592 {
1593   return simgrid::simix::unmarshal<const char*>(simcall->args[1]);
1594 }
1595 static inline const char* simcall_file_open__getraw__path(smx_simcall_t simcall)
1596 {
1597   return simgrid::simix::unmarshal_raw<const char*>(simcall->args[1]);
1598 }
1599 static inline void simcall_file_open__set__path(smx_simcall_t simcall, const char* arg)
1600 {
1601   simgrid::simix::marshal<const char*>(simcall->args[1], arg);
1602 }
1603 static inline sg_storage_t simcall_file_open__get__st(smx_simcall_t simcall)
1604 {
1605   return simgrid::simix::unmarshal<sg_storage_t>(simcall->args[2]);
1606 }
1607 static inline sg_storage_t simcall_file_open__getraw__st(smx_simcall_t simcall)
1608 {
1609   return simgrid::simix::unmarshal_raw<sg_storage_t>(simcall->args[2]);
1610 }
1611 static inline void simcall_file_open__set__st(smx_simcall_t simcall, sg_storage_t arg)
1612 {
1613   simgrid::simix::marshal<sg_storage_t>(simcall->args[2], arg);
1614 }
1615 static inline surf_file_t simcall_file_open__get__result(smx_simcall_t simcall)
1616 {
1617   return simgrid::simix::unmarshal<surf_file_t>(simcall->result);
1618 }
1619 static inline surf_file_t simcall_file_open__getraw__result(smx_simcall_t simcall)
1620 {
1621   return simgrid::simix::unmarshal_raw<surf_file_t>(simcall->result);
1622 }
1623 static inline void simcall_file_open__set__result(smx_simcall_t simcall, surf_file_t result)
1624 {
1625   simgrid::simix::marshal<surf_file_t>(simcall->result, result);
1626 }
1627
1628 static inline surf_file_t simcall_file_close__get__fd(smx_simcall_t simcall)
1629 {
1630   return simgrid::simix::unmarshal<surf_file_t>(simcall->args[0]);
1631 }
1632 static inline surf_file_t simcall_file_close__getraw__fd(smx_simcall_t simcall)
1633 {
1634   return simgrid::simix::unmarshal_raw<surf_file_t>(simcall->args[0]);
1635 }
1636 static inline void simcall_file_close__set__fd(smx_simcall_t simcall, surf_file_t arg)
1637 {
1638   simgrid::simix::marshal<surf_file_t>(simcall->args[0], arg);
1639 }
1640 static inline sg_host_t simcall_file_close__get__host(smx_simcall_t simcall)
1641 {
1642   return simgrid::simix::unmarshal<sg_host_t>(simcall->args[1]);
1643 }
1644 static inline sg_host_t simcall_file_close__getraw__host(smx_simcall_t simcall)
1645 {
1646   return simgrid::simix::unmarshal_raw<sg_host_t>(simcall->args[1]);
1647 }
1648 static inline void simcall_file_close__set__host(smx_simcall_t simcall, sg_host_t arg)
1649 {
1650   simgrid::simix::marshal<sg_host_t>(simcall->args[1], arg);
1651 }
1652 static inline int simcall_file_close__get__result(smx_simcall_t simcall)
1653 {
1654   return simgrid::simix::unmarshal<int>(simcall->result);
1655 }
1656 static inline int simcall_file_close__getraw__result(smx_simcall_t simcall)
1657 {
1658   return simgrid::simix::unmarshal_raw<int>(simcall->result);
1659 }
1660 static inline void simcall_file_close__set__result(smx_simcall_t simcall, int result){
1661     simgrid::simix::marshal<int>(simcall->result, result);
1662 }
1663
1664 static inline int simcall_mc_random__get__min(smx_simcall_t simcall)
1665 {
1666   return simgrid::simix::unmarshal<int>(simcall->args[0]);
1667 }
1668 static inline int simcall_mc_random__getraw__min(smx_simcall_t simcall)
1669 {
1670   return simgrid::simix::unmarshal_raw<int>(simcall->args[0]);
1671 }
1672 static inline void simcall_mc_random__set__min(smx_simcall_t simcall, int arg)
1673 {
1674   simgrid::simix::marshal<int>(simcall->args[0], arg);
1675 }
1676 static inline int simcall_mc_random__get__max(smx_simcall_t simcall)
1677 {
1678   return simgrid::simix::unmarshal<int>(simcall->args[1]);
1679 }
1680 static inline int simcall_mc_random__getraw__max(smx_simcall_t simcall)
1681 {
1682   return simgrid::simix::unmarshal_raw<int>(simcall->args[1]);
1683 }
1684 static inline void simcall_mc_random__set__max(smx_simcall_t simcall, int arg)
1685 {
1686   simgrid::simix::marshal<int>(simcall->args[1], arg);
1687 }
1688 static inline int simcall_mc_random__get__result(smx_simcall_t simcall)
1689 {
1690   return simgrid::simix::unmarshal<int>(simcall->result);
1691 }
1692 static inline int simcall_mc_random__getraw__result(smx_simcall_t simcall)
1693 {
1694   return simgrid::simix::unmarshal_raw<int>(simcall->result);
1695 }
1696 static inline void simcall_mc_random__set__result(smx_simcall_t simcall, int result){
1697     simgrid::simix::marshal<int>(simcall->result, result);
1698 }
1699
1700 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
1701 simcall_set_category__get__synchro(smx_simcall_t simcall)
1702 {
1703   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
1704 }
1705 static inline simgrid::kernel::activity::ActivityImpl* simcall_set_category__getraw__synchro(smx_simcall_t simcall)
1706 {
1707   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
1708 }
1709 static inline void simcall_set_category__set__synchro(smx_simcall_t simcall,
1710                                                       boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
1711 {
1712   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
1713 }
1714 static inline const char* simcall_set_category__get__category(smx_simcall_t simcall)
1715 {
1716   return simgrid::simix::unmarshal<const char*>(simcall->args[1]);
1717 }
1718 static inline const char* simcall_set_category__getraw__category(smx_simcall_t simcall)
1719 {
1720   return simgrid::simix::unmarshal_raw<const char*>(simcall->args[1]);
1721 }
1722 static inline void simcall_set_category__set__category(smx_simcall_t simcall, const char* arg)
1723 {
1724   simgrid::simix::marshal<const char*>(simcall->args[1], arg);
1725 }
1726
1727 static inline std::function<void()> const* simcall_run_kernel__get__code(smx_simcall_t simcall)
1728 {
1729   return simgrid::simix::unmarshal<std::function<void()> const*>(simcall->args[0]);
1730 }
1731 static inline std::function<void()> const* simcall_run_kernel__getraw__code(smx_simcall_t simcall)
1732 {
1733   return simgrid::simix::unmarshal_raw<std::function<void()> const*>(simcall->args[0]);
1734 }
1735 static inline void simcall_run_kernel__set__code(smx_simcall_t simcall, std::function<void()> const* arg)
1736 {
1737   simgrid::simix::marshal<std::function<void()> const*>(simcall->args[0], arg);
1738 }
1739
1740 static inline std::function<void()> const* simcall_run_blocking__get__code(smx_simcall_t simcall)
1741 {
1742   return simgrid::simix::unmarshal<std::function<void()> const*>(simcall->args[0]);
1743 }
1744 static inline std::function<void()> const* simcall_run_blocking__getraw__code(smx_simcall_t simcall)
1745 {
1746   return simgrid::simix::unmarshal_raw<std::function<void()> const*>(simcall->args[0]);
1747 }
1748 static inline void simcall_run_blocking__set__code(smx_simcall_t simcall, std::function<void()> const* arg)
1749 {
1750   simgrid::simix::marshal<std::function<void()> const*>(simcall->args[0], arg);
1751 }
1752
1753 /* The prototype of all simcall handlers, automatically generated for you */
1754
1755 XBT_PRIVATE void simcall_HANDLER_process_kill(smx_simcall_t simcall, smx_actor_t process);
1756 XBT_PRIVATE void simcall_HANDLER_process_killall(smx_simcall_t simcall, int reset_pid);
1757 XBT_PRIVATE void simcall_HANDLER_process_suspend(smx_simcall_t simcall, smx_actor_t process);
1758 XBT_PRIVATE void simcall_HANDLER_process_join(smx_simcall_t simcall, smx_actor_t process, double timeout);
1759 XBT_PRIVATE void simcall_HANDLER_process_sleep(smx_simcall_t simcall, double duration);
1760 XBT_PRIVATE boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl>
1761 simcall_HANDLER_execution_start(smx_simcall_t simcall, const char* name, double flops_amount, double priority,
1762                                 double bound);
1763 XBT_PRIVATE void
1764 simcall_HANDLER_execution_wait(smx_simcall_t simcall,
1765                                boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> execution);
1766 XBT_PRIVATE smx_actor_t simcall_HANDLER_process_restart(smx_simcall_t simcall, smx_actor_t process);
1767 XBT_PRIVATE boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
1768 simcall_HANDLER_comm_iprobe(smx_simcall_t simcall, smx_mailbox_t mbox, int type, int src, int tag,
1769                             simix_match_func_t match_fun, void* data);
1770 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);
1771 XBT_PRIVATE boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
1772 simcall_HANDLER_comm_isend(smx_simcall_t simcall, smx_actor_t sender, smx_mailbox_t mbox, double task_size, double rate,
1773                            void* src_buff, size_t src_buff_size, simix_match_func_t match_fun,
1774                            simix_clean_func_t clean_fun, simix_copy_data_func_t copy_data_fun, void* data,
1775                            int detached);
1776 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);
1777 XBT_PRIVATE boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
1778 simcall_HANDLER_comm_irecv(smx_simcall_t simcall, smx_actor_t receiver, smx_mailbox_t mbox, void* dst_buff,
1779                            size_t* dst_buff_size, simix_match_func_t match_fun, simix_copy_data_func_t copy_data_fun,
1780                            void* data, double rate);
1781 XBT_PRIVATE void simcall_HANDLER_comm_waitany(smx_simcall_t simcall, xbt_dynar_t comms, double timeout);
1782 XBT_PRIVATE void simcall_HANDLER_comm_wait(smx_simcall_t simcall,
1783                                            boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> comm,
1784                                            double timeout);
1785 XBT_PRIVATE void simcall_HANDLER_comm_test(smx_simcall_t simcall,
1786                                            boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> comm);
1787 XBT_PRIVATE void simcall_HANDLER_comm_testany(smx_simcall_t simcall,
1788                                               boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>* comms,
1789                                               size_t count);
1790 XBT_PRIVATE smx_mutex_t simcall_HANDLER_mutex_init(smx_simcall_t simcall);
1791 XBT_PRIVATE void simcall_HANDLER_mutex_lock(smx_simcall_t simcall, smx_mutex_t mutex);
1792 XBT_PRIVATE int simcall_HANDLER_mutex_trylock(smx_simcall_t simcall, smx_mutex_t mutex);
1793 XBT_PRIVATE void simcall_HANDLER_mutex_unlock(smx_simcall_t simcall, smx_mutex_t mutex);
1794 XBT_PRIVATE void simcall_HANDLER_cond_wait(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex);
1795 XBT_PRIVATE void simcall_HANDLER_cond_wait_timeout(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex, double timeout);
1796 XBT_PRIVATE void simcall_HANDLER_sem_release(smx_simcall_t simcall, smx_sem_t sem);
1797 XBT_PRIVATE int simcall_HANDLER_sem_would_block(smx_simcall_t simcall, smx_sem_t sem);
1798 XBT_PRIVATE void simcall_HANDLER_sem_acquire(smx_simcall_t simcall, smx_sem_t sem);
1799 XBT_PRIVATE void simcall_HANDLER_sem_acquire_timeout(smx_simcall_t simcall, smx_sem_t sem, double timeout);
1800 XBT_PRIVATE int simcall_HANDLER_sem_get_capacity(smx_simcall_t simcall, smx_sem_t sem);
1801 XBT_PRIVATE void simcall_HANDLER_file_read(smx_simcall_t simcall, surf_file_t fd, sg_size_t size, sg_host_t host);
1802 XBT_PRIVATE void simcall_HANDLER_file_write(smx_simcall_t simcall, surf_file_t fd, sg_size_t size, sg_host_t host);
1803 XBT_PRIVATE void simcall_HANDLER_file_open(smx_simcall_t simcall, const char* mount, const char* path, sg_storage_t st);
1804 XBT_PRIVATE void simcall_HANDLER_file_close(smx_simcall_t simcall, surf_file_t fd, sg_host_t host);
1805 XBT_PRIVATE int simcall_HANDLER_mc_random(smx_simcall_t simcall, int min, int max);