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