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_resume__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_resume__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_resume__set__process(smx_simcall_t simcall, smx_actor_t arg)
  79 {
  80   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
  81 }
  82
  83 static inline smx_actor_t simcall_process_set_host__get__process(smx_simcall_t simcall)
  84 {
  85   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
  86 }
  87 static inline smx_actor_t simcall_process_set_host__getraw__process(smx_simcall_t simcall)
  88 {
  89   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
  90 }
  91 static inline void simcall_process_set_host__set__process(smx_simcall_t simcall, smx_actor_t arg)
  92 {
  93   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
  94 }
  95 static inline sg_host_t simcall_process_set_host__get__dest(smx_simcall_t simcall)
  96 {
  97   return simgrid::simix::unmarshal<sg_host_t>(simcall->args[1]);
  98 }
  99 static inline sg_host_t simcall_process_set_host__getraw__dest(smx_simcall_t simcall)
 100 {
 101   return simgrid::simix::unmarshal_raw<sg_host_t>(simcall->args[1]);
 102 }
 103 static inline void simcall_process_set_host__set__dest(smx_simcall_t simcall, sg_host_t arg)
 104 {
 105   simgrid::simix::marshal<sg_host_t>(simcall->args[1], arg);
 106 }
 107
 108 static inline smx_actor_t simcall_process_is_suspended__get__process(smx_simcall_t simcall)
 109 {
 110   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
 111 }
 112 static inline smx_actor_t simcall_process_is_suspended__getraw__process(smx_simcall_t simcall)
 113 {
 114   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
 115 }
 116 static inline void simcall_process_is_suspended__set__process(smx_simcall_t simcall, smx_actor_t arg)
 117 {
 118   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
 119 }
 120 static inline int simcall_process_is_suspended__get__result(smx_simcall_t simcall)
 121 {
 122   return simgrid::simix::unmarshal<int>(simcall->result);
 123 }
 124 static inline int simcall_process_is_suspended__getraw__result(smx_simcall_t simcall)
 125 {
 126   return simgrid::simix::unmarshal_raw<int>(simcall->result);
 127 }
 128 static inline void simcall_process_is_suspended__set__result(smx_simcall_t simcall, int result){
 129     simgrid::simix::marshal<int>(simcall->result, result);
 130 }
 131
 132 static inline smx_actor_t simcall_process_join__get__process(smx_simcall_t simcall)
 133 {
 134   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
 135 }
 136 static inline smx_actor_t simcall_process_join__getraw__process(smx_simcall_t simcall)
 137 {
 138   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
 139 }
 140 static inline void simcall_process_join__set__process(smx_simcall_t simcall, smx_actor_t arg)
 141 {
 142   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
 143 }
 144 static inline double simcall_process_join__get__timeout(smx_simcall_t simcall)
 145 {
 146   return simgrid::simix::unmarshal<double>(simcall->args[1]);
 147 }
 148 static inline double simcall_process_join__getraw__timeout(smx_simcall_t simcall)
 149 {
 150   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
 151 }
 152 static inline void simcall_process_join__set__timeout(smx_simcall_t simcall, double arg)
 153 {
 154   simgrid::simix::marshal<double>(simcall->args[1], arg);
 155 }
 156 static inline int simcall_process_join__get__result(smx_simcall_t simcall)
 157 {
 158   return simgrid::simix::unmarshal<int>(simcall->result);
 159 }
 160 static inline int simcall_process_join__getraw__result(smx_simcall_t simcall)
 161 {
 162   return simgrid::simix::unmarshal_raw<int>(simcall->result);
 163 }
 164 static inline void simcall_process_join__set__result(smx_simcall_t simcall, int result){
 165     simgrid::simix::marshal<int>(simcall->result, result);
 166 }
 167
 168 static inline double simcall_process_sleep__get__duration(smx_simcall_t simcall)
 169 {
 170   return simgrid::simix::unmarshal<double>(simcall->args[0]);
 171 }
 172 static inline double simcall_process_sleep__getraw__duration(smx_simcall_t simcall)
 173 {
 174   return simgrid::simix::unmarshal_raw<double>(simcall->args[0]);
 175 }
 176 static inline void simcall_process_sleep__set__duration(smx_simcall_t simcall, double arg)
 177 {
 178   simgrid::simix::marshal<double>(simcall->args[0], arg);
 179 }
 180 static inline int simcall_process_sleep__get__result(smx_simcall_t simcall)
 181 {
 182   return simgrid::simix::unmarshal<int>(simcall->result);
 183 }
 184 static inline int simcall_process_sleep__getraw__result(smx_simcall_t simcall)
 185 {
 186   return simgrid::simix::unmarshal_raw<int>(simcall->result);
 187 }
 188 static inline void simcall_process_sleep__set__result(smx_simcall_t simcall, int result){
 189     simgrid::simix::marshal<int>(simcall->result, result);
 190 }
 191
 192 static inline const char* simcall_execution_start__get__name(smx_simcall_t simcall)
 193 {
 194   return simgrid::simix::unmarshal<const char*>(simcall->args[0]);
 195 }
 196 static inline const char* simcall_execution_start__getraw__name(smx_simcall_t simcall)
 197 {
 198   return simgrid::simix::unmarshal_raw<const char*>(simcall->args[0]);
 199 }
 200 static inline void simcall_execution_start__set__name(smx_simcall_t simcall, const char* arg)
 201 {
 202   simgrid::simix::marshal<const char*>(simcall->args[0], arg);
 203 }
 204 static inline double simcall_execution_start__get__flops_amount(smx_simcall_t simcall)
 205 {
 206   return simgrid::simix::unmarshal<double>(simcall->args[1]);
 207 }
 208 static inline double simcall_execution_start__getraw__flops_amount(smx_simcall_t simcall)
 209 {
 210   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
 211 }
 212 static inline void simcall_execution_start__set__flops_amount(smx_simcall_t simcall, double arg)
 213 {
 214   simgrid::simix::marshal<double>(simcall->args[1], arg);
 215 }
 216 static inline double simcall_execution_start__get__priority(smx_simcall_t simcall)
 217 {
 218   return simgrid::simix::unmarshal<double>(simcall->args[2]);
 219 }
 220 static inline double simcall_execution_start__getraw__priority(smx_simcall_t simcall)
 221 {
 222   return simgrid::simix::unmarshal_raw<double>(simcall->args[2]);
 223 }
 224 static inline void simcall_execution_start__set__priority(smx_simcall_t simcall, double arg)
 225 {
 226   simgrid::simix::marshal<double>(simcall->args[2], arg);
 227 }
 228 static inline double simcall_execution_start__get__bound(smx_simcall_t simcall)
 229 {
 230   return simgrid::simix::unmarshal<double>(simcall->args[3]);
 231 }
 232 static inline double simcall_execution_start__getraw__bound(smx_simcall_t simcall)
 233 {
 234   return simgrid::simix::unmarshal_raw<double>(simcall->args[3]);
 235 }
 236 static inline void simcall_execution_start__set__bound(smx_simcall_t simcall, double arg)
 237 {
 238   simgrid::simix::marshal<double>(simcall->args[3], arg);
 239 }
 240 static inline boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl>
 241 simcall_execution_start__get__result(smx_simcall_t simcall)
 242 {
 243   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl>>(simcall->result);
 244 }
 245 static inline simgrid::kernel::activity::ExecImpl* simcall_execution_start__getraw__result(smx_simcall_t simcall)
 246 {
 247   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ExecImpl*>(simcall->result);
 248 }
 249 static inline void
 250 simcall_execution_start__set__result(smx_simcall_t simcall,
 251                                      boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl> result)
 252 {
 253   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl>>(simcall->result, result);
 254 }
 255
 256 static inline const char* simcall_execution_parallel_start__get__name(smx_simcall_t simcall)
 257 {
 258   return simgrid::simix::unmarshal<const char*>(simcall->args[0]);
 259 }
 260 static inline const char* simcall_execution_parallel_start__getraw__name(smx_simcall_t simcall)
 261 {
 262   return simgrid::simix::unmarshal_raw<const char*>(simcall->args[0]);
 263 }
 264 static inline void simcall_execution_parallel_start__set__name(smx_simcall_t simcall, const char* arg)
 265 {
 266   simgrid::simix::marshal<const char*>(simcall->args[0], arg);
 267 }
 268 static inline int simcall_execution_parallel_start__get__host_nb(smx_simcall_t simcall)
 269 {
 270   return simgrid::simix::unmarshal<int>(simcall->args[1]);
 271 }
 272 static inline int simcall_execution_parallel_start__getraw__host_nb(smx_simcall_t simcall)
 273 {
 274   return simgrid::simix::unmarshal_raw<int>(simcall->args[1]);
 275 }
 276 static inline void simcall_execution_parallel_start__set__host_nb(smx_simcall_t simcall, int arg)
 277 {
 278   simgrid::simix::marshal<int>(simcall->args[1], arg);
 279 }
 280 static inline sg_host_t* simcall_execution_parallel_start__get__host_list(smx_simcall_t simcall)
 281 {
 282   return simgrid::simix::unmarshal<sg_host_t*>(simcall->args[2]);
 283 }
 284 static inline sg_host_t* simcall_execution_parallel_start__getraw__host_list(smx_simcall_t simcall)
 285 {
 286   return simgrid::simix::unmarshal_raw<sg_host_t*>(simcall->args[2]);
 287 }
 288 static inline void simcall_execution_parallel_start__set__host_list(smx_simcall_t simcall, sg_host_t* arg)
 289 {
 290   simgrid::simix::marshal<sg_host_t*>(simcall->args[2], arg);
 291 }
 292 static inline double* simcall_execution_parallel_start__get__flops_amount(smx_simcall_t simcall)
 293 {
 294   return simgrid::simix::unmarshal<double*>(simcall->args[3]);
 295 }
 296 static inline double* simcall_execution_parallel_start__getraw__flops_amount(smx_simcall_t simcall)
 297 {
 298   return simgrid::simix::unmarshal_raw<double*>(simcall->args[3]);
 299 }
 300 static inline void simcall_execution_parallel_start__set__flops_amount(smx_simcall_t simcall, double* arg)
 301 {
 302   simgrid::simix::marshal<double*>(simcall->args[3], arg);
 303 }
 304 static inline double* simcall_execution_parallel_start__get__bytes_amount(smx_simcall_t simcall)
 305 {
 306   return simgrid::simix::unmarshal<double*>(simcall->args[4]);
 307 }
 308 static inline double* simcall_execution_parallel_start__getraw__bytes_amount(smx_simcall_t simcall)
 309 {
 310   return simgrid::simix::unmarshal_raw<double*>(simcall->args[4]);
 311 }
 312 static inline void simcall_execution_parallel_start__set__bytes_amount(smx_simcall_t simcall, double* arg)
 313 {
 314   simgrid::simix::marshal<double*>(simcall->args[4], arg);
 315 }
 316 static inline double simcall_execution_parallel_start__get__amount(smx_simcall_t simcall)
 317 {
 318   return simgrid::simix::unmarshal<double>(simcall->args[5]);
 319 }
 320 static inline double simcall_execution_parallel_start__getraw__amount(smx_simcall_t simcall)
 321 {
 322   return simgrid::simix::unmarshal_raw<double>(simcall->args[5]);
 323 }
 324 static inline void simcall_execution_parallel_start__set__amount(smx_simcall_t simcall, double arg)
 325 {
 326   simgrid::simix::marshal<double>(simcall->args[5], arg);
 327 }
 328 static inline double simcall_execution_parallel_start__get__rate(smx_simcall_t simcall)
 329 {
 330   return simgrid::simix::unmarshal<double>(simcall->args[6]);
 331 }
 332 static inline double simcall_execution_parallel_start__getraw__rate(smx_simcall_t simcall)
 333 {
 334   return simgrid::simix::unmarshal_raw<double>(simcall->args[6]);
 335 }
 336 static inline void simcall_execution_parallel_start__set__rate(smx_simcall_t simcall, double arg)
 337 {
 338   simgrid::simix::marshal<double>(simcall->args[6], arg);
 339 }
 340 static inline double simcall_execution_parallel_start__get__timeout(smx_simcall_t simcall)
 341 {
 342   return simgrid::simix::unmarshal<double>(simcall->args[7]);
 343 }
 344 static inline double simcall_execution_parallel_start__getraw__timeout(smx_simcall_t simcall)
 345 {
 346   return simgrid::simix::unmarshal_raw<double>(simcall->args[7]);
 347 }
 348 static inline void simcall_execution_parallel_start__set__timeout(smx_simcall_t simcall, double arg)
 349 {
 350   simgrid::simix::marshal<double>(simcall->args[7], arg);
 351 }
 352 static inline boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl>
 353 simcall_execution_parallel_start__get__result(smx_simcall_t simcall)
 354 {
 355   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl>>(simcall->result);
 356 }
 357 static inline simgrid::kernel::activity::ExecImpl*
 358 simcall_execution_parallel_start__getraw__result(smx_simcall_t simcall)
 359 {
 360   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ExecImpl*>(simcall->result);
 361 }
 362 static inline void
 363 simcall_execution_parallel_start__set__result(smx_simcall_t simcall,
 364                                               boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl> result)
 365 {
 366   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl>>(simcall->result, result);
 367 }
 368
 369 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
 370 simcall_execution_cancel__get__execution(smx_simcall_t simcall)
 371 {
 372   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
 373 }
 374 static inline simgrid::kernel::activity::ActivityImpl*
 375 simcall_execution_cancel__getraw__execution(smx_simcall_t simcall)
 376 {
 377   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
 378 }
 379 static inline void
 380 simcall_execution_cancel__set__execution(smx_simcall_t simcall,
 381                                          boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
 382 {
 383   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
 384 }
 385
 386 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
 387 simcall_execution_set_priority__get__execution(smx_simcall_t simcall)
 388 {
 389   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
 390 }
 391 static inline simgrid::kernel::activity::ActivityImpl*
 392 simcall_execution_set_priority__getraw__execution(smx_simcall_t simcall)
 393 {
 394   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
 395 }
 396 static inline void
 397 simcall_execution_set_priority__set__execution(smx_simcall_t simcall,
 398                                                boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
 399 {
 400   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
 401 }
 402 static inline double simcall_execution_set_priority__get__priority(smx_simcall_t simcall)
 403 {
 404   return simgrid::simix::unmarshal<double>(simcall->args[1]);
 405 }
 406 static inline double simcall_execution_set_priority__getraw__priority(smx_simcall_t simcall)
 407 {
 408   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
 409 }
 410 static inline void simcall_execution_set_priority__set__priority(smx_simcall_t simcall, double arg)
 411 {
 412   simgrid::simix::marshal<double>(simcall->args[1], arg);
 413 }
 414
 415 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
 416 simcall_execution_set_bound__get__execution(smx_simcall_t simcall)
 417 {
 418   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
 419 }
 420 static inline simgrid::kernel::activity::ActivityImpl*
 421 simcall_execution_set_bound__getraw__execution(smx_simcall_t simcall)
 422 {
 423   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
 424 }
 425 static inline void
 426 simcall_execution_set_bound__set__execution(smx_simcall_t simcall,
 427                                             boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
 428 {
 429   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
 430 }
 431 static inline double simcall_execution_set_bound__get__bound(smx_simcall_t simcall)
 432 {
 433   return simgrid::simix::unmarshal<double>(simcall->args[1]);
 434 }
 435 static inline double simcall_execution_set_bound__getraw__bound(smx_simcall_t simcall)
 436 {
 437   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
 438 }
 439 static inline void simcall_execution_set_bound__set__bound(smx_simcall_t simcall, double arg)
 440 {
 441   simgrid::simix::marshal<double>(simcall->args[1], arg);
 442 }
 443
 444 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
 445 simcall_execution_wait__get__execution(smx_simcall_t simcall)
 446 {
 447   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
 448 }
 449 static inline simgrid::kernel::activity::ActivityImpl* simcall_execution_wait__getraw__execution(smx_simcall_t simcall)
 450 {
 451   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
 452 }
 453 static inline void
 454 simcall_execution_wait__set__execution(smx_simcall_t simcall,
 455                                        boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
 456 {
 457   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
 458 }
 459 static inline int simcall_execution_wait__get__result(smx_simcall_t simcall)
 460 {
 461   return simgrid::simix::unmarshal<int>(simcall->result);
 462 }
 463 static inline int simcall_execution_wait__getraw__result(smx_simcall_t simcall)
 464 {
 465   return simgrid::simix::unmarshal_raw<int>(simcall->result);
 466 }
 467 static inline void simcall_execution_wait__set__result(smx_simcall_t simcall, int result){
 468     simgrid::simix::marshal<int>(simcall->result, result);
 469 }
 470
 471 static inline smx_actor_t simcall_process_on_exit__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_on_exit__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_on_exit__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 int_f_pvoid_pvoid_t simcall_process_on_exit__get__fun(smx_simcall_t simcall)
 484 {
 485   return simgrid::simix::unmarshal<int_f_pvoid_pvoid_t>(simcall->args[1]);
 486 }
 487 static inline int_f_pvoid_pvoid_t simcall_process_on_exit__getraw__fun(smx_simcall_t simcall)
 488 {
 489   return simgrid::simix::unmarshal_raw<int_f_pvoid_pvoid_t>(simcall->args[1]);
 490 }
 491 static inline void simcall_process_on_exit__set__fun(smx_simcall_t simcall, int_f_pvoid_pvoid_t arg)
 492 {
 493   simgrid::simix::marshal<int_f_pvoid_pvoid_t>(simcall->args[1], arg);
 494 }
 495 static inline void* simcall_process_on_exit__get__data(smx_simcall_t simcall)
 496 {
 497   return simgrid::simix::unmarshal<void*>(simcall->args[2]);
 498 }
 499 static inline void* simcall_process_on_exit__getraw__data(smx_simcall_t simcall)
 500 {
 501   return simgrid::simix::unmarshal_raw<void*>(simcall->args[2]);
 502 }
 503 static inline void simcall_process_on_exit__set__data(smx_simcall_t simcall, void* arg)
 504 {
 505   simgrid::simix::marshal<void*>(simcall->args[2], arg);
 506 }
 507
 508 static inline smx_actor_t simcall_process_auto_restart_set__get__process(smx_simcall_t simcall)
 509 {
 510   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
 511 }
 512 static inline smx_actor_t simcall_process_auto_restart_set__getraw__process(smx_simcall_t simcall)
 513 {
 514   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
 515 }
 516 static inline void simcall_process_auto_restart_set__set__process(smx_simcall_t simcall, smx_actor_t arg)
 517 {
 518   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
 519 }
 520 static inline int simcall_process_auto_restart_set__get__auto_restart(smx_simcall_t simcall)
 521 {
 522   return simgrid::simix::unmarshal<int>(simcall->args[1]);
 523 }
 524 static inline int simcall_process_auto_restart_set__getraw__auto_restart(smx_simcall_t simcall)
 525 {
 526   return simgrid::simix::unmarshal_raw<int>(simcall->args[1]);
 527 }
 528 static inline void simcall_process_auto_restart_set__set__auto_restart(smx_simcall_t simcall, int arg)
 529 {
 530   simgrid::simix::marshal<int>(simcall->args[1], arg);
 531 }
 532
 533 static inline smx_actor_t simcall_process_restart__get__process(smx_simcall_t simcall)
 534 {
 535   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
 536 }
 537 static inline smx_actor_t simcall_process_restart__getraw__process(smx_simcall_t simcall)
 538 {
 539   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
 540 }
 541 static inline void simcall_process_restart__set__process(smx_simcall_t simcall, smx_actor_t arg)
 542 {
 543   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
 544 }
 545 static inline smx_actor_t simcall_process_restart__get__result(smx_simcall_t simcall)
 546 {
 547   return simgrid::simix::unmarshal<smx_actor_t>(simcall->result);
 548 }
 549 static inline smx_actor_t simcall_process_restart__getraw__result(smx_simcall_t simcall)
 550 {
 551   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->result);
 552 }
 553 static inline void simcall_process_restart__set__result(smx_simcall_t simcall, smx_actor_t result){
 554     simgrid::simix::marshal<smx_actor_t>(simcall->result, result);
 555 }
 556
 557 static inline smx_mailbox_t simcall_comm_iprobe__get__mbox(smx_simcall_t simcall)
 558 {
 559   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[0]);
 560 }
 561 static inline smx_mailbox_t simcall_comm_iprobe__getraw__mbox(smx_simcall_t simcall)
 562 {
 563   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[0]);
 564 }
 565 static inline void simcall_comm_iprobe__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
 566 {
 567   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[0], arg);
 568 }
 569 static inline int simcall_comm_iprobe__get__type(smx_simcall_t simcall)
 570 {
 571   return simgrid::simix::unmarshal<int>(simcall->args[1]);
 572 }
 573 static inline int simcall_comm_iprobe__getraw__type(smx_simcall_t simcall)
 574 {
 575   return simgrid::simix::unmarshal_raw<int>(simcall->args[1]);
 576 }
 577 static inline void simcall_comm_iprobe__set__type(smx_simcall_t simcall, int arg)
 578 {
 579   simgrid::simix::marshal<int>(simcall->args[1], arg);
 580 }
 581 static inline int simcall_comm_iprobe__get__src(smx_simcall_t simcall)
 582 {
 583   return simgrid::simix::unmarshal<int>(simcall->args[2]);
 584 }
 585 static inline int simcall_comm_iprobe__getraw__src(smx_simcall_t simcall)
 586 {
 587   return simgrid::simix::unmarshal_raw<int>(simcall->args[2]);
 588 }
 589 static inline void simcall_comm_iprobe__set__src(smx_simcall_t simcall, int arg)
 590 {
 591   simgrid::simix::marshal<int>(simcall->args[2], arg);
 592 }
 593 static inline int simcall_comm_iprobe__get__tag(smx_simcall_t simcall)
 594 {
 595   return simgrid::simix::unmarshal<int>(simcall->args[3]);
 596 }
 597 static inline int simcall_comm_iprobe__getraw__tag(smx_simcall_t simcall)
 598 {
 599   return simgrid::simix::unmarshal_raw<int>(simcall->args[3]);
 600 }
 601 static inline void simcall_comm_iprobe__set__tag(smx_simcall_t simcall, int arg)
 602 {
 603   simgrid::simix::marshal<int>(simcall->args[3], arg);
 604 }
 605 static inline simix_match_func_t simcall_comm_iprobe__get__match_fun(smx_simcall_t simcall)
 606 {
 607   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[4]);
 608 }
 609 static inline simix_match_func_t simcall_comm_iprobe__getraw__match_fun(smx_simcall_t simcall)
 610 {
 611   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[4]);
 612 }
 613 static inline void simcall_comm_iprobe__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
 614 {
 615   simgrid::simix::marshal<simix_match_func_t>(simcall->args[4], arg);
 616 }
 617 static inline void* simcall_comm_iprobe__get__data(smx_simcall_t simcall)
 618 {
 619   return simgrid::simix::unmarshal<void*>(simcall->args[5]);
 620 }
 621 static inline void* simcall_comm_iprobe__getraw__data(smx_simcall_t simcall)
 622 {
 623   return simgrid::simix::unmarshal_raw<void*>(simcall->args[5]);
 624 }
 625 static inline void simcall_comm_iprobe__set__data(smx_simcall_t simcall, void* arg)
 626 {
 627   simgrid::simix::marshal<void*>(simcall->args[5], arg);
 628 }
 629 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
 630 simcall_comm_iprobe__get__result(smx_simcall_t simcall)
 631 {
 632   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result);
 633 }
 634 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_iprobe__getraw__result(smx_simcall_t simcall)
 635 {
 636   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->result);
 637 }
 638 static inline void
 639 simcall_comm_iprobe__set__result(smx_simcall_t simcall,
 640                                  boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> result)
 641 {
 642   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result, result);
 643 }
 644
 645 static inline smx_actor_t simcall_comm_send__get__sender(smx_simcall_t simcall)
 646 {
 647   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
 648 }
 649 static inline smx_actor_t simcall_comm_send__getraw__sender(smx_simcall_t simcall)
 650 {
 651   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
 652 }
 653 static inline void simcall_comm_send__set__sender(smx_simcall_t simcall, smx_actor_t arg)
 654 {
 655   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
 656 }
 657 static inline smx_mailbox_t simcall_comm_send__get__mbox(smx_simcall_t simcall)
 658 {
 659   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[1]);
 660 }
 661 static inline smx_mailbox_t simcall_comm_send__getraw__mbox(smx_simcall_t simcall)
 662 {
 663   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[1]);
 664 }
 665 static inline void simcall_comm_send__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
 666 {
 667   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[1], arg);
 668 }
 669 static inline double simcall_comm_send__get__task_size(smx_simcall_t simcall)
 670 {
 671   return simgrid::simix::unmarshal<double>(simcall->args[2]);
 672 }
 673 static inline double simcall_comm_send__getraw__task_size(smx_simcall_t simcall)
 674 {
 675   return simgrid::simix::unmarshal_raw<double>(simcall->args[2]);
 676 }
 677 static inline void simcall_comm_send__set__task_size(smx_simcall_t simcall, double arg)
 678 {
 679   simgrid::simix::marshal<double>(simcall->args[2], arg);
 680 }
 681 static inline double simcall_comm_send__get__rate(smx_simcall_t simcall)
 682 {
 683   return simgrid::simix::unmarshal<double>(simcall->args[3]);
 684 }
 685 static inline double simcall_comm_send__getraw__rate(smx_simcall_t simcall)
 686 {
 687   return simgrid::simix::unmarshal_raw<double>(simcall->args[3]);
 688 }
 689 static inline void simcall_comm_send__set__rate(smx_simcall_t simcall, double arg)
 690 {
 691   simgrid::simix::marshal<double>(simcall->args[3], arg);
 692 }
 693 static inline void* simcall_comm_send__get__src_buff(smx_simcall_t simcall)
 694 {
 695   return simgrid::simix::unmarshal<void*>(simcall->args[4]);
 696 }
 697 static inline void* simcall_comm_send__getraw__src_buff(smx_simcall_t simcall)
 698 {
 699   return simgrid::simix::unmarshal_raw<void*>(simcall->args[4]);
 700 }
 701 static inline void simcall_comm_send__set__src_buff(smx_simcall_t simcall, void* arg)
 702 {
 703   simgrid::simix::marshal<void*>(simcall->args[4], arg);
 704 }
 705 static inline size_t simcall_comm_send__get__src_buff_size(smx_simcall_t simcall)
 706 {
 707   return simgrid::simix::unmarshal<size_t>(simcall->args[5]);
 708 }
 709 static inline size_t simcall_comm_send__getraw__src_buff_size(smx_simcall_t simcall)
 710 {
 711   return simgrid::simix::unmarshal_raw<size_t>(simcall->args[5]);
 712 }
 713 static inline void simcall_comm_send__set__src_buff_size(smx_simcall_t simcall, size_t arg)
 714 {
 715   simgrid::simix::marshal<size_t>(simcall->args[5], arg);
 716 }
 717 static inline simix_match_func_t simcall_comm_send__get__match_fun(smx_simcall_t simcall)
 718 {
 719   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[6]);
 720 }
 721 static inline simix_match_func_t simcall_comm_send__getraw__match_fun(smx_simcall_t simcall)
 722 {
 723   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[6]);
 724 }
 725 static inline void simcall_comm_send__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
 726 {
 727   simgrid::simix::marshal<simix_match_func_t>(simcall->args[6], arg);
 728 }
 729 static inline simix_copy_data_func_t simcall_comm_send__get__copy_data_fun(smx_simcall_t simcall)
 730 {
 731   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[7]);
 732 }
 733 static inline simix_copy_data_func_t simcall_comm_send__getraw__copy_data_fun(smx_simcall_t simcall)
 734 {
 735   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args[7]);
 736 }
 737 static inline void simcall_comm_send__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
 738 {
 739   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[7], arg);
 740 }
 741 static inline void* simcall_comm_send__get__data(smx_simcall_t simcall)
 742 {
 743   return simgrid::simix::unmarshal<void*>(simcall->args[8]);
 744 }
 745 static inline void* simcall_comm_send__getraw__data(smx_simcall_t simcall)
 746 {
 747   return simgrid::simix::unmarshal_raw<void*>(simcall->args[8]);
 748 }
 749 static inline void simcall_comm_send__set__data(smx_simcall_t simcall, void* arg)
 750 {
 751   simgrid::simix::marshal<void*>(simcall->args[8], arg);
 752 }
 753 static inline double simcall_comm_send__get__timeout(smx_simcall_t simcall)
 754 {
 755   return simgrid::simix::unmarshal<double>(simcall->args[9]);
 756 }
 757 static inline double simcall_comm_send__getraw__timeout(smx_simcall_t simcall)
 758 {
 759   return simgrid::simix::unmarshal_raw<double>(simcall->args[9]);
 760 }
 761 static inline void simcall_comm_send__set__timeout(smx_simcall_t simcall, double arg)
 762 {
 763   simgrid::simix::marshal<double>(simcall->args[9], arg);
 764 }
 765
 766 static inline smx_actor_t simcall_comm_isend__get__sender(smx_simcall_t simcall)
 767 {
 768   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
 769 }
 770 static inline smx_actor_t simcall_comm_isend__getraw__sender(smx_simcall_t simcall)
 771 {
 772   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
 773 }
 774 static inline void simcall_comm_isend__set__sender(smx_simcall_t simcall, smx_actor_t arg)
 775 {
 776   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
 777 }
 778 static inline smx_mailbox_t simcall_comm_isend__get__mbox(smx_simcall_t simcall)
 779 {
 780   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[1]);
 781 }
 782 static inline smx_mailbox_t simcall_comm_isend__getraw__mbox(smx_simcall_t simcall)
 783 {
 784   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[1]);
 785 }
 786 static inline void simcall_comm_isend__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
 787 {
 788   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[1], arg);
 789 }
 790 static inline double simcall_comm_isend__get__task_size(smx_simcall_t simcall)
 791 {
 792   return simgrid::simix::unmarshal<double>(simcall->args[2]);
 793 }
 794 static inline double simcall_comm_isend__getraw__task_size(smx_simcall_t simcall)
 795 {
 796   return simgrid::simix::unmarshal_raw<double>(simcall->args[2]);
 797 }
 798 static inline void simcall_comm_isend__set__task_size(smx_simcall_t simcall, double arg)
 799 {
 800   simgrid::simix::marshal<double>(simcall->args[2], arg);
 801 }
 802 static inline double simcall_comm_isend__get__rate(smx_simcall_t simcall)
 803 {
 804   return simgrid::simix::unmarshal<double>(simcall->args[3]);
 805 }
 806 static inline double simcall_comm_isend__getraw__rate(smx_simcall_t simcall)
 807 {
 808   return simgrid::simix::unmarshal_raw<double>(simcall->args[3]);
 809 }
 810 static inline void simcall_comm_isend__set__rate(smx_simcall_t simcall, double arg)
 811 {
 812   simgrid::simix::marshal<double>(simcall->args[3], arg);
 813 }
 814 static inline void* simcall_comm_isend__get__src_buff(smx_simcall_t simcall)
 815 {
 816   return simgrid::simix::unmarshal<void*>(simcall->args[4]);
 817 }
 818 static inline void* simcall_comm_isend__getraw__src_buff(smx_simcall_t simcall)
 819 {
 820   return simgrid::simix::unmarshal_raw<void*>(simcall->args[4]);
 821 }
 822 static inline void simcall_comm_isend__set__src_buff(smx_simcall_t simcall, void* arg)
 823 {
 824   simgrid::simix::marshal<void*>(simcall->args[4], arg);
 825 }
 826 static inline size_t simcall_comm_isend__get__src_buff_size(smx_simcall_t simcall)
 827 {
 828   return simgrid::simix::unmarshal<size_t>(simcall->args[5]);
 829 }
 830 static inline size_t simcall_comm_isend__getraw__src_buff_size(smx_simcall_t simcall)
 831 {
 832   return simgrid::simix::unmarshal_raw<size_t>(simcall->args[5]);
 833 }
 834 static inline void simcall_comm_isend__set__src_buff_size(smx_simcall_t simcall, size_t arg)
 835 {
 836   simgrid::simix::marshal<size_t>(simcall->args[5], arg);
 837 }
 838 static inline simix_match_func_t simcall_comm_isend__get__match_fun(smx_simcall_t simcall)
 839 {
 840   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[6]);
 841 }
 842 static inline simix_match_func_t simcall_comm_isend__getraw__match_fun(smx_simcall_t simcall)
 843 {
 844   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[6]);
 845 }
 846 static inline void simcall_comm_isend__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
 847 {
 848   simgrid::simix::marshal<simix_match_func_t>(simcall->args[6], arg);
 849 }
 850 static inline simix_clean_func_t simcall_comm_isend__get__clean_fun(smx_simcall_t simcall)
 851 {
 852   return simgrid::simix::unmarshal<simix_clean_func_t>(simcall->args[7]);
 853 }
 854 static inline simix_clean_func_t simcall_comm_isend__getraw__clean_fun(smx_simcall_t simcall)
 855 {
 856   return simgrid::simix::unmarshal_raw<simix_clean_func_t>(simcall->args[7]);
 857 }
 858 static inline void simcall_comm_isend__set__clean_fun(smx_simcall_t simcall, simix_clean_func_t arg)
 859 {
 860   simgrid::simix::marshal<simix_clean_func_t>(simcall->args[7], arg);
 861 }
 862 static inline simix_copy_data_func_t simcall_comm_isend__get__copy_data_fun(smx_simcall_t simcall)
 863 {
 864   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[8]);
 865 }
 866 static inline simix_copy_data_func_t simcall_comm_isend__getraw__copy_data_fun(smx_simcall_t simcall)
 867 {
 868   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args[8]);
 869 }
 870 static inline void simcall_comm_isend__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
 871 {
 872   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[8], arg);
 873 }
 874 static inline void* simcall_comm_isend__get__data(smx_simcall_t simcall)
 875 {
 876   return simgrid::simix::unmarshal<void*>(simcall->args[9]);
 877 }
 878 static inline void* simcall_comm_isend__getraw__data(smx_simcall_t simcall)
 879 {
 880   return simgrid::simix::unmarshal_raw<void*>(simcall->args[9]);
 881 }
 882 static inline void simcall_comm_isend__set__data(smx_simcall_t simcall, void* arg)
 883 {
 884   simgrid::simix::marshal<void*>(simcall->args[9], arg);
 885 }
 886 static inline int simcall_comm_isend__get__detached(smx_simcall_t simcall)
 887 {
 888   return simgrid::simix::unmarshal<int>(simcall->args[10]);
 889 }
 890 static inline int simcall_comm_isend__getraw__detached(smx_simcall_t simcall)
 891 {
 892   return simgrid::simix::unmarshal_raw<int>(simcall->args[10]);
 893 }
 894 static inline void simcall_comm_isend__set__detached(smx_simcall_t simcall, int arg)
 895 {
 896   simgrid::simix::marshal<int>(simcall->args[10], arg);
 897 }
 898 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
 899 simcall_comm_isend__get__result(smx_simcall_t simcall)
 900 {
 901   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result);
 902 }
 903 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_isend__getraw__result(smx_simcall_t simcall)
 904 {
 905   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->result);
 906 }
 907 static inline void simcall_comm_isend__set__result(smx_simcall_t simcall,
 908                                                    boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> result)
 909 {
 910   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result, result);
 911 }
 912
 913 static inline smx_actor_t simcall_comm_recv__get__receiver(smx_simcall_t simcall)
 914 {
 915   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
 916 }
 917 static inline smx_actor_t simcall_comm_recv__getraw__receiver(smx_simcall_t simcall)
 918 {
 919   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
 920 }
 921 static inline void simcall_comm_recv__set__receiver(smx_simcall_t simcall, smx_actor_t arg)
 922 {
 923   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
 924 }
 925 static inline smx_mailbox_t simcall_comm_recv__get__mbox(smx_simcall_t simcall)
 926 {
 927   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[1]);
 928 }
 929 static inline smx_mailbox_t simcall_comm_recv__getraw__mbox(smx_simcall_t simcall)
 930 {
 931   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[1]);
 932 }
 933 static inline void simcall_comm_recv__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
 934 {
 935   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[1], arg);
 936 }
 937 static inline void* simcall_comm_recv__get__dst_buff(smx_simcall_t simcall)
 938 {
 939   return simgrid::simix::unmarshal<void*>(simcall->args[2]);
 940 }
 941 static inline void* simcall_comm_recv__getraw__dst_buff(smx_simcall_t simcall)
 942 {
 943   return simgrid::simix::unmarshal_raw<void*>(simcall->args[2]);
 944 }
 945 static inline void simcall_comm_recv__set__dst_buff(smx_simcall_t simcall, void* arg)
 946 {
 947   simgrid::simix::marshal<void*>(simcall->args[2], arg);
 948 }
 949 static inline size_t* simcall_comm_recv__get__dst_buff_size(smx_simcall_t simcall)
 950 {
 951   return simgrid::simix::unmarshal<size_t*>(simcall->args[3]);
 952 }
 953 static inline size_t* simcall_comm_recv__getraw__dst_buff_size(smx_simcall_t simcall)
 954 {
 955   return simgrid::simix::unmarshal_raw<size_t*>(simcall->args[3]);
 956 }
 957 static inline void simcall_comm_recv__set__dst_buff_size(smx_simcall_t simcall, size_t* arg)
 958 {
 959   simgrid::simix::marshal<size_t*>(simcall->args[3], arg);
 960 }
 961 static inline simix_match_func_t simcall_comm_recv__get__match_fun(smx_simcall_t simcall)
 962 {
 963   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[4]);
 964 }
 965 static inline simix_match_func_t simcall_comm_recv__getraw__match_fun(smx_simcall_t simcall)
 966 {
 967   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[4]);
 968 }
 969 static inline void simcall_comm_recv__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
 970 {
 971   simgrid::simix::marshal<simix_match_func_t>(simcall->args[4], arg);
 972 }
 973 static inline simix_copy_data_func_t simcall_comm_recv__get__copy_data_fun(smx_simcall_t simcall)
 974 {
 975   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[5]);
 976 }
 977 static inline simix_copy_data_func_t simcall_comm_recv__getraw__copy_data_fun(smx_simcall_t simcall)
 978 {
 979   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args[5]);
 980 }
 981 static inline void simcall_comm_recv__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
 982 {
 983   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[5], arg);
 984 }
 985 static inline void* simcall_comm_recv__get__data(smx_simcall_t simcall)
 986 {
 987   return simgrid::simix::unmarshal<void*>(simcall->args[6]);
 988 }
 989 static inline void* simcall_comm_recv__getraw__data(smx_simcall_t simcall)
 990 {
 991   return simgrid::simix::unmarshal_raw<void*>(simcall->args[6]);
 992 }
 993 static inline void simcall_comm_recv__set__data(smx_simcall_t simcall, void* arg)
 994 {
 995   simgrid::simix::marshal<void*>(simcall->args[6], arg);
 996 }
 997 static inline double simcall_comm_recv__get__timeout(smx_simcall_t simcall)
 998 {
 999   return simgrid::simix::unmarshal<double>(simcall->args[7]);
1000 }
1001 static inline double simcall_comm_recv__getraw__timeout(smx_simcall_t simcall)
1002 {
1003   return simgrid::simix::unmarshal_raw<double>(simcall->args[7]);
1004 }
1005 static inline void simcall_comm_recv__set__timeout(smx_simcall_t simcall, double arg)
1006 {
1007   simgrid::simix::marshal<double>(simcall->args[7], arg);
1008 }
1009 static inline double simcall_comm_recv__get__rate(smx_simcall_t simcall)
1010 {
1011   return simgrid::simix::unmarshal<double>(simcall->args[8]);
1012 }
1013 static inline double simcall_comm_recv__getraw__rate(smx_simcall_t simcall)
1014 {
1015   return simgrid::simix::unmarshal_raw<double>(simcall->args[8]);
1016 }
1017 static inline void simcall_comm_recv__set__rate(smx_simcall_t simcall, double arg)
1018 {
1019   simgrid::simix::marshal<double>(simcall->args[8], arg);
1020 }
1021
1022 static inline smx_actor_t simcall_comm_irecv__get__receiver(smx_simcall_t simcall)
1023 {
1024   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
1025 }
1026 static inline smx_actor_t simcall_comm_irecv__getraw__receiver(smx_simcall_t simcall)
1027 {
1028   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
1029 }
1030 static inline void simcall_comm_irecv__set__receiver(smx_simcall_t simcall, smx_actor_t arg)
1031 {
1032   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
1033 }
1034 static inline smx_mailbox_t simcall_comm_irecv__get__mbox(smx_simcall_t simcall)
1035 {
1036   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[1]);
1037 }
1038 static inline smx_mailbox_t simcall_comm_irecv__getraw__mbox(smx_simcall_t simcall)
1039 {
1040   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[1]);
1041 }
1042 static inline void simcall_comm_irecv__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
1043 {
1044   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[1], arg);
1045 }
1046 static inline void* simcall_comm_irecv__get__dst_buff(smx_simcall_t simcall)
1047 {
1048   return simgrid::simix::unmarshal<void*>(simcall->args[2]);
1049 }
1050 static inline void* simcall_comm_irecv__getraw__dst_buff(smx_simcall_t simcall)
1051 {
1052   return simgrid::simix::unmarshal_raw<void*>(simcall->args[2]);
1053 }
1054 static inline void simcall_comm_irecv__set__dst_buff(smx_simcall_t simcall, void* arg)
1055 {
1056   simgrid::simix::marshal<void*>(simcall->args[2], arg);
1057 }
1058 static inline size_t* simcall_comm_irecv__get__dst_buff_size(smx_simcall_t simcall)
1059 {
1060   return simgrid::simix::unmarshal<size_t*>(simcall->args[3]);
1061 }
1062 static inline size_t* simcall_comm_irecv__getraw__dst_buff_size(smx_simcall_t simcall)
1063 {
1064   return simgrid::simix::unmarshal_raw<size_t*>(simcall->args[3]);
1065 }
1066 static inline void simcall_comm_irecv__set__dst_buff_size(smx_simcall_t simcall, size_t* arg)
1067 {
1068   simgrid::simix::marshal<size_t*>(simcall->args[3], arg);
1069 }
1070 static inline simix_match_func_t simcall_comm_irecv__get__match_fun(smx_simcall_t simcall)
1071 {
1072   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[4]);
1073 }
1074 static inline simix_match_func_t simcall_comm_irecv__getraw__match_fun(smx_simcall_t simcall)
1075 {
1076   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[4]);
1077 }
1078 static inline void simcall_comm_irecv__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
1079 {
1080   simgrid::simix::marshal<simix_match_func_t>(simcall->args[4], arg);
1081 }
1082 static inline simix_copy_data_func_t simcall_comm_irecv__get__copy_data_fun(smx_simcall_t simcall)
1083 {
1084   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[5]);
1085 }
1086 static inline simix_copy_data_func_t simcall_comm_irecv__getraw__copy_data_fun(smx_simcall_t simcall)
1087 {
1088   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args[5]);
1089 }
1090 static inline void simcall_comm_irecv__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
1091 {
1092   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[5], arg);
1093 }
1094 static inline void* simcall_comm_irecv__get__data(smx_simcall_t simcall)
1095 {
1096   return simgrid::simix::unmarshal<void*>(simcall->args[6]);
1097 }
1098 static inline void* simcall_comm_irecv__getraw__data(smx_simcall_t simcall)
1099 {
1100   return simgrid::simix::unmarshal_raw<void*>(simcall->args[6]);
1101 }
1102 static inline void simcall_comm_irecv__set__data(smx_simcall_t simcall, void* arg)
1103 {
1104   simgrid::simix::marshal<void*>(simcall->args[6], arg);
1105 }
1106 static inline double simcall_comm_irecv__get__rate(smx_simcall_t simcall)
1107 {
1108   return simgrid::simix::unmarshal<double>(simcall->args[7]);
1109 }
1110 static inline double simcall_comm_irecv__getraw__rate(smx_simcall_t simcall)
1111 {
1112   return simgrid::simix::unmarshal_raw<double>(simcall->args[7]);
1113 }
1114 static inline void simcall_comm_irecv__set__rate(smx_simcall_t simcall, double arg)
1115 {
1116   simgrid::simix::marshal<double>(simcall->args[7], arg);
1117 }
1118 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
1119 simcall_comm_irecv__get__result(smx_simcall_t simcall)
1120 {
1121   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result);
1122 }
1123 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_irecv__getraw__result(smx_simcall_t simcall)
1124 {
1125   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->result);
1126 }
1127 static inline void simcall_comm_irecv__set__result(smx_simcall_t simcall,
1128                                                    boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> result)
1129 {
1130   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result, result);
1131 }
1132
1133 static inline xbt_dynar_t simcall_comm_waitany__get__comms(smx_simcall_t simcall)
1134 {
1135   return simgrid::simix::unmarshal<xbt_dynar_t>(simcall->args[0]);
1136 }
1137 static inline xbt_dynar_t simcall_comm_waitany__getraw__comms(smx_simcall_t simcall)
1138 {
1139   return simgrid::simix::unmarshal_raw<xbt_dynar_t>(simcall->args[0]);
1140 }
1141 static inline void simcall_comm_waitany__set__comms(smx_simcall_t simcall, xbt_dynar_t arg)
1142 {
1143   simgrid::simix::marshal<xbt_dynar_t>(simcall->args[0], arg);
1144 }
1145 static inline double simcall_comm_waitany__get__timeout(smx_simcall_t simcall)
1146 {
1147   return simgrid::simix::unmarshal<double>(simcall->args[1]);
1148 }
1149 static inline double simcall_comm_waitany__getraw__timeout(smx_simcall_t simcall)
1150 {
1151   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
1152 }
1153 static inline void simcall_comm_waitany__set__timeout(smx_simcall_t simcall, double arg)
1154 {
1155   simgrid::simix::marshal<double>(simcall->args[1], arg);
1156 }
1157 static inline int simcall_comm_waitany__get__result(smx_simcall_t simcall)
1158 {
1159   return simgrid::simix::unmarshal<int>(simcall->result);
1160 }
1161 static inline int simcall_comm_waitany__getraw__result(smx_simcall_t simcall)
1162 {
1163   return simgrid::simix::unmarshal_raw<int>(simcall->result);
1164 }
1165 static inline void simcall_comm_waitany__set__result(smx_simcall_t simcall, int result){
1166     simgrid::simix::marshal<int>(simcall->result, result);
1167 }
1168
1169 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
1170 simcall_comm_wait__get__comm(smx_simcall_t simcall)
1171 {
1172   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
1173 }
1174 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_wait__getraw__comm(smx_simcall_t simcall)
1175 {
1176   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
1177 }
1178 static inline void simcall_comm_wait__set__comm(smx_simcall_t simcall,
1179                                                 boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
1180 {
1181   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
1182 }
1183 static inline double simcall_comm_wait__get__timeout(smx_simcall_t simcall)
1184 {
1185   return simgrid::simix::unmarshal<double>(simcall->args[1]);
1186 }
1187 static inline double simcall_comm_wait__getraw__timeout(smx_simcall_t simcall)
1188 {
1189   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
1190 }
1191 static inline void simcall_comm_wait__set__timeout(smx_simcall_t simcall, double arg)
1192 {
1193   simgrid::simix::marshal<double>(simcall->args[1], arg);
1194 }
1195
1196 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
1197 simcall_comm_test__get__comm(smx_simcall_t simcall)
1198 {
1199   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
1200 }
1201 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_test__getraw__comm(smx_simcall_t simcall)
1202 {
1203   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
1204 }
1205 static inline void simcall_comm_test__set__comm(smx_simcall_t simcall,
1206                                                 boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
1207 {
1208   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
1209 }
1210 static inline int simcall_comm_test__get__result(smx_simcall_t simcall)
1211 {
1212   return simgrid::simix::unmarshal<int>(simcall->result);
1213 }
1214 static inline int simcall_comm_test__getraw__result(smx_simcall_t simcall)
1215 {
1216   return simgrid::simix::unmarshal_raw<int>(simcall->result);
1217 }
1218 static inline void simcall_comm_test__set__result(smx_simcall_t simcall, int result){
1219     simgrid::simix::marshal<int>(simcall->result, result);
1220 }
1221
1222 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>*
1223 simcall_comm_testany__get__comms(smx_simcall_t simcall)
1224 {
1225   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>*>(simcall->args[0]);
1226 }
1227 static inline simgrid::kernel::activity::ActivityImpl** simcall_comm_testany__getraw__comms(smx_simcall_t simcall)
1228 {
1229   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl**>(simcall->args[0]);
1230 }
1231 static inline void simcall_comm_testany__set__comms(smx_simcall_t simcall,
1232                                                     boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>* arg)
1233 {
1234   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>*>(simcall->args[0], arg);
1235 }
1236 static inline size_t simcall_comm_testany__get__count(smx_simcall_t simcall)
1237 {
1238   return simgrid::simix::unmarshal<size_t>(simcall->args[1]);
1239 }
1240 static inline size_t simcall_comm_testany__getraw__count(smx_simcall_t simcall)
1241 {
1242   return simgrid::simix::unmarshal_raw<size_t>(simcall->args[1]);
1243 }
1244 static inline void simcall_comm_testany__set__count(smx_simcall_t simcall, size_t arg)
1245 {
1246   simgrid::simix::marshal<size_t>(simcall->args[1], arg);
1247 }
1248 static inline int simcall_comm_testany__get__result(smx_simcall_t simcall)
1249 {
1250   return simgrid::simix::unmarshal<int>(simcall->result);
1251 }
1252 static inline int simcall_comm_testany__getraw__result(smx_simcall_t simcall)
1253 {
1254   return simgrid::simix::unmarshal_raw<int>(simcall->result);
1255 }
1256 static inline void simcall_comm_testany__set__result(smx_simcall_t simcall, int result){
1257     simgrid::simix::marshal<int>(simcall->result, result);
1258 }
1259
1260 static inline smx_mutex_t simcall_mutex_init__get__result(smx_simcall_t simcall)
1261 {
1262   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->result);
1263 }
1264 static inline smx_mutex_t simcall_mutex_init__getraw__result(smx_simcall_t simcall)
1265 {
1266   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->result);
1267 }
1268 static inline void simcall_mutex_init__set__result(smx_simcall_t simcall, smx_mutex_t result){
1269     simgrid::simix::marshal<smx_mutex_t>(simcall->result, result);
1270 }
1271
1272 static inline smx_mutex_t simcall_mutex_lock__get__mutex(smx_simcall_t simcall)
1273 {
1274   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[0]);
1275 }
1276 static inline smx_mutex_t simcall_mutex_lock__getraw__mutex(smx_simcall_t simcall)
1277 {
1278   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[0]);
1279 }
1280 static inline void simcall_mutex_lock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
1281 {
1282   simgrid::simix::marshal<smx_mutex_t>(simcall->args[0], arg);
1283 }
1284
1285 static inline smx_mutex_t simcall_mutex_trylock__get__mutex(smx_simcall_t simcall)
1286 {
1287   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[0]);
1288 }
1289 static inline smx_mutex_t simcall_mutex_trylock__getraw__mutex(smx_simcall_t simcall)
1290 {
1291   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[0]);
1292 }
1293 static inline void simcall_mutex_trylock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
1294 {
1295   simgrid::simix::marshal<smx_mutex_t>(simcall->args[0], arg);
1296 }
1297 static inline int simcall_mutex_trylock__get__result(smx_simcall_t simcall)
1298 {
1299   return simgrid::simix::unmarshal<int>(simcall->result);
1300 }
1301 static inline int simcall_mutex_trylock__getraw__result(smx_simcall_t simcall)
1302 {
1303   return simgrid::simix::unmarshal_raw<int>(simcall->result);
1304 }
1305 static inline void simcall_mutex_trylock__set__result(smx_simcall_t simcall, int result){
1306     simgrid::simix::marshal<int>(simcall->result, result);
1307 }
1308
1309 static inline smx_mutex_t simcall_mutex_unlock__get__mutex(smx_simcall_t simcall)
1310 {
1311   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[0]);
1312 }
1313 static inline smx_mutex_t simcall_mutex_unlock__getraw__mutex(smx_simcall_t simcall)
1314 {
1315   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[0]);
1316 }
1317 static inline void simcall_mutex_unlock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
1318 {
1319   simgrid::simix::marshal<smx_mutex_t>(simcall->args[0], arg);
1320 }
1321
1322 static inline smx_cond_t simcall_cond_init__get__result(smx_simcall_t simcall)
1323 {
1324   return simgrid::simix::unmarshal<smx_cond_t>(simcall->result);
1325 }
1326 static inline smx_cond_t simcall_cond_init__getraw__result(smx_simcall_t simcall)
1327 {
1328   return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->result);
1329 }
1330 static inline void simcall_cond_init__set__result(smx_simcall_t simcall, smx_cond_t result){
1331     simgrid::simix::marshal<smx_cond_t>(simcall->result, result);
1332 }
1333
1334 static inline smx_cond_t simcall_cond_signal__get__cond(smx_simcall_t simcall)
1335 {
1336   return simgrid::simix::unmarshal<smx_cond_t>(simcall->args[0]);
1337 }
1338 static inline smx_cond_t simcall_cond_signal__getraw__cond(smx_simcall_t simcall)
1339 {
1340   return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->args[0]);
1341 }
1342 static inline void simcall_cond_signal__set__cond(smx_simcall_t simcall, smx_cond_t arg)
1343 {
1344   simgrid::simix::marshal<smx_cond_t>(simcall->args[0], arg);
1345 }
1346
1347 static inline smx_cond_t simcall_cond_wait__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_wait__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_wait__set__cond(smx_simcall_t simcall, smx_cond_t arg)
1356 {
1357   simgrid::simix::marshal<smx_cond_t>(simcall->args[0], arg);
1358 }
1359 static inline smx_mutex_t simcall_cond_wait__get__mutex(smx_simcall_t simcall)
1360 {
1361   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[1]);
1362 }
1363 static inline smx_mutex_t simcall_cond_wait__getraw__mutex(smx_simcall_t simcall)
1364 {
1365   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[1]);
1366 }
1367 static inline void simcall_cond_wait__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
1368 {
1369   simgrid::simix::marshal<smx_mutex_t>(simcall->args[1], arg);
1370 }
1371
1372 static inline smx_cond_t simcall_cond_wait_timeout__get__cond(smx_simcall_t simcall)
1373 {
1374   return simgrid::simix::unmarshal<smx_cond_t>(simcall->args[0]);
1375 }
1376 static inline smx_cond_t simcall_cond_wait_timeout__getraw__cond(smx_simcall_t simcall)
1377 {
1378   return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->args[0]);
1379 }
1380 static inline void simcall_cond_wait_timeout__set__cond(smx_simcall_t simcall, smx_cond_t arg)
1381 {
1382   simgrid::simix::marshal<smx_cond_t>(simcall->args[0], arg);
1383 }
1384 static inline smx_mutex_t simcall_cond_wait_timeout__get__mutex(smx_simcall_t simcall)
1385 {
1386   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[1]);
1387 }
1388 static inline smx_mutex_t simcall_cond_wait_timeout__getraw__mutex(smx_simcall_t simcall)
1389 {
1390   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[1]);
1391 }
1392 static inline void simcall_cond_wait_timeout__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
1393 {
1394   simgrid::simix::marshal<smx_mutex_t>(simcall->args[1], arg);
1395 }
1396 static inline double simcall_cond_wait_timeout__get__timeout(smx_simcall_t simcall)
1397 {
1398   return simgrid::simix::unmarshal<double>(simcall->args[2]);
1399 }
1400 static inline double simcall_cond_wait_timeout__getraw__timeout(smx_simcall_t simcall)
1401 {
1402   return simgrid::simix::unmarshal_raw<double>(simcall->args[2]);
1403 }
1404 static inline void simcall_cond_wait_timeout__set__timeout(smx_simcall_t simcall, double arg)
1405 {
1406   simgrid::simix::marshal<double>(simcall->args[2], arg);
1407 }
1408
1409 static inline smx_cond_t simcall_cond_broadcast__get__cond(smx_simcall_t simcall)
1410 {
1411   return simgrid::simix::unmarshal<smx_cond_t>(simcall->args[0]);
1412 }
1413 static inline smx_cond_t simcall_cond_broadcast__getraw__cond(smx_simcall_t simcall)
1414 {
1415   return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->args[0]);
1416 }
1417 static inline void simcall_cond_broadcast__set__cond(smx_simcall_t simcall, smx_cond_t arg)
1418 {
1419   simgrid::simix::marshal<smx_cond_t>(simcall->args[0], arg);
1420 }
1421
1422 static inline unsigned int simcall_sem_init__get__capacity(smx_simcall_t simcall)
1423 {
1424   return simgrid::simix::unmarshal<unsigned int>(simcall->args[0]);
1425 }
1426 static inline unsigned int simcall_sem_init__getraw__capacity(smx_simcall_t simcall)
1427 {
1428   return simgrid::simix::unmarshal_raw<unsigned int>(simcall->args[0]);
1429 }
1430 static inline void simcall_sem_init__set__capacity(smx_simcall_t simcall, unsigned int arg)
1431 {
1432   simgrid::simix::marshal<unsigned int>(simcall->args[0], arg);
1433 }
1434 static inline smx_sem_t simcall_sem_init__get__result(smx_simcall_t simcall)
1435 {
1436   return simgrid::simix::unmarshal<smx_sem_t>(simcall->result);
1437 }
1438 static inline smx_sem_t simcall_sem_init__getraw__result(smx_simcall_t simcall)
1439 {
1440   return simgrid::simix::unmarshal_raw<smx_sem_t>(simcall->result);
1441 }
1442 static inline void simcall_sem_init__set__result(smx_simcall_t simcall, smx_sem_t result){
1443     simgrid::simix::marshal<smx_sem_t>(simcall->result, result);
1444 }
1445
1446 static inline smx_sem_t simcall_sem_release__get__sem(smx_simcall_t simcall)
1447 {
1448   return simgrid::simix::unmarshal<smx_sem_t>(simcall->args[0]);
1449 }
1450 static inline smx_sem_t simcall_sem_release__getraw__sem(smx_simcall_t simcall)
1451 {
1452   return simgrid::simix::unmarshal_raw<smx_sem_t>(simcall->args[0]);
1453 }
1454 static inline void simcall_sem_release__set__sem(smx_simcall_t simcall, smx_sem_t arg)
1455 {
1456   simgrid::simix::marshal<smx_sem_t>(simcall->args[0], arg);
1457 }
1458
1459 static inline smx_sem_t simcall_sem_would_block__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_would_block__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_would_block__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_would_block__get__result(smx_simcall_t simcall)
1472 {
1473   return simgrid::simix::unmarshal<int>(simcall->result);
1474 }
1475 static inline int simcall_sem_would_block__getraw__result(smx_simcall_t simcall)
1476 {
1477   return simgrid::simix::unmarshal_raw<int>(simcall->result);
1478 }
1479 static inline void simcall_sem_would_block__set__result(smx_simcall_t simcall, int result){
1480     simgrid::simix::marshal<int>(simcall->result, result);
1481 }
1482
1483 static inline smx_sem_t simcall_sem_acquire__get__sem(smx_simcall_t simcall)
1484 {
1485   return simgrid::simix::unmarshal<smx_sem_t>(simcall->args[0]);
1486 }
1487 static inline smx_sem_t simcall_sem_acquire__getraw__sem(smx_simcall_t simcall)
1488 {
1489   return simgrid::simix::unmarshal_raw<smx_sem_t>(simcall->args[0]);
1490 }
1491 static inline void simcall_sem_acquire__set__sem(smx_simcall_t simcall, smx_sem_t arg)
1492 {
1493   simgrid::simix::marshal<smx_sem_t>(simcall->args[0], arg);
1494 }
1495
1496 static inline smx_sem_t simcall_sem_acquire_timeout__get__sem(smx_simcall_t simcall)
1497 {
1498   return simgrid::simix::unmarshal<smx_sem_t>(simcall->args[0]);
1499 }
1500 static inline smx_sem_t simcall_sem_acquire_timeout__getraw__sem(smx_simcall_t simcall)
1501 {
1502   return simgrid::simix::unmarshal_raw<smx_sem_t>(simcall->args[0]);
1503 }
1504 static inline void simcall_sem_acquire_timeout__set__sem(smx_simcall_t simcall, smx_sem_t arg)
1505 {
1506   simgrid::simix::marshal<smx_sem_t>(simcall->args[0], arg);
1507 }
1508 static inline double simcall_sem_acquire_timeout__get__timeout(smx_simcall_t simcall)
1509 {
1510   return simgrid::simix::unmarshal<double>(simcall->args[1]);
1511 }
1512 static inline double simcall_sem_acquire_timeout__getraw__timeout(smx_simcall_t simcall)
1513 {
1514   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
1515 }
1516 static inline void simcall_sem_acquire_timeout__set__timeout(smx_simcall_t simcall, double arg)
1517 {
1518   simgrid::simix::marshal<double>(simcall->args[1], arg);
1519 }
1520
1521 static inline smx_sem_t simcall_sem_get_capacity__get__sem(smx_simcall_t simcall)
1522 {
1523   return simgrid::simix::unmarshal<smx_sem_t>(simcall->args[0]);
1524 }
1525 static inline smx_sem_t simcall_sem_get_capacity__getraw__sem(smx_simcall_t simcall)
1526 {
1527   return simgrid::simix::unmarshal_raw<smx_sem_t>(simcall->args[0]);
1528 }
1529 static inline void simcall_sem_get_capacity__set__sem(smx_simcall_t simcall, smx_sem_t arg)
1530 {
1531   simgrid::simix::marshal<smx_sem_t>(simcall->args[0], arg);
1532 }
1533 static inline int simcall_sem_get_capacity__get__result(smx_simcall_t simcall)
1534 {
1535   return simgrid::simix::unmarshal<int>(simcall->result);
1536 }
1537 static inline int simcall_sem_get_capacity__getraw__result(smx_simcall_t simcall)
1538 {
1539   return simgrid::simix::unmarshal_raw<int>(simcall->result);
1540 }
1541 static inline void simcall_sem_get_capacity__set__result(smx_simcall_t simcall, int result){
1542     simgrid::simix::marshal<int>(simcall->result, result);
1543 }
1544
1545 static inline surf_file_t simcall_file_read__get__fd(smx_simcall_t simcall)
1546 {
1547   return simgrid::simix::unmarshal<surf_file_t>(simcall->args[0]);
1548 }
1549 static inline surf_file_t simcall_file_read__getraw__fd(smx_simcall_t simcall)
1550 {
1551   return simgrid::simix::unmarshal_raw<surf_file_t>(simcall->args[0]);
1552 }
1553 static inline void simcall_file_read__set__fd(smx_simcall_t simcall, surf_file_t arg)
1554 {
1555   simgrid::simix::marshal<surf_file_t>(simcall->args[0], arg);
1556 }
1557 static inline sg_size_t simcall_file_read__get__size(smx_simcall_t simcall)
1558 {
1559   return simgrid::simix::unmarshal<sg_size_t>(simcall->args[1]);
1560 }
1561 static inline sg_size_t simcall_file_read__getraw__size(smx_simcall_t simcall)
1562 {
1563   return simgrid::simix::unmarshal_raw<sg_size_t>(simcall->args[1]);
1564 }
1565 static inline void simcall_file_read__set__size(smx_simcall_t simcall, sg_size_t arg)
1566 {
1567   simgrid::simix::marshal<sg_size_t>(simcall->args[1], arg);
1568 }
1569 static inline sg_host_t simcall_file_read__get__host(smx_simcall_t simcall)
1570 {
1571   return simgrid::simix::unmarshal<sg_host_t>(simcall->args[2]);
1572 }
1573 static inline sg_host_t simcall_file_read__getraw__host(smx_simcall_t simcall)
1574 {
1575   return simgrid::simix::unmarshal_raw<sg_host_t>(simcall->args[2]);
1576 }
1577 static inline void simcall_file_read__set__host(smx_simcall_t simcall, sg_host_t arg)
1578 {
1579   simgrid::simix::marshal<sg_host_t>(simcall->args[2], arg);
1580 }
1581 static inline sg_size_t simcall_file_read__get__result(smx_simcall_t simcall)
1582 {
1583   return simgrid::simix::unmarshal<sg_size_t>(simcall->result);
1584 }
1585 static inline sg_size_t simcall_file_read__getraw__result(smx_simcall_t simcall)
1586 {
1587   return simgrid::simix::unmarshal_raw<sg_size_t>(simcall->result);
1588 }
1589 static inline void simcall_file_read__set__result(smx_simcall_t simcall, sg_size_t result){
1590     simgrid::simix::marshal<sg_size_t>(simcall->result, result);
1591 }
1592
1593 static inline surf_file_t simcall_file_write__get__fd(smx_simcall_t simcall)
1594 {
1595   return simgrid::simix::unmarshal<surf_file_t>(simcall->args[0]);
1596 }
1597 static inline surf_file_t simcall_file_write__getraw__fd(smx_simcall_t simcall)
1598 {
1599   return simgrid::simix::unmarshal_raw<surf_file_t>(simcall->args[0]);
1600 }
1601 static inline void simcall_file_write__set__fd(smx_simcall_t simcall, surf_file_t arg)
1602 {
1603   simgrid::simix::marshal<surf_file_t>(simcall->args[0], arg);
1604 }
1605 static inline sg_size_t simcall_file_write__get__size(smx_simcall_t simcall)
1606 {
1607   return simgrid::simix::unmarshal<sg_size_t>(simcall->args[1]);
1608 }
1609 static inline sg_size_t simcall_file_write__getraw__size(smx_simcall_t simcall)
1610 {
1611   return simgrid::simix::unmarshal_raw<sg_size_t>(simcall->args[1]);
1612 }
1613 static inline void simcall_file_write__set__size(smx_simcall_t simcall, sg_size_t arg)
1614 {
1615   simgrid::simix::marshal<sg_size_t>(simcall->args[1], arg);
1616 }
1617 static inline sg_host_t simcall_file_write__get__host(smx_simcall_t simcall)
1618 {
1619   return simgrid::simix::unmarshal<sg_host_t>(simcall->args[2]);
1620 }
1621 static inline sg_host_t simcall_file_write__getraw__host(smx_simcall_t simcall)
1622 {
1623   return simgrid::simix::unmarshal_raw<sg_host_t>(simcall->args[2]);
1624 }
1625 static inline void simcall_file_write__set__host(smx_simcall_t simcall, sg_host_t arg)
1626 {
1627   simgrid::simix::marshal<sg_host_t>(simcall->args[2], arg);
1628 }
1629 static inline sg_size_t simcall_file_write__get__result(smx_simcall_t simcall)
1630 {
1631   return simgrid::simix::unmarshal<sg_size_t>(simcall->result);
1632 }
1633 static inline sg_size_t simcall_file_write__getraw__result(smx_simcall_t simcall)
1634 {
1635   return simgrid::simix::unmarshal_raw<sg_size_t>(simcall->result);
1636 }
1637 static inline void simcall_file_write__set__result(smx_simcall_t simcall, sg_size_t result){
1638     simgrid::simix::marshal<sg_size_t>(simcall->result, result);
1639 }
1640
1641 static inline const char* simcall_file_open__get__mount(smx_simcall_t simcall)
1642 {
1643   return simgrid::simix::unmarshal<const char*>(simcall->args[0]);
1644 }
1645 static inline const char* simcall_file_open__getraw__mount(smx_simcall_t simcall)
1646 {
1647   return simgrid::simix::unmarshal_raw<const char*>(simcall->args[0]);
1648 }
1649 static inline void simcall_file_open__set__mount(smx_simcall_t simcall, const char* arg)
1650 {
1651   simgrid::simix::marshal<const char*>(simcall->args[0], arg);
1652 }
1653 static inline const char* simcall_file_open__get__path(smx_simcall_t simcall)
1654 {
1655   return simgrid::simix::unmarshal<const char*>(simcall->args[1]);
1656 }
1657 static inline const char* simcall_file_open__getraw__path(smx_simcall_t simcall)
1658 {
1659   return simgrid::simix::unmarshal_raw<const char*>(simcall->args[1]);
1660 }
1661 static inline void simcall_file_open__set__path(smx_simcall_t simcall, const char* arg)
1662 {
1663   simgrid::simix::marshal<const char*>(simcall->args[1], arg);
1664 }
1665 static inline sg_storage_t simcall_file_open__get__st(smx_simcall_t simcall)
1666 {
1667   return simgrid::simix::unmarshal<sg_storage_t>(simcall->args[2]);
1668 }
1669 static inline sg_storage_t simcall_file_open__getraw__st(smx_simcall_t simcall)
1670 {
1671   return simgrid::simix::unmarshal_raw<sg_storage_t>(simcall->args[2]);
1672 }
1673 static inline void simcall_file_open__set__st(smx_simcall_t simcall, sg_storage_t arg)
1674 {
1675   simgrid::simix::marshal<sg_storage_t>(simcall->args[2], arg);
1676 }
1677 static inline surf_file_t simcall_file_open__get__result(smx_simcall_t simcall)
1678 {
1679   return simgrid::simix::unmarshal<surf_file_t>(simcall->result);
1680 }
1681 static inline surf_file_t simcall_file_open__getraw__result(smx_simcall_t simcall)
1682 {
1683   return simgrid::simix::unmarshal_raw<surf_file_t>(simcall->result);
1684 }
1685 static inline void simcall_file_open__set__result(smx_simcall_t simcall, surf_file_t result)
1686 {
1687   simgrid::simix::marshal<surf_file_t>(simcall->result, result);
1688 }
1689
1690 static inline surf_file_t simcall_file_close__get__fd(smx_simcall_t simcall)
1691 {
1692   return simgrid::simix::unmarshal<surf_file_t>(simcall->args[0]);
1693 }
1694 static inline surf_file_t simcall_file_close__getraw__fd(smx_simcall_t simcall)
1695 {
1696   return simgrid::simix::unmarshal_raw<surf_file_t>(simcall->args[0]);
1697 }
1698 static inline void simcall_file_close__set__fd(smx_simcall_t simcall, surf_file_t arg)
1699 {
1700   simgrid::simix::marshal<surf_file_t>(simcall->args[0], arg);
1701 }
1702 static inline sg_host_t simcall_file_close__get__host(smx_simcall_t simcall)
1703 {
1704   return simgrid::simix::unmarshal<sg_host_t>(simcall->args[1]);
1705 }
1706 static inline sg_host_t simcall_file_close__getraw__host(smx_simcall_t simcall)
1707 {
1708   return simgrid::simix::unmarshal_raw<sg_host_t>(simcall->args[1]);
1709 }
1710 static inline void simcall_file_close__set__host(smx_simcall_t simcall, sg_host_t arg)
1711 {
1712   simgrid::simix::marshal<sg_host_t>(simcall->args[1], arg);
1713 }
1714 static inline int simcall_file_close__get__result(smx_simcall_t simcall)
1715 {
1716   return simgrid::simix::unmarshal<int>(simcall->result);
1717 }
1718 static inline int simcall_file_close__getraw__result(smx_simcall_t simcall)
1719 {
1720   return simgrid::simix::unmarshal_raw<int>(simcall->result);
1721 }
1722 static inline void simcall_file_close__set__result(smx_simcall_t simcall, int result){
1723     simgrid::simix::marshal<int>(simcall->result, result);
1724 }
1725
1726 static inline surf_file_t simcall_file_move__get__fd(smx_simcall_t simcall)
1727 {
1728   return simgrid::simix::unmarshal<surf_file_t>(simcall->args[0]);
1729 }
1730 static inline surf_file_t simcall_file_move__getraw__fd(smx_simcall_t simcall)
1731 {
1732   return simgrid::simix::unmarshal_raw<surf_file_t>(simcall->args[0]);
1733 }
1734 static inline void simcall_file_move__set__fd(smx_simcall_t simcall, surf_file_t arg)
1735 {
1736   simgrid::simix::marshal<surf_file_t>(simcall->args[0], arg);
1737 }
1738 static inline const char* simcall_file_move__get__fullpath(smx_simcall_t simcall)
1739 {
1740   return simgrid::simix::unmarshal<const char*>(simcall->args[1]);
1741 }
1742 static inline const char* simcall_file_move__getraw__fullpath(smx_simcall_t simcall)
1743 {
1744   return simgrid::simix::unmarshal_raw<const char*>(simcall->args[1]);
1745 }
1746 static inline void simcall_file_move__set__fullpath(smx_simcall_t simcall, const char* arg)
1747 {
1748   simgrid::simix::marshal<const char*>(simcall->args[1], arg);
1749 }
1750 static inline int simcall_file_move__get__result(smx_simcall_t simcall)
1751 {
1752   return simgrid::simix::unmarshal<int>(simcall->result);
1753 }
1754 static inline int simcall_file_move__getraw__result(smx_simcall_t simcall)
1755 {
1756   return simgrid::simix::unmarshal_raw<int>(simcall->result);
1757 }
1758 static inline void simcall_file_move__set__result(smx_simcall_t simcall, int result){
1759     simgrid::simix::marshal<int>(simcall->result, result);
1760 }
1761
1762 static inline int simcall_mc_random__get__min(smx_simcall_t simcall)
1763 {
1764   return simgrid::simix::unmarshal<int>(simcall->args[0]);
1765 }
1766 static inline int simcall_mc_random__getraw__min(smx_simcall_t simcall)
1767 {
1768   return simgrid::simix::unmarshal_raw<int>(simcall->args[0]);
1769 }
1770 static inline void simcall_mc_random__set__min(smx_simcall_t simcall, int arg)
1771 {
1772   simgrid::simix::marshal<int>(simcall->args[0], arg);
1773 }
1774 static inline int simcall_mc_random__get__max(smx_simcall_t simcall)
1775 {
1776   return simgrid::simix::unmarshal<int>(simcall->args[1]);
1777 }
1778 static inline int simcall_mc_random__getraw__max(smx_simcall_t simcall)
1779 {
1780   return simgrid::simix::unmarshal_raw<int>(simcall->args[1]);
1781 }
1782 static inline void simcall_mc_random__set__max(smx_simcall_t simcall, int arg)
1783 {
1784   simgrid::simix::marshal<int>(simcall->args[1], arg);
1785 }
1786 static inline int simcall_mc_random__get__result(smx_simcall_t simcall)
1787 {
1788   return simgrid::simix::unmarshal<int>(simcall->result);
1789 }
1790 static inline int simcall_mc_random__getraw__result(smx_simcall_t simcall)
1791 {
1792   return simgrid::simix::unmarshal_raw<int>(simcall->result);
1793 }
1794 static inline void simcall_mc_random__set__result(smx_simcall_t simcall, int result){
1795     simgrid::simix::marshal<int>(simcall->result, result);
1796 }
1797
1798 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
1799 simcall_set_category__get__synchro(smx_simcall_t simcall)
1800 {
1801   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
1802 }
1803 static inline simgrid::kernel::activity::ActivityImpl* simcall_set_category__getraw__synchro(smx_simcall_t simcall)
1804 {
1805   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
1806 }
1807 static inline void simcall_set_category__set__synchro(smx_simcall_t simcall,
1808                                                       boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
1809 {
1810   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
1811 }
1812 static inline const char* simcall_set_category__get__category(smx_simcall_t simcall)
1813 {
1814   return simgrid::simix::unmarshal<const char*>(simcall->args[1]);
1815 }
1816 static inline const char* simcall_set_category__getraw__category(smx_simcall_t simcall)
1817 {
1818   return simgrid::simix::unmarshal_raw<const char*>(simcall->args[1]);
1819 }
1820 static inline void simcall_set_category__set__category(smx_simcall_t simcall, const char* arg)
1821 {
1822   simgrid::simix::marshal<const char*>(simcall->args[1], arg);
1823 }
1824
1825 static inline std::function<void()> const* simcall_run_kernel__get__code(smx_simcall_t simcall)
1826 {
1827   return simgrid::simix::unmarshal<std::function<void()> const*>(simcall->args[0]);
1828 }
1829 static inline std::function<void()> const* simcall_run_kernel__getraw__code(smx_simcall_t simcall)
1830 {
1831   return simgrid::simix::unmarshal_raw<std::function<void()> const*>(simcall->args[0]);
1832 }
1833 static inline void simcall_run_kernel__set__code(smx_simcall_t simcall, std::function<void()> const* arg)
1834 {
1835   simgrid::simix::marshal<std::function<void()> const*>(simcall->args[0], arg);
1836 }
1837
1838 static inline std::function<void()> const* simcall_run_blocking__get__code(smx_simcall_t simcall)
1839 {
1840   return simgrid::simix::unmarshal<std::function<void()> const*>(simcall->args[0]);
1841 }
1842 static inline std::function<void()> const* simcall_run_blocking__getraw__code(smx_simcall_t simcall)
1843 {
1844   return simgrid::simix::unmarshal_raw<std::function<void()> const*>(simcall->args[0]);
1845 }
1846 static inline void simcall_run_blocking__set__code(smx_simcall_t simcall, std::function<void()> const* arg)
1847 {
1848   simgrid::simix::marshal<std::function<void()> const*>(simcall->args[0], arg);
1849 }
1850
1851 /* The prototype of all simcall handlers, automatically generated for you */
1852
1853 XBT_PRIVATE void simcall_HANDLER_process_kill(smx_simcall_t simcall, smx_actor_t process);
1854 XBT_PRIVATE void simcall_HANDLER_process_killall(smx_simcall_t simcall, int reset_pid);
1855 XBT_PRIVATE void simcall_HANDLER_process_suspend(smx_simcall_t simcall, smx_actor_t process);
1856 XBT_PRIVATE void simcall_HANDLER_process_set_host(smx_simcall_t simcall, smx_actor_t process, sg_host_t dest);
1857 XBT_PRIVATE void simcall_HANDLER_process_join(smx_simcall_t simcall, smx_actor_t process, double timeout);
1858 XBT_PRIVATE void simcall_HANDLER_process_sleep(smx_simcall_t simcall, double duration);
1859 XBT_PRIVATE boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl>
1860 simcall_HANDLER_execution_start(smx_simcall_t simcall, const char* name, double flops_amount, double priority,
1861                                 double bound);
1862 XBT_PRIVATE void
1863 simcall_HANDLER_execution_wait(smx_simcall_t simcall,
1864                                boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> execution);
1865 XBT_PRIVATE smx_actor_t simcall_HANDLER_process_restart(smx_simcall_t simcall, smx_actor_t process);
1866 XBT_PRIVATE boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
1867 simcall_HANDLER_comm_iprobe(smx_simcall_t simcall, smx_mailbox_t mbox, int type, int src, int tag,
1868                             simix_match_func_t match_fun, void* data);
1869 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);
1870 XBT_PRIVATE boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
1871 simcall_HANDLER_comm_isend(smx_simcall_t simcall, smx_actor_t sender, smx_mailbox_t mbox, double task_size, double rate,
1872                            void* src_buff, size_t src_buff_size, simix_match_func_t match_fun,
1873                            simix_clean_func_t clean_fun, simix_copy_data_func_t copy_data_fun, void* data,
1874                            int detached);
1875 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);
1876 XBT_PRIVATE boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
1877 simcall_HANDLER_comm_irecv(smx_simcall_t simcall, smx_actor_t receiver, smx_mailbox_t mbox, void* dst_buff,
1878                            size_t* dst_buff_size, simix_match_func_t match_fun, simix_copy_data_func_t copy_data_fun,
1879                            void* data, double rate);
1880 XBT_PRIVATE void simcall_HANDLER_comm_waitany(smx_simcall_t simcall, xbt_dynar_t comms, double timeout);
1881 XBT_PRIVATE void simcall_HANDLER_comm_wait(smx_simcall_t simcall,
1882                                            boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> comm,
1883                                            double timeout);
1884 XBT_PRIVATE void simcall_HANDLER_comm_test(smx_simcall_t simcall,
1885                                            boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> comm);
1886 XBT_PRIVATE void simcall_HANDLER_comm_testany(smx_simcall_t simcall,
1887                                               boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>* comms,
1888                                               size_t count);
1889 XBT_PRIVATE smx_mutex_t simcall_HANDLER_mutex_init(smx_simcall_t simcall);
1890 XBT_PRIVATE void simcall_HANDLER_mutex_lock(smx_simcall_t simcall, smx_mutex_t mutex);
1891 XBT_PRIVATE int simcall_HANDLER_mutex_trylock(smx_simcall_t simcall, smx_mutex_t mutex);
1892 XBT_PRIVATE void simcall_HANDLER_mutex_unlock(smx_simcall_t simcall, smx_mutex_t mutex);
1893 XBT_PRIVATE void simcall_HANDLER_cond_wait(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex);
1894 XBT_PRIVATE void simcall_HANDLER_cond_wait_timeout(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex, double timeout);
1895 XBT_PRIVATE void simcall_HANDLER_sem_release(smx_simcall_t simcall, smx_sem_t sem);
1896 XBT_PRIVATE int simcall_HANDLER_sem_would_block(smx_simcall_t simcall, smx_sem_t sem);
1897 XBT_PRIVATE void simcall_HANDLER_sem_acquire(smx_simcall_t simcall, smx_sem_t sem);
1898 XBT_PRIVATE void simcall_HANDLER_sem_acquire_timeout(smx_simcall_t simcall, smx_sem_t sem, double timeout);
1899 XBT_PRIVATE int simcall_HANDLER_sem_get_capacity(smx_simcall_t simcall, smx_sem_t sem);
1900 XBT_PRIVATE void simcall_HANDLER_file_read(smx_simcall_t simcall, surf_file_t fd, sg_size_t size, sg_host_t host);
1901 XBT_PRIVATE void simcall_HANDLER_file_write(smx_simcall_t simcall, surf_file_t fd, sg_size_t size, sg_host_t host);
1902 XBT_PRIVATE void simcall_HANDLER_file_open(smx_simcall_t simcall, const char* mount, const char* path, sg_storage_t st);
1903 XBT_PRIVATE void simcall_HANDLER_file_close(smx_simcall_t simcall, surf_file_t fd, sg_host_t host);
1904 XBT_PRIVATE int simcall_HANDLER_file_move(smx_simcall_t simcall, surf_file_t fd, const char* fullpath);
1905 XBT_PRIVATE int simcall_HANDLER_mc_random(smx_simcall_t simcall, int min, int max);