src/simix/popping_accessors.hpp

   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-2018. 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.hpp"
  18 static inline smx_actor_t simcall_process_suspend__get__process(smx_simcall_t simcall)
  19 {
  20   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
  21 }
  22 static inline smx_actor_t simcall_process_suspend__getraw__process(smx_simcall_t simcall)
  23 {
  24   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
  25 }
  26 static inline void simcall_process_suspend__set__process(smx_simcall_t simcall, smx_actor_t arg)
  27 {
  28   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
  29 }
  30
  31 static inline smx_actor_t simcall_process_join__get__process(smx_simcall_t simcall)
  32 {
  33   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
  34 }
  35 static inline smx_actor_t simcall_process_join__getraw__process(smx_simcall_t simcall)
  36 {
  37   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
  38 }
  39 static inline void simcall_process_join__set__process(smx_simcall_t simcall, smx_actor_t arg)
  40 {
  41   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
  42 }
  43 static inline double simcall_process_join__get__timeout(smx_simcall_t simcall)
  44 {
  45   return simgrid::simix::unmarshal<double>(simcall->args[1]);
  46 }
  47 static inline double simcall_process_join__getraw__timeout(smx_simcall_t simcall)
  48 {
  49   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
  50 }
  51 static inline void simcall_process_join__set__timeout(smx_simcall_t simcall, double arg)
  52 {
  53   simgrid::simix::marshal<double>(simcall->args[1], arg);
  54 }
  55 static inline int simcall_process_join__get__result(smx_simcall_t simcall)
  56 {
  57   return simgrid::simix::unmarshal<int>(simcall->result);
  58 }
  59 static inline int simcall_process_join__getraw__result(smx_simcall_t simcall)
  60 {
  61   return simgrid::simix::unmarshal_raw<int>(simcall->result);
  62 }
  63 static inline void simcall_process_join__set__result(smx_simcall_t simcall, int result)
  64 {
  65   simgrid::simix::marshal<int>(simcall->result, result);
  66 }
  67
  68 static inline double simcall_process_sleep__get__duration(smx_simcall_t simcall)
  69 {
  70   return simgrid::simix::unmarshal<double>(simcall->args[0]);
  71 }
  72 static inline double simcall_process_sleep__getraw__duration(smx_simcall_t simcall)
  73 {
  74   return simgrid::simix::unmarshal_raw<double>(simcall->args[0]);
  75 }
  76 static inline void simcall_process_sleep__set__duration(smx_simcall_t simcall, double arg)
  77 {
  78   simgrid::simix::marshal<double>(simcall->args[0], arg);
  79 }
  80 static inline int simcall_process_sleep__get__result(smx_simcall_t simcall)
  81 {
  82   return simgrid::simix::unmarshal<int>(simcall->result);
  83 }
  84 static inline int simcall_process_sleep__getraw__result(smx_simcall_t simcall)
  85 {
  86   return simgrid::simix::unmarshal_raw<int>(simcall->result);
  87 }
  88 static inline void simcall_process_sleep__set__result(smx_simcall_t simcall, int result)
  89 {
  90   simgrid::simix::marshal<int>(simcall->result, result);
  91 }
  92
  93 static inline const char* simcall_execution_start__get__name(smx_simcall_t simcall)
  94 {
  95   return simgrid::simix::unmarshal<const char*>(simcall->args[0]);
  96 }
  97 static inline const char* simcall_execution_start__getraw__name(smx_simcall_t simcall)
  98 {
  99   return simgrid::simix::unmarshal_raw<const char*>(simcall->args[0]);
 100 }
 101 static inline void simcall_execution_start__set__name(smx_simcall_t simcall, const char* arg)
 102 {
 103   simgrid::simix::marshal<const char*>(simcall->args[0], arg);
 104 }
 105 static inline double simcall_execution_start__get__flops_amount(smx_simcall_t simcall)
 106 {
 107   return simgrid::simix::unmarshal<double>(simcall->args[1]);
 108 }
 109 static inline double simcall_execution_start__getraw__flops_amount(smx_simcall_t simcall)
 110 {
 111   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
 112 }
 113 static inline void simcall_execution_start__set__flops_amount(smx_simcall_t simcall, double arg)
 114 {
 115   simgrid::simix::marshal<double>(simcall->args[1], arg);
 116 }
 117 static inline double simcall_execution_start__get__priority(smx_simcall_t simcall)
 118 {
 119   return simgrid::simix::unmarshal<double>(simcall->args[2]);
 120 }
 121 static inline double simcall_execution_start__getraw__priority(smx_simcall_t simcall)
 122 {
 123   return simgrid::simix::unmarshal_raw<double>(simcall->args[2]);
 124 }
 125 static inline void simcall_execution_start__set__priority(smx_simcall_t simcall, double arg)
 126 {
 127   simgrid::simix::marshal<double>(simcall->args[2], arg);
 128 }
 129 static inline double simcall_execution_start__get__bound(smx_simcall_t simcall)
 130 {
 131   return simgrid::simix::unmarshal<double>(simcall->args[3]);
 132 }
 133 static inline double simcall_execution_start__getraw__bound(smx_simcall_t simcall)
 134 {
 135   return simgrid::simix::unmarshal_raw<double>(simcall->args[3]);
 136 }
 137 static inline void simcall_execution_start__set__bound(smx_simcall_t simcall, double arg)
 138 {
 139   simgrid::simix::marshal<double>(simcall->args[3], arg);
 140 }
 141 static inline sg_host_t simcall_execution_start__get__host(smx_simcall_t simcall)
 142 {
 143   return simgrid::simix::unmarshal<sg_host_t>(simcall->args[4]);
 144 }
 145 static inline sg_host_t simcall_execution_start__getraw__host(smx_simcall_t simcall)
 146 {
 147   return simgrid::simix::unmarshal_raw<sg_host_t>(simcall->args[4]);
 148 }
 149 static inline void simcall_execution_start__set__host(smx_simcall_t simcall, sg_host_t arg)
 150 {
 151   simgrid::simix::marshal<sg_host_t>(simcall->args[4], arg);
 152 }
 153 static inline boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl> simcall_execution_start__get__result(smx_simcall_t simcall)
 154 {
 155   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl>>(simcall->result);
 156 }
 157 static inline simgrid::kernel::activity::ExecImpl* simcall_execution_start__getraw__result(smx_simcall_t simcall)
 158 {
 159   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ExecImpl*>(simcall->result);
 160 }
 161 static inline void simcall_execution_start__set__result(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl> result)
 162 {
 163   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl>>(simcall->result, result);
 164 }
 165
 166 static inline const char* simcall_execution_parallel_start__get__name(smx_simcall_t simcall)
 167 {
 168   return simgrid::simix::unmarshal<const char*>(simcall->args[0]);
 169 }
 170 static inline const char* simcall_execution_parallel_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_parallel_start__set__name(smx_simcall_t simcall, const char* arg)
 175 {
 176   simgrid::simix::marshal<const char*>(simcall->args[0], arg);
 177 }
 178 static inline int simcall_execution_parallel_start__get__host_nb(smx_simcall_t simcall)
 179 {
 180   return simgrid::simix::unmarshal<int>(simcall->args[1]);
 181 }
 182 static inline int simcall_execution_parallel_start__getraw__host_nb(smx_simcall_t simcall)
 183 {
 184   return simgrid::simix::unmarshal_raw<int>(simcall->args[1]);
 185 }
 186 static inline void simcall_execution_parallel_start__set__host_nb(smx_simcall_t simcall, int arg)
 187 {
 188   simgrid::simix::marshal<int>(simcall->args[1], arg);
 189 }
 190 static inline sg_host_t* simcall_execution_parallel_start__get__host_list(smx_simcall_t simcall)
 191 {
 192   return simgrid::simix::unmarshal<sg_host_t*>(simcall->args[2]);
 193 }
 194 static inline sg_host_t* simcall_execution_parallel_start__getraw__host_list(smx_simcall_t simcall)
 195 {
 196   return simgrid::simix::unmarshal_raw<sg_host_t*>(simcall->args[2]);
 197 }
 198 static inline void simcall_execution_parallel_start__set__host_list(smx_simcall_t simcall, sg_host_t* arg)
 199 {
 200   simgrid::simix::marshal<sg_host_t*>(simcall->args[2], arg);
 201 }
 202 static inline double* simcall_execution_parallel_start__get__flops_amount(smx_simcall_t simcall)
 203 {
 204   return simgrid::simix::unmarshal<double*>(simcall->args[3]);
 205 }
 206 static inline double* simcall_execution_parallel_start__getraw__flops_amount(smx_simcall_t simcall)
 207 {
 208   return simgrid::simix::unmarshal_raw<double*>(simcall->args[3]);
 209 }
 210 static inline void simcall_execution_parallel_start__set__flops_amount(smx_simcall_t simcall, double* arg)
 211 {
 212   simgrid::simix::marshal<double*>(simcall->args[3], arg);
 213 }
 214 static inline double* simcall_execution_parallel_start__get__bytes_amount(smx_simcall_t simcall)
 215 {
 216   return simgrid::simix::unmarshal<double*>(simcall->args[4]);
 217 }
 218 static inline double* simcall_execution_parallel_start__getraw__bytes_amount(smx_simcall_t simcall)
 219 {
 220   return simgrid::simix::unmarshal_raw<double*>(simcall->args[4]);
 221 }
 222 static inline void simcall_execution_parallel_start__set__bytes_amount(smx_simcall_t simcall, double* arg)
 223 {
 224   simgrid::simix::marshal<double*>(simcall->args[4], arg);
 225 }
 226 static inline double simcall_execution_parallel_start__get__rate(smx_simcall_t simcall)
 227 {
 228   return simgrid::simix::unmarshal<double>(simcall->args[5]);
 229 }
 230 static inline double simcall_execution_parallel_start__getraw__rate(smx_simcall_t simcall)
 231 {
 232   return simgrid::simix::unmarshal_raw<double>(simcall->args[5]);
 233 }
 234 static inline void simcall_execution_parallel_start__set__rate(smx_simcall_t simcall, double arg)
 235 {
 236   simgrid::simix::marshal<double>(simcall->args[5], arg);
 237 }
 238 static inline double simcall_execution_parallel_start__get__timeout(smx_simcall_t simcall)
 239 {
 240   return simgrid::simix::unmarshal<double>(simcall->args[6]);
 241 }
 242 static inline double simcall_execution_parallel_start__getraw__timeout(smx_simcall_t simcall)
 243 {
 244   return simgrid::simix::unmarshal_raw<double>(simcall->args[6]);
 245 }
 246 static inline void simcall_execution_parallel_start__set__timeout(smx_simcall_t simcall, double arg)
 247 {
 248   simgrid::simix::marshal<double>(simcall->args[6], arg);
 249 }
 250 static inline boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl> simcall_execution_parallel_start__get__result(smx_simcall_t simcall)
 251 {
 252   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl>>(simcall->result);
 253 }
 254 static inline simgrid::kernel::activity::ExecImpl* simcall_execution_parallel_start__getraw__result(smx_simcall_t simcall)
 255 {
 256   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ExecImpl*>(simcall->result);
 257 }
 258 static inline void simcall_execution_parallel_start__set__result(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl> result)
 259 {
 260   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ExecImpl>>(simcall->result, result);
 261 }
 262
 263 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_execution_wait__get__execution(smx_simcall_t simcall)
 264 {
 265   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
 266 }
 267 static inline simgrid::kernel::activity::ActivityImpl* simcall_execution_wait__getraw__execution(smx_simcall_t simcall)
 268 {
 269   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
 270 }
 271 static inline void simcall_execution_wait__set__execution(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
 272 {
 273   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
 274 }
 275 static inline int simcall_execution_wait__get__result(smx_simcall_t simcall)
 276 {
 277   return simgrid::simix::unmarshal<int>(simcall->result);
 278 }
 279 static inline int simcall_execution_wait__getraw__result(smx_simcall_t simcall)
 280 {
 281   return simgrid::simix::unmarshal_raw<int>(simcall->result);
 282 }
 283 static inline void simcall_execution_wait__set__result(smx_simcall_t simcall, int result)
 284 {
 285   simgrid::simix::marshal<int>(simcall->result, result);
 286 }
 287
 288 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
 289 simcall_execution_test__get__execution(smx_simcall_t simcall)
 290 {
 291   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
 292 }
 293 static inline simgrid::kernel::activity::ActivityImpl* simcall_execution_test__getraw__execution(smx_simcall_t simcall)
 294 {
 295   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
 296 }
 297 static inline void
 298 simcall_execution_test__set__execution(smx_simcall_t simcall,
 299                                        boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
 300 {
 301   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
 302 }
 303 static inline int simcall_execution_test__get__result(smx_simcall_t simcall)
 304 {
 305   return simgrid::simix::unmarshal<int>(simcall->result);
 306 }
 307 static inline int simcall_execution_test__getraw__result(smx_simcall_t simcall)
 308 {
 309   return simgrid::simix::unmarshal_raw<int>(simcall->result);
 310 }
 311 static inline void simcall_execution_test__set__result(smx_simcall_t simcall, int result)
 312 {
 313   simgrid::simix::marshal<int>(simcall->result, result);
 314 }
 315
 316 static inline smx_mailbox_t simcall_comm_iprobe__get__mbox(smx_simcall_t simcall)
 317 {
 318   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[0]);
 319 }
 320 static inline smx_mailbox_t simcall_comm_iprobe__getraw__mbox(smx_simcall_t simcall)
 321 {
 322   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[0]);
 323 }
 324 static inline void simcall_comm_iprobe__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
 325 {
 326   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[0], arg);
 327 }
 328 static inline int simcall_comm_iprobe__get__type(smx_simcall_t simcall)
 329 {
 330   return simgrid::simix::unmarshal<int>(simcall->args[1]);
 331 }
 332 static inline int simcall_comm_iprobe__getraw__type(smx_simcall_t simcall)
 333 {
 334   return simgrid::simix::unmarshal_raw<int>(simcall->args[1]);
 335 }
 336 static inline void simcall_comm_iprobe__set__type(smx_simcall_t simcall, int arg)
 337 {
 338   simgrid::simix::marshal<int>(simcall->args[1], arg);
 339 }
 340 static inline simix_match_func_t simcall_comm_iprobe__get__match_fun(smx_simcall_t simcall)
 341 {
 342   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[2]);
 343 }
 344 static inline simix_match_func_t simcall_comm_iprobe__getraw__match_fun(smx_simcall_t simcall)
 345 {
 346   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[2]);
 347 }
 348 static inline void simcall_comm_iprobe__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
 349 {
 350   simgrid::simix::marshal<simix_match_func_t>(simcall->args[2], arg);
 351 }
 352 static inline void* simcall_comm_iprobe__get__data(smx_simcall_t simcall)
 353 {
 354   return simgrid::simix::unmarshal<void*>(simcall->args[3]);
 355 }
 356 static inline void* simcall_comm_iprobe__getraw__data(smx_simcall_t simcall)
 357 {
 358   return simgrid::simix::unmarshal_raw<void*>(simcall->args[3]);
 359 }
 360 static inline void simcall_comm_iprobe__set__data(smx_simcall_t simcall, void* arg)
 361 {
 362   simgrid::simix::marshal<void*>(simcall->args[3], arg);
 363 }
 364 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_comm_iprobe__get__result(smx_simcall_t simcall)
 365 {
 366   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result);
 367 }
 368 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_iprobe__getraw__result(smx_simcall_t simcall)
 369 {
 370   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->result);
 371 }
 372 static inline void simcall_comm_iprobe__set__result(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> result)
 373 {
 374   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result, result);
 375 }
 376
 377 static inline smx_actor_t simcall_comm_send__get__sender(smx_simcall_t simcall)
 378 {
 379   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
 380 }
 381 static inline smx_actor_t simcall_comm_send__getraw__sender(smx_simcall_t simcall)
 382 {
 383   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
 384 }
 385 static inline void simcall_comm_send__set__sender(smx_simcall_t simcall, smx_actor_t arg)
 386 {
 387   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
 388 }
 389 static inline smx_mailbox_t simcall_comm_send__get__mbox(smx_simcall_t simcall)
 390 {
 391   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[1]);
 392 }
 393 static inline smx_mailbox_t simcall_comm_send__getraw__mbox(smx_simcall_t simcall)
 394 {
 395   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[1]);
 396 }
 397 static inline void simcall_comm_send__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
 398 {
 399   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[1], arg);
 400 }
 401 static inline double simcall_comm_send__get__task_size(smx_simcall_t simcall)
 402 {
 403   return simgrid::simix::unmarshal<double>(simcall->args[2]);
 404 }
 405 static inline double simcall_comm_send__getraw__task_size(smx_simcall_t simcall)
 406 {
 407   return simgrid::simix::unmarshal_raw<double>(simcall->args[2]);
 408 }
 409 static inline void simcall_comm_send__set__task_size(smx_simcall_t simcall, double arg)
 410 {
 411   simgrid::simix::marshal<double>(simcall->args[2], arg);
 412 }
 413 static inline double simcall_comm_send__get__rate(smx_simcall_t simcall)
 414 {
 415   return simgrid::simix::unmarshal<double>(simcall->args[3]);
 416 }
 417 static inline double simcall_comm_send__getraw__rate(smx_simcall_t simcall)
 418 {
 419   return simgrid::simix::unmarshal_raw<double>(simcall->args[3]);
 420 }
 421 static inline void simcall_comm_send__set__rate(smx_simcall_t simcall, double arg)
 422 {
 423   simgrid::simix::marshal<double>(simcall->args[3], arg);
 424 }
 425 static inline void* simcall_comm_send__get__src_buff(smx_simcall_t simcall)
 426 {
 427   return simgrid::simix::unmarshal<void*>(simcall->args[4]);
 428 }
 429 static inline void* simcall_comm_send__getraw__src_buff(smx_simcall_t simcall)
 430 {
 431   return simgrid::simix::unmarshal_raw<void*>(simcall->args[4]);
 432 }
 433 static inline void simcall_comm_send__set__src_buff(smx_simcall_t simcall, void* arg)
 434 {
 435   simgrid::simix::marshal<void*>(simcall->args[4], arg);
 436 }
 437 static inline size_t simcall_comm_send__get__src_buff_size(smx_simcall_t simcall)
 438 {
 439   return simgrid::simix::unmarshal<size_t>(simcall->args[5]);
 440 }
 441 static inline size_t simcall_comm_send__getraw__src_buff_size(smx_simcall_t simcall)
 442 {
 443   return simgrid::simix::unmarshal_raw<size_t>(simcall->args[5]);
 444 }
 445 static inline void simcall_comm_send__set__src_buff_size(smx_simcall_t simcall, size_t arg)
 446 {
 447   simgrid::simix::marshal<size_t>(simcall->args[5], arg);
 448 }
 449 static inline simix_match_func_t simcall_comm_send__get__match_fun(smx_simcall_t simcall)
 450 {
 451   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[6]);
 452 }
 453 static inline simix_match_func_t simcall_comm_send__getraw__match_fun(smx_simcall_t simcall)
 454 {
 455   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[6]);
 456 }
 457 static inline void simcall_comm_send__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
 458 {
 459   simgrid::simix::marshal<simix_match_func_t>(simcall->args[6], arg);
 460 }
 461 static inline simix_copy_data_func_t simcall_comm_send__get__copy_data_fun(smx_simcall_t simcall)
 462 {
 463   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[7]);
 464 }
 465 static inline simix_copy_data_func_t simcall_comm_send__getraw__copy_data_fun(smx_simcall_t simcall)
 466 {
 467   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args[7]);
 468 }
 469 static inline void simcall_comm_send__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
 470 {
 471   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[7], arg);
 472 }
 473 static inline void* simcall_comm_send__get__data(smx_simcall_t simcall)
 474 {
 475   return simgrid::simix::unmarshal<void*>(simcall->args[8]);
 476 }
 477 static inline void* simcall_comm_send__getraw__data(smx_simcall_t simcall)
 478 {
 479   return simgrid::simix::unmarshal_raw<void*>(simcall->args[8]);
 480 }
 481 static inline void simcall_comm_send__set__data(smx_simcall_t simcall, void* arg)
 482 {
 483   simgrid::simix::marshal<void*>(simcall->args[8], arg);
 484 }
 485 static inline double simcall_comm_send__get__timeout(smx_simcall_t simcall)
 486 {
 487   return simgrid::simix::unmarshal<double>(simcall->args[9]);
 488 }
 489 static inline double simcall_comm_send__getraw__timeout(smx_simcall_t simcall)
 490 {
 491   return simgrid::simix::unmarshal_raw<double>(simcall->args[9]);
 492 }
 493 static inline void simcall_comm_send__set__timeout(smx_simcall_t simcall, double arg)
 494 {
 495   simgrid::simix::marshal<double>(simcall->args[9], arg);
 496 }
 497
 498 static inline smx_actor_t simcall_comm_isend__get__sender(smx_simcall_t simcall)
 499 {
 500   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
 501 }
 502 static inline smx_actor_t simcall_comm_isend__getraw__sender(smx_simcall_t simcall)
 503 {
 504   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
 505 }
 506 static inline void simcall_comm_isend__set__sender(smx_simcall_t simcall, smx_actor_t arg)
 507 {
 508   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
 509 }
 510 static inline smx_mailbox_t simcall_comm_isend__get__mbox(smx_simcall_t simcall)
 511 {
 512   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[1]);
 513 }
 514 static inline smx_mailbox_t simcall_comm_isend__getraw__mbox(smx_simcall_t simcall)
 515 {
 516   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[1]);
 517 }
 518 static inline void simcall_comm_isend__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
 519 {
 520   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[1], arg);
 521 }
 522 static inline double simcall_comm_isend__get__task_size(smx_simcall_t simcall)
 523 {
 524   return simgrid::simix::unmarshal<double>(simcall->args[2]);
 525 }
 526 static inline double simcall_comm_isend__getraw__task_size(smx_simcall_t simcall)
 527 {
 528   return simgrid::simix::unmarshal_raw<double>(simcall->args[2]);
 529 }
 530 static inline void simcall_comm_isend__set__task_size(smx_simcall_t simcall, double arg)
 531 {
 532   simgrid::simix::marshal<double>(simcall->args[2], arg);
 533 }
 534 static inline double simcall_comm_isend__get__rate(smx_simcall_t simcall)
 535 {
 536   return simgrid::simix::unmarshal<double>(simcall->args[3]);
 537 }
 538 static inline double simcall_comm_isend__getraw__rate(smx_simcall_t simcall)
 539 {
 540   return simgrid::simix::unmarshal_raw<double>(simcall->args[3]);
 541 }
 542 static inline void simcall_comm_isend__set__rate(smx_simcall_t simcall, double arg)
 543 {
 544   simgrid::simix::marshal<double>(simcall->args[3], arg);
 545 }
 546 static inline void* simcall_comm_isend__get__src_buff(smx_simcall_t simcall)
 547 {
 548   return simgrid::simix::unmarshal<void*>(simcall->args[4]);
 549 }
 550 static inline void* simcall_comm_isend__getraw__src_buff(smx_simcall_t simcall)
 551 {
 552   return simgrid::simix::unmarshal_raw<void*>(simcall->args[4]);
 553 }
 554 static inline void simcall_comm_isend__set__src_buff(smx_simcall_t simcall, void* arg)
 555 {
 556   simgrid::simix::marshal<void*>(simcall->args[4], arg);
 557 }
 558 static inline size_t simcall_comm_isend__get__src_buff_size(smx_simcall_t simcall)
 559 {
 560   return simgrid::simix::unmarshal<size_t>(simcall->args[5]);
 561 }
 562 static inline size_t simcall_comm_isend__getraw__src_buff_size(smx_simcall_t simcall)
 563 {
 564   return simgrid::simix::unmarshal_raw<size_t>(simcall->args[5]);
 565 }
 566 static inline void simcall_comm_isend__set__src_buff_size(smx_simcall_t simcall, size_t arg)
 567 {
 568   simgrid::simix::marshal<size_t>(simcall->args[5], arg);
 569 }
 570 static inline simix_match_func_t simcall_comm_isend__get__match_fun(smx_simcall_t simcall)
 571 {
 572   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[6]);
 573 }
 574 static inline simix_match_func_t simcall_comm_isend__getraw__match_fun(smx_simcall_t simcall)
 575 {
 576   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[6]);
 577 }
 578 static inline void simcall_comm_isend__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
 579 {
 580   simgrid::simix::marshal<simix_match_func_t>(simcall->args[6], arg);
 581 }
 582 static inline simix_clean_func_t simcall_comm_isend__get__clean_fun(smx_simcall_t simcall)
 583 {
 584   return simgrid::simix::unmarshal<simix_clean_func_t>(simcall->args[7]);
 585 }
 586 static inline simix_clean_func_t simcall_comm_isend__getraw__clean_fun(smx_simcall_t simcall)
 587 {
 588   return simgrid::simix::unmarshal_raw<simix_clean_func_t>(simcall->args[7]);
 589 }
 590 static inline void simcall_comm_isend__set__clean_fun(smx_simcall_t simcall, simix_clean_func_t arg)
 591 {
 592   simgrid::simix::marshal<simix_clean_func_t>(simcall->args[7], arg);
 593 }
 594 static inline simix_copy_data_func_t simcall_comm_isend__get__copy_data_fun(smx_simcall_t simcall)
 595 {
 596   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[8]);
 597 }
 598 static inline simix_copy_data_func_t simcall_comm_isend__getraw__copy_data_fun(smx_simcall_t simcall)
 599 {
 600   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args[8]);
 601 }
 602 static inline void simcall_comm_isend__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
 603 {
 604   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[8], arg);
 605 }
 606 static inline void* simcall_comm_isend__get__data(smx_simcall_t simcall)
 607 {
 608   return simgrid::simix::unmarshal<void*>(simcall->args[9]);
 609 }
 610 static inline void* simcall_comm_isend__getraw__data(smx_simcall_t simcall)
 611 {
 612   return simgrid::simix::unmarshal_raw<void*>(simcall->args[9]);
 613 }
 614 static inline void simcall_comm_isend__set__data(smx_simcall_t simcall, void* arg)
 615 {
 616   simgrid::simix::marshal<void*>(simcall->args[9], arg);
 617 }
 618 static inline int simcall_comm_isend__get__detached(smx_simcall_t simcall)
 619 {
 620   return simgrid::simix::unmarshal<int>(simcall->args[10]);
 621 }
 622 static inline int simcall_comm_isend__getraw__detached(smx_simcall_t simcall)
 623 {
 624   return simgrid::simix::unmarshal_raw<int>(simcall->args[10]);
 625 }
 626 static inline void simcall_comm_isend__set__detached(smx_simcall_t simcall, int arg)
 627 {
 628   simgrid::simix::marshal<int>(simcall->args[10], arg);
 629 }
 630 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_comm_isend__get__result(smx_simcall_t simcall)
 631 {
 632   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result);
 633 }
 634 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_isend__getraw__result(smx_simcall_t simcall)
 635 {
 636   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->result);
 637 }
 638 static inline void simcall_comm_isend__set__result(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> result)
 639 {
 640   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result, result);
 641 }
 642
 643 static inline smx_actor_t simcall_comm_recv__get__receiver(smx_simcall_t simcall)
 644 {
 645   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
 646 }
 647 static inline smx_actor_t simcall_comm_recv__getraw__receiver(smx_simcall_t simcall)
 648 {
 649   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
 650 }
 651 static inline void simcall_comm_recv__set__receiver(smx_simcall_t simcall, smx_actor_t arg)
 652 {
 653   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
 654 }
 655 static inline smx_mailbox_t simcall_comm_recv__get__mbox(smx_simcall_t simcall)
 656 {
 657   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[1]);
 658 }
 659 static inline smx_mailbox_t simcall_comm_recv__getraw__mbox(smx_simcall_t simcall)
 660 {
 661   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[1]);
 662 }
 663 static inline void simcall_comm_recv__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
 664 {
 665   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[1], arg);
 666 }
 667 static inline void* simcall_comm_recv__get__dst_buff(smx_simcall_t simcall)
 668 {
 669   return simgrid::simix::unmarshal<void*>(simcall->args[2]);
 670 }
 671 static inline void* simcall_comm_recv__getraw__dst_buff(smx_simcall_t simcall)
 672 {
 673   return simgrid::simix::unmarshal_raw<void*>(simcall->args[2]);
 674 }
 675 static inline void simcall_comm_recv__set__dst_buff(smx_simcall_t simcall, void* arg)
 676 {
 677   simgrid::simix::marshal<void*>(simcall->args[2], arg);
 678 }
 679 static inline size_t* simcall_comm_recv__get__dst_buff_size(smx_simcall_t simcall)
 680 {
 681   return simgrid::simix::unmarshal<size_t*>(simcall->args[3]);
 682 }
 683 static inline size_t* simcall_comm_recv__getraw__dst_buff_size(smx_simcall_t simcall)
 684 {
 685   return simgrid::simix::unmarshal_raw<size_t*>(simcall->args[3]);
 686 }
 687 static inline void simcall_comm_recv__set__dst_buff_size(smx_simcall_t simcall, size_t* arg)
 688 {
 689   simgrid::simix::marshal<size_t*>(simcall->args[3], arg);
 690 }
 691 static inline simix_match_func_t simcall_comm_recv__get__match_fun(smx_simcall_t simcall)
 692 {
 693   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[4]);
 694 }
 695 static inline simix_match_func_t simcall_comm_recv__getraw__match_fun(smx_simcall_t simcall)
 696 {
 697   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[4]);
 698 }
 699 static inline void simcall_comm_recv__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
 700 {
 701   simgrid::simix::marshal<simix_match_func_t>(simcall->args[4], arg);
 702 }
 703 static inline simix_copy_data_func_t simcall_comm_recv__get__copy_data_fun(smx_simcall_t simcall)
 704 {
 705   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[5]);
 706 }
 707 static inline simix_copy_data_func_t simcall_comm_recv__getraw__copy_data_fun(smx_simcall_t simcall)
 708 {
 709   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args[5]);
 710 }
 711 static inline void simcall_comm_recv__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
 712 {
 713   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[5], arg);
 714 }
 715 static inline void* simcall_comm_recv__get__data(smx_simcall_t simcall)
 716 {
 717   return simgrid::simix::unmarshal<void*>(simcall->args[6]);
 718 }
 719 static inline void* simcall_comm_recv__getraw__data(smx_simcall_t simcall)
 720 {
 721   return simgrid::simix::unmarshal_raw<void*>(simcall->args[6]);
 722 }
 723 static inline void simcall_comm_recv__set__data(smx_simcall_t simcall, void* arg)
 724 {
 725   simgrid::simix::marshal<void*>(simcall->args[6], arg);
 726 }
 727 static inline double simcall_comm_recv__get__timeout(smx_simcall_t simcall)
 728 {
 729   return simgrid::simix::unmarshal<double>(simcall->args[7]);
 730 }
 731 static inline double simcall_comm_recv__getraw__timeout(smx_simcall_t simcall)
 732 {
 733   return simgrid::simix::unmarshal_raw<double>(simcall->args[7]);
 734 }
 735 static inline void simcall_comm_recv__set__timeout(smx_simcall_t simcall, double arg)
 736 {
 737   simgrid::simix::marshal<double>(simcall->args[7], arg);
 738 }
 739 static inline double simcall_comm_recv__get__rate(smx_simcall_t simcall)
 740 {
 741   return simgrid::simix::unmarshal<double>(simcall->args[8]);
 742 }
 743 static inline double simcall_comm_recv__getraw__rate(smx_simcall_t simcall)
 744 {
 745   return simgrid::simix::unmarshal_raw<double>(simcall->args[8]);
 746 }
 747 static inline void simcall_comm_recv__set__rate(smx_simcall_t simcall, double arg)
 748 {
 749   simgrid::simix::marshal<double>(simcall->args[8], arg);
 750 }
 751
 752 static inline smx_actor_t simcall_comm_irecv__get__receiver(smx_simcall_t simcall)
 753 {
 754   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args[0]);
 755 }
 756 static inline smx_actor_t simcall_comm_irecv__getraw__receiver(smx_simcall_t simcall)
 757 {
 758   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args[0]);
 759 }
 760 static inline void simcall_comm_irecv__set__receiver(smx_simcall_t simcall, smx_actor_t arg)
 761 {
 762   simgrid::simix::marshal<smx_actor_t>(simcall->args[0], arg);
 763 }
 764 static inline smx_mailbox_t simcall_comm_irecv__get__mbox(smx_simcall_t simcall)
 765 {
 766   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args[1]);
 767 }
 768 static inline smx_mailbox_t simcall_comm_irecv__getraw__mbox(smx_simcall_t simcall)
 769 {
 770   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args[1]);
 771 }
 772 static inline void simcall_comm_irecv__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
 773 {
 774   simgrid::simix::marshal<smx_mailbox_t>(simcall->args[1], arg);
 775 }
 776 static inline void* simcall_comm_irecv__get__dst_buff(smx_simcall_t simcall)
 777 {
 778   return simgrid::simix::unmarshal<void*>(simcall->args[2]);
 779 }
 780 static inline void* simcall_comm_irecv__getraw__dst_buff(smx_simcall_t simcall)
 781 {
 782   return simgrid::simix::unmarshal_raw<void*>(simcall->args[2]);
 783 }
 784 static inline void simcall_comm_irecv__set__dst_buff(smx_simcall_t simcall, void* arg)
 785 {
 786   simgrid::simix::marshal<void*>(simcall->args[2], arg);
 787 }
 788 static inline size_t* simcall_comm_irecv__get__dst_buff_size(smx_simcall_t simcall)
 789 {
 790   return simgrid::simix::unmarshal<size_t*>(simcall->args[3]);
 791 }
 792 static inline size_t* simcall_comm_irecv__getraw__dst_buff_size(smx_simcall_t simcall)
 793 {
 794   return simgrid::simix::unmarshal_raw<size_t*>(simcall->args[3]);
 795 }
 796 static inline void simcall_comm_irecv__set__dst_buff_size(smx_simcall_t simcall, size_t* arg)
 797 {
 798   simgrid::simix::marshal<size_t*>(simcall->args[3], arg);
 799 }
 800 static inline simix_match_func_t simcall_comm_irecv__get__match_fun(smx_simcall_t simcall)
 801 {
 802   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args[4]);
 803 }
 804 static inline simix_match_func_t simcall_comm_irecv__getraw__match_fun(smx_simcall_t simcall)
 805 {
 806   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args[4]);
 807 }
 808 static inline void simcall_comm_irecv__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
 809 {
 810   simgrid::simix::marshal<simix_match_func_t>(simcall->args[4], arg);
 811 }
 812 static inline simix_copy_data_func_t simcall_comm_irecv__get__copy_data_fun(smx_simcall_t simcall)
 813 {
 814   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args[5]);
 815 }
 816 static inline simix_copy_data_func_t simcall_comm_irecv__getraw__copy_data_fun(smx_simcall_t simcall)
 817 {
 818   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args[5]);
 819 }
 820 static inline void simcall_comm_irecv__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
 821 {
 822   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args[5], arg);
 823 }
 824 static inline void* simcall_comm_irecv__get__data(smx_simcall_t simcall)
 825 {
 826   return simgrid::simix::unmarshal<void*>(simcall->args[6]);
 827 }
 828 static inline void* simcall_comm_irecv__getraw__data(smx_simcall_t simcall)
 829 {
 830   return simgrid::simix::unmarshal_raw<void*>(simcall->args[6]);
 831 }
 832 static inline void simcall_comm_irecv__set__data(smx_simcall_t simcall, void* arg)
 833 {
 834   simgrid::simix::marshal<void*>(simcall->args[6], arg);
 835 }
 836 static inline double simcall_comm_irecv__get__rate(smx_simcall_t simcall)
 837 {
 838   return simgrid::simix::unmarshal<double>(simcall->args[7]);
 839 }
 840 static inline double simcall_comm_irecv__getraw__rate(smx_simcall_t simcall)
 841 {
 842   return simgrid::simix::unmarshal_raw<double>(simcall->args[7]);
 843 }
 844 static inline void simcall_comm_irecv__set__rate(smx_simcall_t simcall, double arg)
 845 {
 846   simgrid::simix::marshal<double>(simcall->args[7], arg);
 847 }
 848 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_comm_irecv__get__result(smx_simcall_t simcall)
 849 {
 850   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result);
 851 }
 852 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_irecv__getraw__result(smx_simcall_t simcall)
 853 {
 854   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->result);
 855 }
 856 static inline void simcall_comm_irecv__set__result(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> result)
 857 {
 858   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result, result);
 859 }
 860
 861 static inline xbt_dynar_t simcall_comm_waitany__get__comms(smx_simcall_t simcall)
 862 {
 863   return simgrid::simix::unmarshal<xbt_dynar_t>(simcall->args[0]);
 864 }
 865 static inline xbt_dynar_t simcall_comm_waitany__getraw__comms(smx_simcall_t simcall)
 866 {
 867   return simgrid::simix::unmarshal_raw<xbt_dynar_t>(simcall->args[0]);
 868 }
 869 static inline void simcall_comm_waitany__set__comms(smx_simcall_t simcall, xbt_dynar_t arg)
 870 {
 871   simgrid::simix::marshal<xbt_dynar_t>(simcall->args[0], arg);
 872 }
 873 static inline double simcall_comm_waitany__get__timeout(smx_simcall_t simcall)
 874 {
 875   return simgrid::simix::unmarshal<double>(simcall->args[1]);
 876 }
 877 static inline double simcall_comm_waitany__getraw__timeout(smx_simcall_t simcall)
 878 {
 879   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
 880 }
 881 static inline void simcall_comm_waitany__set__timeout(smx_simcall_t simcall, double arg)
 882 {
 883   simgrid::simix::marshal<double>(simcall->args[1], arg);
 884 }
 885 static inline int simcall_comm_waitany__get__result(smx_simcall_t simcall)
 886 {
 887   return simgrid::simix::unmarshal<int>(simcall->result);
 888 }
 889 static inline int simcall_comm_waitany__getraw__result(smx_simcall_t simcall)
 890 {
 891   return simgrid::simix::unmarshal_raw<int>(simcall->result);
 892 }
 893 static inline void simcall_comm_waitany__set__result(smx_simcall_t simcall, int result)
 894 {
 895   simgrid::simix::marshal<int>(simcall->result, result);
 896 }
 897
 898 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_comm_wait__get__comm(smx_simcall_t simcall)
 899 {
 900   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
 901 }
 902 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_wait__getraw__comm(smx_simcall_t simcall)
 903 {
 904   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
 905 }
 906 static inline void simcall_comm_wait__set__comm(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
 907 {
 908   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
 909 }
 910 static inline double simcall_comm_wait__get__timeout(smx_simcall_t simcall)
 911 {
 912   return simgrid::simix::unmarshal<double>(simcall->args[1]);
 913 }
 914 static inline double simcall_comm_wait__getraw__timeout(smx_simcall_t simcall)
 915 {
 916   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
 917 }
 918 static inline void simcall_comm_wait__set__timeout(smx_simcall_t simcall, double arg)
 919 {
 920   simgrid::simix::marshal<double>(simcall->args[1], arg);
 921 }
 922
 923 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_comm_test__get__comm(smx_simcall_t simcall)
 924 {
 925   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
 926 }
 927 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_test__getraw__comm(smx_simcall_t simcall)
 928 {
 929   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
 930 }
 931 static inline void simcall_comm_test__set__comm(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
 932 {
 933   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
 934 }
 935 static inline int simcall_comm_test__get__result(smx_simcall_t simcall)
 936 {
 937   return simgrid::simix::unmarshal<int>(simcall->result);
 938 }
 939 static inline int simcall_comm_test__getraw__result(smx_simcall_t simcall)
 940 {
 941   return simgrid::simix::unmarshal_raw<int>(simcall->result);
 942 }
 943 static inline void simcall_comm_test__set__result(smx_simcall_t simcall, int result)
 944 {
 945   simgrid::simix::marshal<int>(simcall->result, result);
 946 }
 947
 948 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>* simcall_comm_testany__get__comms(smx_simcall_t simcall)
 949 {
 950   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>*>(simcall->args[0]);
 951 }
 952 static inline simgrid::kernel::activity::ActivityImpl** simcall_comm_testany__getraw__comms(smx_simcall_t simcall)
 953 {
 954   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl**>(simcall->args[0]);
 955 }
 956 static inline void simcall_comm_testany__set__comms(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>* arg)
 957 {
 958   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>*>(simcall->args[0], arg);
 959 }
 960 static inline size_t simcall_comm_testany__get__count(smx_simcall_t simcall)
 961 {
 962   return simgrid::simix::unmarshal<size_t>(simcall->args[1]);
 963 }
 964 static inline size_t simcall_comm_testany__getraw__count(smx_simcall_t simcall)
 965 {
 966   return simgrid::simix::unmarshal_raw<size_t>(simcall->args[1]);
 967 }
 968 static inline void simcall_comm_testany__set__count(smx_simcall_t simcall, size_t arg)
 969 {
 970   simgrid::simix::marshal<size_t>(simcall->args[1], arg);
 971 }
 972 static inline int simcall_comm_testany__get__result(smx_simcall_t simcall)
 973 {
 974   return simgrid::simix::unmarshal<int>(simcall->result);
 975 }
 976 static inline int simcall_comm_testany__getraw__result(smx_simcall_t simcall)
 977 {
 978   return simgrid::simix::unmarshal_raw<int>(simcall->result);
 979 }
 980 static inline void simcall_comm_testany__set__result(smx_simcall_t simcall, int result)
 981 {
 982   simgrid::simix::marshal<int>(simcall->result, result);
 983 }
 984
 985 static inline smx_mutex_t simcall_mutex_lock__get__mutex(smx_simcall_t simcall)
 986 {
 987   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[0]);
 988 }
 989 static inline smx_mutex_t simcall_mutex_lock__getraw__mutex(smx_simcall_t simcall)
 990 {
 991   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[0]);
 992 }
 993 static inline void simcall_mutex_lock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
 994 {
 995   simgrid::simix::marshal<smx_mutex_t>(simcall->args[0], arg);
 996 }
 997
 998 static inline smx_mutex_t simcall_mutex_trylock__get__mutex(smx_simcall_t simcall)
 999 {
1000   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[0]);
1001 }
1002 static inline smx_mutex_t simcall_mutex_trylock__getraw__mutex(smx_simcall_t simcall)
1003 {
1004   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[0]);
1005 }
1006 static inline void simcall_mutex_trylock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
1007 {
1008   simgrid::simix::marshal<smx_mutex_t>(simcall->args[0], arg);
1009 }
1010 static inline int simcall_mutex_trylock__get__result(smx_simcall_t simcall)
1011 {
1012   return simgrid::simix::unmarshal<int>(simcall->result);
1013 }
1014 static inline int simcall_mutex_trylock__getraw__result(smx_simcall_t simcall)
1015 {
1016   return simgrid::simix::unmarshal_raw<int>(simcall->result);
1017 }
1018 static inline void simcall_mutex_trylock__set__result(smx_simcall_t simcall, int result)
1019 {
1020   simgrid::simix::marshal<int>(simcall->result, result);
1021 }
1022
1023 static inline smx_mutex_t simcall_mutex_unlock__get__mutex(smx_simcall_t simcall)
1024 {
1025   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[0]);
1026 }
1027 static inline smx_mutex_t simcall_mutex_unlock__getraw__mutex(smx_simcall_t simcall)
1028 {
1029   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[0]);
1030 }
1031 static inline void simcall_mutex_unlock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
1032 {
1033   simgrid::simix::marshal<smx_mutex_t>(simcall->args[0], arg);
1034 }
1035
1036 static inline smx_cond_t simcall_cond_init__get__result(smx_simcall_t simcall)
1037 {
1038   return simgrid::simix::unmarshal<smx_cond_t>(simcall->result);
1039 }
1040 static inline smx_cond_t simcall_cond_init__getraw__result(smx_simcall_t simcall)
1041 {
1042   return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->result);
1043 }
1044 static inline void simcall_cond_init__set__result(smx_simcall_t simcall, smx_cond_t result)
1045 {
1046   simgrid::simix::marshal<smx_cond_t>(simcall->result, result);
1047 }
1048
1049 static inline smx_cond_t simcall_cond_wait__get__cond(smx_simcall_t simcall)
1050 {
1051   return simgrid::simix::unmarshal<smx_cond_t>(simcall->args[0]);
1052 }
1053 static inline smx_cond_t simcall_cond_wait__getraw__cond(smx_simcall_t simcall)
1054 {
1055   return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->args[0]);
1056 }
1057 static inline void simcall_cond_wait__set__cond(smx_simcall_t simcall, smx_cond_t arg)
1058 {
1059   simgrid::simix::marshal<smx_cond_t>(simcall->args[0], arg);
1060 }
1061 static inline smx_mutex_t simcall_cond_wait__get__mutex(smx_simcall_t simcall)
1062 {
1063   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[1]);
1064 }
1065 static inline smx_mutex_t simcall_cond_wait__getraw__mutex(smx_simcall_t simcall)
1066 {
1067   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[1]);
1068 }
1069 static inline void simcall_cond_wait__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
1070 {
1071   simgrid::simix::marshal<smx_mutex_t>(simcall->args[1], arg);
1072 }
1073
1074 static inline smx_cond_t simcall_cond_wait_timeout__get__cond(smx_simcall_t simcall)
1075 {
1076   return simgrid::simix::unmarshal<smx_cond_t>(simcall->args[0]);
1077 }
1078 static inline smx_cond_t simcall_cond_wait_timeout__getraw__cond(smx_simcall_t simcall)
1079 {
1080   return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->args[0]);
1081 }
1082 static inline void simcall_cond_wait_timeout__set__cond(smx_simcall_t simcall, smx_cond_t arg)
1083 {
1084   simgrid::simix::marshal<smx_cond_t>(simcall->args[0], arg);
1085 }
1086 static inline smx_mutex_t simcall_cond_wait_timeout__get__mutex(smx_simcall_t simcall)
1087 {
1088   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[1]);
1089 }
1090 static inline smx_mutex_t simcall_cond_wait_timeout__getraw__mutex(smx_simcall_t simcall)
1091 {
1092   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[1]);
1093 }
1094 static inline void simcall_cond_wait_timeout__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
1095 {
1096   simgrid::simix::marshal<smx_mutex_t>(simcall->args[1], arg);
1097 }
1098 static inline double simcall_cond_wait_timeout__get__timeout(smx_simcall_t simcall)
1099 {
1100   return simgrid::simix::unmarshal<double>(simcall->args[2]);
1101 }
1102 static inline double simcall_cond_wait_timeout__getraw__timeout(smx_simcall_t simcall)
1103 {
1104   return simgrid::simix::unmarshal_raw<double>(simcall->args[2]);
1105 }
1106 static inline void simcall_cond_wait_timeout__set__timeout(smx_simcall_t simcall, double arg)
1107 {
1108   simgrid::simix::marshal<double>(simcall->args[2], arg);
1109 }
1110
1111 static inline smx_sem_t simcall_sem_acquire__get__sem(smx_simcall_t simcall)
1112 {
1113   return simgrid::simix::unmarshal<smx_sem_t>(simcall->args[0]);
1114 }
1115 static inline smx_sem_t simcall_sem_acquire__getraw__sem(smx_simcall_t simcall)
1116 {
1117   return simgrid::simix::unmarshal_raw<smx_sem_t>(simcall->args[0]);
1118 }
1119 static inline void simcall_sem_acquire__set__sem(smx_simcall_t simcall, smx_sem_t arg)
1120 {
1121   simgrid::simix::marshal<smx_sem_t>(simcall->args[0], arg);
1122 }
1123
1124 static inline smx_sem_t simcall_sem_acquire_timeout__get__sem(smx_simcall_t simcall)
1125 {
1126   return simgrid::simix::unmarshal<smx_sem_t>(simcall->args[0]);
1127 }
1128 static inline smx_sem_t simcall_sem_acquire_timeout__getraw__sem(smx_simcall_t simcall)
1129 {
1130   return simgrid::simix::unmarshal_raw<smx_sem_t>(simcall->args[0]);
1131 }
1132 static inline void simcall_sem_acquire_timeout__set__sem(smx_simcall_t simcall, smx_sem_t arg)
1133 {
1134   simgrid::simix::marshal<smx_sem_t>(simcall->args[0], arg);
1135 }
1136 static inline double simcall_sem_acquire_timeout__get__timeout(smx_simcall_t simcall)
1137 {
1138   return simgrid::simix::unmarshal<double>(simcall->args[1]);
1139 }
1140 static inline double simcall_sem_acquire_timeout__getraw__timeout(smx_simcall_t simcall)
1141 {
1142   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
1143 }
1144 static inline void simcall_sem_acquire_timeout__set__timeout(smx_simcall_t simcall, double arg)
1145 {
1146   simgrid::simix::marshal<double>(simcall->args[1], arg);
1147 }
1148
1149 static inline surf_storage_t simcall_storage_read__get__st(smx_simcall_t simcall)
1150 {
1151   return simgrid::simix::unmarshal<surf_storage_t>(simcall->args[0]);
1152 }
1153 static inline surf_storage_t simcall_storage_read__getraw__st(smx_simcall_t simcall)
1154 {
1155   return simgrid::simix::unmarshal_raw<surf_storage_t>(simcall->args[0]);
1156 }
1157 static inline void simcall_storage_read__set__st(smx_simcall_t simcall, surf_storage_t arg)
1158 {
1159   simgrid::simix::marshal<surf_storage_t>(simcall->args[0], arg);
1160 }
1161 static inline sg_size_t simcall_storage_read__get__size(smx_simcall_t simcall)
1162 {
1163   return simgrid::simix::unmarshal<sg_size_t>(simcall->args[1]);
1164 }
1165 static inline sg_size_t simcall_storage_read__getraw__size(smx_simcall_t simcall)
1166 {
1167   return simgrid::simix::unmarshal_raw<sg_size_t>(simcall->args[1]);
1168 }
1169 static inline void simcall_storage_read__set__size(smx_simcall_t simcall, sg_size_t arg)
1170 {
1171   simgrid::simix::marshal<sg_size_t>(simcall->args[1], arg);
1172 }
1173 static inline sg_size_t simcall_storage_read__get__result(smx_simcall_t simcall)
1174 {
1175   return simgrid::simix::unmarshal<sg_size_t>(simcall->result);
1176 }
1177 static inline sg_size_t simcall_storage_read__getraw__result(smx_simcall_t simcall)
1178 {
1179   return simgrid::simix::unmarshal_raw<sg_size_t>(simcall->result);
1180 }
1181 static inline void simcall_storage_read__set__result(smx_simcall_t simcall, sg_size_t result)
1182 {
1183   simgrid::simix::marshal<sg_size_t>(simcall->result, result);
1184 }
1185
1186 static inline surf_storage_t simcall_storage_write__get__st(smx_simcall_t simcall)
1187 {
1188   return simgrid::simix::unmarshal<surf_storage_t>(simcall->args[0]);
1189 }
1190 static inline surf_storage_t simcall_storage_write__getraw__st(smx_simcall_t simcall)
1191 {
1192   return simgrid::simix::unmarshal_raw<surf_storage_t>(simcall->args[0]);
1193 }
1194 static inline void simcall_storage_write__set__st(smx_simcall_t simcall, surf_storage_t arg)
1195 {
1196   simgrid::simix::marshal<surf_storage_t>(simcall->args[0], arg);
1197 }
1198 static inline sg_size_t simcall_storage_write__get__size(smx_simcall_t simcall)
1199 {
1200   return simgrid::simix::unmarshal<sg_size_t>(simcall->args[1]);
1201 }
1202 static inline sg_size_t simcall_storage_write__getraw__size(smx_simcall_t simcall)
1203 {
1204   return simgrid::simix::unmarshal_raw<sg_size_t>(simcall->args[1]);
1205 }
1206 static inline void simcall_storage_write__set__size(smx_simcall_t simcall, sg_size_t arg)
1207 {
1208   simgrid::simix::marshal<sg_size_t>(simcall->args[1], arg);
1209 }
1210 static inline sg_size_t simcall_storage_write__get__result(smx_simcall_t simcall)
1211 {
1212   return simgrid::simix::unmarshal<sg_size_t>(simcall->result);
1213 }
1214 static inline sg_size_t simcall_storage_write__getraw__result(smx_simcall_t simcall)
1215 {
1216   return simgrid::simix::unmarshal_raw<sg_size_t>(simcall->result);
1217 }
1218 static inline void simcall_storage_write__set__result(smx_simcall_t simcall, sg_size_t result)
1219 {
1220   simgrid::simix::marshal<sg_size_t>(simcall->result, result);
1221 }
1222
1223 static inline int simcall_mc_random__get__min(smx_simcall_t simcall)
1224 {
1225   return simgrid::simix::unmarshal<int>(simcall->args[0]);
1226 }
1227 static inline int simcall_mc_random__getraw__min(smx_simcall_t simcall)
1228 {
1229   return simgrid::simix::unmarshal_raw<int>(simcall->args[0]);
1230 }
1231 static inline void simcall_mc_random__set__min(smx_simcall_t simcall, int arg)
1232 {
1233   simgrid::simix::marshal<int>(simcall->args[0], arg);
1234 }
1235 static inline int simcall_mc_random__get__max(smx_simcall_t simcall)
1236 {
1237   return simgrid::simix::unmarshal<int>(simcall->args[1]);
1238 }
1239 static inline int simcall_mc_random__getraw__max(smx_simcall_t simcall)
1240 {
1241   return simgrid::simix::unmarshal_raw<int>(simcall->args[1]);
1242 }
1243 static inline void simcall_mc_random__set__max(smx_simcall_t simcall, int arg)
1244 {
1245   simgrid::simix::marshal<int>(simcall->args[1], arg);
1246 }
1247 static inline int simcall_mc_random__get__result(smx_simcall_t simcall)
1248 {
1249   return simgrid::simix::unmarshal<int>(simcall->result);
1250 }
1251 static inline int simcall_mc_random__getraw__result(smx_simcall_t simcall)
1252 {
1253   return simgrid::simix::unmarshal_raw<int>(simcall->result);
1254 }
1255 static inline void simcall_mc_random__set__result(smx_simcall_t simcall, int result)
1256 {
1257   simgrid::simix::marshal<int>(simcall->result, result);
1258 }
1259
1260 static inline std::function<void()> const* simcall_run_kernel__get__code(smx_simcall_t simcall)
1261 {
1262   return simgrid::simix::unmarshal<std::function<void()> const*>(simcall->args[0]);
1263 }
1264 static inline std::function<void()> const* simcall_run_kernel__getraw__code(smx_simcall_t simcall)
1265 {
1266   return simgrid::simix::unmarshal_raw<std::function<void()> const*>(simcall->args[0]);
1267 }
1268 static inline void simcall_run_kernel__set__code(smx_simcall_t simcall, std::function<void()> const* arg)
1269 {
1270   simgrid::simix::marshal<std::function<void()> const*>(simcall->args[0], arg);
1271 }
1272
1273 static inline std::function<void()> const* simcall_run_blocking__get__code(smx_simcall_t simcall)
1274 {
1275   return simgrid::simix::unmarshal<std::function<void()> const*>(simcall->args[0]);
1276 }
1277 static inline std::function<void()> const* simcall_run_blocking__getraw__code(smx_simcall_t simcall)
1278 {
1279   return simgrid::simix::unmarshal_raw<std::function<void()> const*>(simcall->args[0]);
1280 }
1281 static inline void simcall_run_blocking__set__code(smx_simcall_t simcall, std::function<void()> const* arg)
1282 {
1283   simgrid::simix::marshal<std::function<void()> const*>(simcall->args[0], arg);
1284 }
1285
1286 /* The prototype of all simcall handlers, automatically generated for you */
1287
1288 XBT_PRIVATE void simcall_HANDLER_process_suspend(smx_simcall_t simcall, smx_actor_t process);
1289 XBT_PRIVATE void simcall_HANDLER_process_join(smx_simcall_t simcall, smx_actor_t process, double timeout);
1290 XBT_PRIVATE void simcall_HANDLER_process_sleep(smx_simcall_t simcall, double duration);
1291 XBT_PRIVATE void simcall_HANDLER_execution_wait(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> execution);
1292 XBT_PRIVATE void
1293 simcall_HANDLER_execution_test(smx_simcall_t simcall,
1294                                boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> execution);
1295 XBT_PRIVATE boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_HANDLER_comm_iprobe(smx_simcall_t simcall, smx_mailbox_t mbox, int type, simix_match_func_t match_fun, void* data);
1296 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);
1297 XBT_PRIVATE boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_HANDLER_comm_isend(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_clean_func_t clean_fun, simix_copy_data_func_t copy_data_fun, void* data, int detached);
1298 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);
1299 XBT_PRIVATE boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_HANDLER_comm_irecv(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 rate);
1300 XBT_PRIVATE void simcall_HANDLER_comm_waitany(smx_simcall_t simcall, xbt_dynar_t comms, double timeout);
1301 XBT_PRIVATE void simcall_HANDLER_comm_wait(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> comm, double timeout);
1302 XBT_PRIVATE void simcall_HANDLER_comm_test(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> comm);
1303 XBT_PRIVATE void simcall_HANDLER_comm_testany(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>* comms, size_t count);
1304 XBT_PRIVATE void simcall_HANDLER_mutex_lock(smx_simcall_t simcall, smx_mutex_t mutex);
1305 XBT_PRIVATE int simcall_HANDLER_mutex_trylock(smx_simcall_t simcall, smx_mutex_t mutex);
1306 XBT_PRIVATE void simcall_HANDLER_mutex_unlock(smx_simcall_t simcall, smx_mutex_t mutex);
1307 XBT_PRIVATE void simcall_HANDLER_cond_wait(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex);
1308 XBT_PRIVATE void simcall_HANDLER_cond_wait_timeout(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex, double timeout);
1309 XBT_PRIVATE void simcall_HANDLER_sem_acquire(smx_simcall_t simcall, smx_sem_t sem);
1310 XBT_PRIVATE void simcall_HANDLER_sem_acquire_timeout(smx_simcall_t simcall, smx_sem_t sem, double timeout);
1311 XBT_PRIVATE void simcall_HANDLER_storage_read(smx_simcall_t simcall, surf_storage_t st, sg_size_t size);
1312 XBT_PRIVATE void simcall_HANDLER_storage_write(smx_simcall_t simcall, surf_storage_t st, sg_size_t size);
1313 XBT_PRIVATE int simcall_HANDLER_mc_random(smx_simcall_t simcall, int min, int max);