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