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-2020. 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 simgrid::kernel::activity::ExecImpl* simcall_execution_wait__get__execution(smx_simcall_t simcall)
  19 {
  20   return simgrid::simix::unmarshal<simgrid::kernel::activity::ExecImpl*>(simcall->args_[0]);
  21 }
  22 static inline simgrid::kernel::activity::ExecImpl* simcall_execution_wait__getraw__execution(smx_simcall_t simcall)
  23 {
  24   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ExecImpl*>(simcall->args_[0]);
  25 }
  26 static inline void simcall_execution_wait__set__execution(smx_simcall_t simcall, simgrid::kernel::activity::ExecImpl* arg)
  27 {
  28   simgrid::simix::marshal<simgrid::kernel::activity::ExecImpl*>(simcall->args_[0], arg);
  29 }
  30 static inline double simcall_execution_wait__get__timeout(smx_simcall_t simcall)
  31 {
  32   return simgrid::simix::unmarshal<double>(simcall->args_[1]);
  33 }
  34 static inline double simcall_execution_wait__getraw__timeout(smx_simcall_t simcall)
  35 {
  36   return simgrid::simix::unmarshal_raw<double>(simcall->args_[1]);
  37 }
  38 static inline void simcall_execution_wait__set__timeout(smx_simcall_t simcall, double arg)
  39 {
  40   simgrid::simix::marshal<double>(simcall->args_[1], arg);
  41 }
  42 static inline int simcall_execution_wait__get__result(smx_simcall_t simcall)
  43 {
  44   return simgrid::simix::unmarshal<int>(simcall->result_);
  45 }
  46 static inline int simcall_execution_wait__getraw__result(smx_simcall_t simcall)
  47 {
  48   return simgrid::simix::unmarshal_raw<int>(simcall->result_);
  49 }
  50 static inline void simcall_execution_wait__set__result(smx_simcall_t simcall, int result)
  51 {
  52   simgrid::simix::marshal<int>(simcall->result_, result);
  53 }
  54
  55 static inline simgrid::kernel::activity::ExecImpl** simcall_execution_waitany_for__get__execs(smx_simcall_t simcall)
  56 {
  57   return simgrid::simix::unmarshal<simgrid::kernel::activity::ExecImpl**>(simcall->args_[0]);
  58 }
  59 static inline simgrid::kernel::activity::ExecImpl** simcall_execution_waitany_for__getraw__execs(smx_simcall_t simcall)
  60 {
  61   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ExecImpl**>(simcall->args_[0]);
  62 }
  63 static inline void simcall_execution_waitany_for__set__execs(smx_simcall_t simcall, simgrid::kernel::activity::ExecImpl** arg)
  64 {
  65   simgrid::simix::marshal<simgrid::kernel::activity::ExecImpl**>(simcall->args_[0], arg);
  66 }
  67 static inline size_t simcall_execution_waitany_for__get__count(smx_simcall_t simcall)
  68 {
  69   return simgrid::simix::unmarshal<size_t>(simcall->args_[1]);
  70 }
  71 static inline size_t simcall_execution_waitany_for__getraw__count(smx_simcall_t simcall)
  72 {
  73   return simgrid::simix::unmarshal_raw<size_t>(simcall->args_[1]);
  74 }
  75 static inline void simcall_execution_waitany_for__set__count(smx_simcall_t simcall, size_t arg)
  76 {
  77   simgrid::simix::marshal<size_t>(simcall->args_[1], arg);
  78 }
  79 static inline double simcall_execution_waitany_for__get__timeout(smx_simcall_t simcall)
  80 {
  81   return simgrid::simix::unmarshal<double>(simcall->args_[2]);
  82 }
  83 static inline double simcall_execution_waitany_for__getraw__timeout(smx_simcall_t simcall)
  84 {
  85   return simgrid::simix::unmarshal_raw<double>(simcall->args_[2]);
  86 }
  87 static inline void simcall_execution_waitany_for__set__timeout(smx_simcall_t simcall, double arg)
  88 {
  89   simgrid::simix::marshal<double>(simcall->args_[2], arg);
  90 }
  91 static inline int simcall_execution_waitany_for__get__result(smx_simcall_t simcall)
  92 {
  93   return simgrid::simix::unmarshal<int>(simcall->result_);
  94 }
  95 static inline int simcall_execution_waitany_for__getraw__result(smx_simcall_t simcall)
  96 {
  97   return simgrid::simix::unmarshal_raw<int>(simcall->result_);
  98 }
  99 static inline void simcall_execution_waitany_for__set__result(smx_simcall_t simcall, int result)
 100 {
 101   simgrid::simix::marshal<int>(simcall->result_, result);
 102 }
 103
 104 static inline smx_actor_t simcall_comm_send__get__sender(smx_simcall_t simcall)
 105 {
 106   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args_[0]);
 107 }
 108 static inline smx_actor_t simcall_comm_send__getraw__sender(smx_simcall_t simcall)
 109 {
 110   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args_[0]);
 111 }
 112 static inline void simcall_comm_send__set__sender(smx_simcall_t simcall, smx_actor_t arg)
 113 {
 114   simgrid::simix::marshal<smx_actor_t>(simcall->args_[0], arg);
 115 }
 116 static inline smx_mailbox_t simcall_comm_send__get__mbox(smx_simcall_t simcall)
 117 {
 118   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args_[1]);
 119 }
 120 static inline smx_mailbox_t simcall_comm_send__getraw__mbox(smx_simcall_t simcall)
 121 {
 122   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args_[1]);
 123 }
 124 static inline void simcall_comm_send__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
 125 {
 126   simgrid::simix::marshal<smx_mailbox_t>(simcall->args_[1], arg);
 127 }
 128 static inline double simcall_comm_send__get__task_size(smx_simcall_t simcall)
 129 {
 130   return simgrid::simix::unmarshal<double>(simcall->args_[2]);
 131 }
 132 static inline double simcall_comm_send__getraw__task_size(smx_simcall_t simcall)
 133 {
 134   return simgrid::simix::unmarshal_raw<double>(simcall->args_[2]);
 135 }
 136 static inline void simcall_comm_send__set__task_size(smx_simcall_t simcall, double arg)
 137 {
 138   simgrid::simix::marshal<double>(simcall->args_[2], arg);
 139 }
 140 static inline double simcall_comm_send__get__rate(smx_simcall_t simcall)
 141 {
 142   return simgrid::simix::unmarshal<double>(simcall->args_[3]);
 143 }
 144 static inline double simcall_comm_send__getraw__rate(smx_simcall_t simcall)
 145 {
 146   return simgrid::simix::unmarshal_raw<double>(simcall->args_[3]);
 147 }
 148 static inline void simcall_comm_send__set__rate(smx_simcall_t simcall, double arg)
 149 {
 150   simgrid::simix::marshal<double>(simcall->args_[3], arg);
 151 }
 152 static inline unsigned char* simcall_comm_send__get__src_buff(smx_simcall_t simcall)
 153 {
 154   return simgrid::simix::unmarshal<unsigned char*>(simcall->args_[4]);
 155 }
 156 static inline unsigned char* simcall_comm_send__getraw__src_buff(smx_simcall_t simcall)
 157 {
 158   return simgrid::simix::unmarshal_raw<unsigned char*>(simcall->args_[4]);
 159 }
 160 static inline void simcall_comm_send__set__src_buff(smx_simcall_t simcall, unsigned char* arg)
 161 {
 162   simgrid::simix::marshal<unsigned char*>(simcall->args_[4], arg);
 163 }
 164 static inline size_t simcall_comm_send__get__src_buff_size(smx_simcall_t simcall)
 165 {
 166   return simgrid::simix::unmarshal<size_t>(simcall->args_[5]);
 167 }
 168 static inline size_t simcall_comm_send__getraw__src_buff_size(smx_simcall_t simcall)
 169 {
 170   return simgrid::simix::unmarshal_raw<size_t>(simcall->args_[5]);
 171 }
 172 static inline void simcall_comm_send__set__src_buff_size(smx_simcall_t simcall, size_t arg)
 173 {
 174   simgrid::simix::marshal<size_t>(simcall->args_[5], arg);
 175 }
 176 static inline simix_match_func_t simcall_comm_send__get__match_fun(smx_simcall_t simcall)
 177 {
 178   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args_[6]);
 179 }
 180 static inline simix_match_func_t simcall_comm_send__getraw__match_fun(smx_simcall_t simcall)
 181 {
 182   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args_[6]);
 183 }
 184 static inline void simcall_comm_send__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
 185 {
 186   simgrid::simix::marshal<simix_match_func_t>(simcall->args_[6], arg);
 187 }
 188 static inline simix_copy_data_func_t simcall_comm_send__get__copy_data_fun(smx_simcall_t simcall)
 189 {
 190   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args_[7]);
 191 }
 192 static inline simix_copy_data_func_t simcall_comm_send__getraw__copy_data_fun(smx_simcall_t simcall)
 193 {
 194   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args_[7]);
 195 }
 196 static inline void simcall_comm_send__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
 197 {
 198   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args_[7], arg);
 199 }
 200 static inline void* simcall_comm_send__get__data(smx_simcall_t simcall)
 201 {
 202   return simgrid::simix::unmarshal<void*>(simcall->args_[8]);
 203 }
 204 static inline void* simcall_comm_send__getraw__data(smx_simcall_t simcall)
 205 {
 206   return simgrid::simix::unmarshal_raw<void*>(simcall->args_[8]);
 207 }
 208 static inline void simcall_comm_send__set__data(smx_simcall_t simcall, void* arg)
 209 {
 210   simgrid::simix::marshal<void*>(simcall->args_[8], arg);
 211 }
 212 static inline double simcall_comm_send__get__timeout(smx_simcall_t simcall)
 213 {
 214   return simgrid::simix::unmarshal<double>(simcall->args_[9]);
 215 }
 216 static inline double simcall_comm_send__getraw__timeout(smx_simcall_t simcall)
 217 {
 218   return simgrid::simix::unmarshal_raw<double>(simcall->args_[9]);
 219 }
 220 static inline void simcall_comm_send__set__timeout(smx_simcall_t simcall, double arg)
 221 {
 222   simgrid::simix::marshal<double>(simcall->args_[9], arg);
 223 }
 224
 225 static inline smx_actor_t simcall_comm_isend__get__sender(smx_simcall_t simcall)
 226 {
 227   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args_[0]);
 228 }
 229 static inline smx_actor_t simcall_comm_isend__getraw__sender(smx_simcall_t simcall)
 230 {
 231   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args_[0]);
 232 }
 233 static inline void simcall_comm_isend__set__sender(smx_simcall_t simcall, smx_actor_t arg)
 234 {
 235   simgrid::simix::marshal<smx_actor_t>(simcall->args_[0], arg);
 236 }
 237 static inline smx_mailbox_t simcall_comm_isend__get__mbox(smx_simcall_t simcall)
 238 {
 239   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args_[1]);
 240 }
 241 static inline smx_mailbox_t simcall_comm_isend__getraw__mbox(smx_simcall_t simcall)
 242 {
 243   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args_[1]);
 244 }
 245 static inline void simcall_comm_isend__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
 246 {
 247   simgrid::simix::marshal<smx_mailbox_t>(simcall->args_[1], arg);
 248 }
 249 static inline double simcall_comm_isend__get__task_size(smx_simcall_t simcall)
 250 {
 251   return simgrid::simix::unmarshal<double>(simcall->args_[2]);
 252 }
 253 static inline double simcall_comm_isend__getraw__task_size(smx_simcall_t simcall)
 254 {
 255   return simgrid::simix::unmarshal_raw<double>(simcall->args_[2]);
 256 }
 257 static inline void simcall_comm_isend__set__task_size(smx_simcall_t simcall, double arg)
 258 {
 259   simgrid::simix::marshal<double>(simcall->args_[2], arg);
 260 }
 261 static inline double simcall_comm_isend__get__rate(smx_simcall_t simcall)
 262 {
 263   return simgrid::simix::unmarshal<double>(simcall->args_[3]);
 264 }
 265 static inline double simcall_comm_isend__getraw__rate(smx_simcall_t simcall)
 266 {
 267   return simgrid::simix::unmarshal_raw<double>(simcall->args_[3]);
 268 }
 269 static inline void simcall_comm_isend__set__rate(smx_simcall_t simcall, double arg)
 270 {
 271   simgrid::simix::marshal<double>(simcall->args_[3], arg);
 272 }
 273 static inline unsigned char* simcall_comm_isend__get__src_buff(smx_simcall_t simcall)
 274 {
 275   return simgrid::simix::unmarshal<unsigned char*>(simcall->args_[4]);
 276 }
 277 static inline unsigned char* simcall_comm_isend__getraw__src_buff(smx_simcall_t simcall)
 278 {
 279   return simgrid::simix::unmarshal_raw<unsigned char*>(simcall->args_[4]);
 280 }
 281 static inline void simcall_comm_isend__set__src_buff(smx_simcall_t simcall, unsigned char* arg)
 282 {
 283   simgrid::simix::marshal<unsigned char*>(simcall->args_[4], arg);
 284 }
 285 static inline size_t simcall_comm_isend__get__src_buff_size(smx_simcall_t simcall)
 286 {
 287   return simgrid::simix::unmarshal<size_t>(simcall->args_[5]);
 288 }
 289 static inline size_t simcall_comm_isend__getraw__src_buff_size(smx_simcall_t simcall)
 290 {
 291   return simgrid::simix::unmarshal_raw<size_t>(simcall->args_[5]);
 292 }
 293 static inline void simcall_comm_isend__set__src_buff_size(smx_simcall_t simcall, size_t arg)
 294 {
 295   simgrid::simix::marshal<size_t>(simcall->args_[5], arg);
 296 }
 297 static inline simix_match_func_t simcall_comm_isend__get__match_fun(smx_simcall_t simcall)
 298 {
 299   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args_[6]);
 300 }
 301 static inline simix_match_func_t simcall_comm_isend__getraw__match_fun(smx_simcall_t simcall)
 302 {
 303   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args_[6]);
 304 }
 305 static inline void simcall_comm_isend__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
 306 {
 307   simgrid::simix::marshal<simix_match_func_t>(simcall->args_[6], arg);
 308 }
 309 static inline simix_clean_func_t simcall_comm_isend__get__clean_fun(smx_simcall_t simcall)
 310 {
 311   return simgrid::simix::unmarshal<simix_clean_func_t>(simcall->args_[7]);
 312 }
 313 static inline simix_clean_func_t simcall_comm_isend__getraw__clean_fun(smx_simcall_t simcall)
 314 {
 315   return simgrid::simix::unmarshal_raw<simix_clean_func_t>(simcall->args_[7]);
 316 }
 317 static inline void simcall_comm_isend__set__clean_fun(smx_simcall_t simcall, simix_clean_func_t arg)
 318 {
 319   simgrid::simix::marshal<simix_clean_func_t>(simcall->args_[7], arg);
 320 }
 321 static inline simix_copy_data_func_t simcall_comm_isend__get__copy_data_fun(smx_simcall_t simcall)
 322 {
 323   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args_[8]);
 324 }
 325 static inline simix_copy_data_func_t simcall_comm_isend__getraw__copy_data_fun(smx_simcall_t simcall)
 326 {
 327   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args_[8]);
 328 }
 329 static inline void simcall_comm_isend__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
 330 {
 331   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args_[8], arg);
 332 }
 333 static inline void* simcall_comm_isend__get__data(smx_simcall_t simcall)
 334 {
 335   return simgrid::simix::unmarshal<void*>(simcall->args_[9]);
 336 }
 337 static inline void* simcall_comm_isend__getraw__data(smx_simcall_t simcall)
 338 {
 339   return simgrid::simix::unmarshal_raw<void*>(simcall->args_[9]);
 340 }
 341 static inline void simcall_comm_isend__set__data(smx_simcall_t simcall, void* arg)
 342 {
 343   simgrid::simix::marshal<void*>(simcall->args_[9], arg);
 344 }
 345 static inline bool simcall_comm_isend__get__detached(smx_simcall_t simcall)
 346 {
 347   return simgrid::simix::unmarshal<bool>(simcall->args_[10]);
 348 }
 349 static inline bool simcall_comm_isend__getraw__detached(smx_simcall_t simcall)
 350 {
 351   return simgrid::simix::unmarshal_raw<bool>(simcall->args_[10]);
 352 }
 353 static inline void simcall_comm_isend__set__detached(smx_simcall_t simcall, bool arg)
 354 {
 355   simgrid::simix::marshal<bool>(simcall->args_[10], arg);
 356 }
 357 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_comm_isend__get__result(smx_simcall_t simcall)
 358 {
 359   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result_);
 360 }
 361 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_isend__getraw__result(smx_simcall_t simcall)
 362 {
 363   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->result_);
 364 }
 365 static inline void simcall_comm_isend__set__result(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> result)
 366 {
 367   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result_, result);
 368 }
 369
 370 static inline smx_actor_t simcall_comm_recv__get__receiver(smx_simcall_t simcall)
 371 {
 372   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args_[0]);
 373 }
 374 static inline smx_actor_t simcall_comm_recv__getraw__receiver(smx_simcall_t simcall)
 375 {
 376   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args_[0]);
 377 }
 378 static inline void simcall_comm_recv__set__receiver(smx_simcall_t simcall, smx_actor_t arg)
 379 {
 380   simgrid::simix::marshal<smx_actor_t>(simcall->args_[0], arg);
 381 }
 382 static inline smx_mailbox_t simcall_comm_recv__get__mbox(smx_simcall_t simcall)
 383 {
 384   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args_[1]);
 385 }
 386 static inline smx_mailbox_t simcall_comm_recv__getraw__mbox(smx_simcall_t simcall)
 387 {
 388   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args_[1]);
 389 }
 390 static inline void simcall_comm_recv__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
 391 {
 392   simgrid::simix::marshal<smx_mailbox_t>(simcall->args_[1], arg);
 393 }
 394 static inline unsigned char* simcall_comm_recv__get__dst_buff(smx_simcall_t simcall)
 395 {
 396   return simgrid::simix::unmarshal<unsigned char*>(simcall->args_[2]);
 397 }
 398 static inline unsigned char* simcall_comm_recv__getraw__dst_buff(smx_simcall_t simcall)
 399 {
 400   return simgrid::simix::unmarshal_raw<unsigned char*>(simcall->args_[2]);
 401 }
 402 static inline void simcall_comm_recv__set__dst_buff(smx_simcall_t simcall, unsigned char* arg)
 403 {
 404   simgrid::simix::marshal<unsigned char*>(simcall->args_[2], arg);
 405 }
 406 static inline size_t* simcall_comm_recv__get__dst_buff_size(smx_simcall_t simcall)
 407 {
 408   return simgrid::simix::unmarshal<size_t*>(simcall->args_[3]);
 409 }
 410 static inline size_t* simcall_comm_recv__getraw__dst_buff_size(smx_simcall_t simcall)
 411 {
 412   return simgrid::simix::unmarshal_raw<size_t*>(simcall->args_[3]);
 413 }
 414 static inline void simcall_comm_recv__set__dst_buff_size(smx_simcall_t simcall, size_t* arg)
 415 {
 416   simgrid::simix::marshal<size_t*>(simcall->args_[3], arg);
 417 }
 418 static inline simix_match_func_t simcall_comm_recv__get__match_fun(smx_simcall_t simcall)
 419 {
 420   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args_[4]);
 421 }
 422 static inline simix_match_func_t simcall_comm_recv__getraw__match_fun(smx_simcall_t simcall)
 423 {
 424   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args_[4]);
 425 }
 426 static inline void simcall_comm_recv__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
 427 {
 428   simgrid::simix::marshal<simix_match_func_t>(simcall->args_[4], arg);
 429 }
 430 static inline simix_copy_data_func_t simcall_comm_recv__get__copy_data_fun(smx_simcall_t simcall)
 431 {
 432   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args_[5]);
 433 }
 434 static inline simix_copy_data_func_t simcall_comm_recv__getraw__copy_data_fun(smx_simcall_t simcall)
 435 {
 436   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args_[5]);
 437 }
 438 static inline void simcall_comm_recv__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
 439 {
 440   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args_[5], arg);
 441 }
 442 static inline void* simcall_comm_recv__get__data(smx_simcall_t simcall)
 443 {
 444   return simgrid::simix::unmarshal<void*>(simcall->args_[6]);
 445 }
 446 static inline void* simcall_comm_recv__getraw__data(smx_simcall_t simcall)
 447 {
 448   return simgrid::simix::unmarshal_raw<void*>(simcall->args_[6]);
 449 }
 450 static inline void simcall_comm_recv__set__data(smx_simcall_t simcall, void* arg)
 451 {
 452   simgrid::simix::marshal<void*>(simcall->args_[6], arg);
 453 }
 454 static inline double simcall_comm_recv__get__timeout(smx_simcall_t simcall)
 455 {
 456   return simgrid::simix::unmarshal<double>(simcall->args_[7]);
 457 }
 458 static inline double simcall_comm_recv__getraw__timeout(smx_simcall_t simcall)
 459 {
 460   return simgrid::simix::unmarshal_raw<double>(simcall->args_[7]);
 461 }
 462 static inline void simcall_comm_recv__set__timeout(smx_simcall_t simcall, double arg)
 463 {
 464   simgrid::simix::marshal<double>(simcall->args_[7], arg);
 465 }
 466 static inline double simcall_comm_recv__get__rate(smx_simcall_t simcall)
 467 {
 468   return simgrid::simix::unmarshal<double>(simcall->args_[8]);
 469 }
 470 static inline double simcall_comm_recv__getraw__rate(smx_simcall_t simcall)
 471 {
 472   return simgrid::simix::unmarshal_raw<double>(simcall->args_[8]);
 473 }
 474 static inline void simcall_comm_recv__set__rate(smx_simcall_t simcall, double arg)
 475 {
 476   simgrid::simix::marshal<double>(simcall->args_[8], arg);
 477 }
 478
 479 static inline smx_actor_t simcall_comm_irecv__get__receiver(smx_simcall_t simcall)
 480 {
 481   return simgrid::simix::unmarshal<smx_actor_t>(simcall->args_[0]);
 482 }
 483 static inline smx_actor_t simcall_comm_irecv__getraw__receiver(smx_simcall_t simcall)
 484 {
 485   return simgrid::simix::unmarshal_raw<smx_actor_t>(simcall->args_[0]);
 486 }
 487 static inline void simcall_comm_irecv__set__receiver(smx_simcall_t simcall, smx_actor_t arg)
 488 {
 489   simgrid::simix::marshal<smx_actor_t>(simcall->args_[0], arg);
 490 }
 491 static inline smx_mailbox_t simcall_comm_irecv__get__mbox(smx_simcall_t simcall)
 492 {
 493   return simgrid::simix::unmarshal<smx_mailbox_t>(simcall->args_[1]);
 494 }
 495 static inline smx_mailbox_t simcall_comm_irecv__getraw__mbox(smx_simcall_t simcall)
 496 {
 497   return simgrid::simix::unmarshal_raw<smx_mailbox_t>(simcall->args_[1]);
 498 }
 499 static inline void simcall_comm_irecv__set__mbox(smx_simcall_t simcall, smx_mailbox_t arg)
 500 {
 501   simgrid::simix::marshal<smx_mailbox_t>(simcall->args_[1], arg);
 502 }
 503 static inline unsigned char* simcall_comm_irecv__get__dst_buff(smx_simcall_t simcall)
 504 {
 505   return simgrid::simix::unmarshal<unsigned char*>(simcall->args_[2]);
 506 }
 507 static inline unsigned char* simcall_comm_irecv__getraw__dst_buff(smx_simcall_t simcall)
 508 {
 509   return simgrid::simix::unmarshal_raw<unsigned char*>(simcall->args_[2]);
 510 }
 511 static inline void simcall_comm_irecv__set__dst_buff(smx_simcall_t simcall, unsigned char* arg)
 512 {
 513   simgrid::simix::marshal<unsigned char*>(simcall->args_[2], arg);
 514 }
 515 static inline size_t* simcall_comm_irecv__get__dst_buff_size(smx_simcall_t simcall)
 516 {
 517   return simgrid::simix::unmarshal<size_t*>(simcall->args_[3]);
 518 }
 519 static inline size_t* simcall_comm_irecv__getraw__dst_buff_size(smx_simcall_t simcall)
 520 {
 521   return simgrid::simix::unmarshal_raw<size_t*>(simcall->args_[3]);
 522 }
 523 static inline void simcall_comm_irecv__set__dst_buff_size(smx_simcall_t simcall, size_t* arg)
 524 {
 525   simgrid::simix::marshal<size_t*>(simcall->args_[3], arg);
 526 }
 527 static inline simix_match_func_t simcall_comm_irecv__get__match_fun(smx_simcall_t simcall)
 528 {
 529   return simgrid::simix::unmarshal<simix_match_func_t>(simcall->args_[4]);
 530 }
 531 static inline simix_match_func_t simcall_comm_irecv__getraw__match_fun(smx_simcall_t simcall)
 532 {
 533   return simgrid::simix::unmarshal_raw<simix_match_func_t>(simcall->args_[4]);
 534 }
 535 static inline void simcall_comm_irecv__set__match_fun(smx_simcall_t simcall, simix_match_func_t arg)
 536 {
 537   simgrid::simix::marshal<simix_match_func_t>(simcall->args_[4], arg);
 538 }
 539 static inline simix_copy_data_func_t simcall_comm_irecv__get__copy_data_fun(smx_simcall_t simcall)
 540 {
 541   return simgrid::simix::unmarshal<simix_copy_data_func_t>(simcall->args_[5]);
 542 }
 543 static inline simix_copy_data_func_t simcall_comm_irecv__getraw__copy_data_fun(smx_simcall_t simcall)
 544 {
 545   return simgrid::simix::unmarshal_raw<simix_copy_data_func_t>(simcall->args_[5]);
 546 }
 547 static inline void simcall_comm_irecv__set__copy_data_fun(smx_simcall_t simcall, simix_copy_data_func_t arg)
 548 {
 549   simgrid::simix::marshal<simix_copy_data_func_t>(simcall->args_[5], arg);
 550 }
 551 static inline void* simcall_comm_irecv__get__data(smx_simcall_t simcall)
 552 {
 553   return simgrid::simix::unmarshal<void*>(simcall->args_[6]);
 554 }
 555 static inline void* simcall_comm_irecv__getraw__data(smx_simcall_t simcall)
 556 {
 557   return simgrid::simix::unmarshal_raw<void*>(simcall->args_[6]);
 558 }
 559 static inline void simcall_comm_irecv__set__data(smx_simcall_t simcall, void* arg)
 560 {
 561   simgrid::simix::marshal<void*>(simcall->args_[6], arg);
 562 }
 563 static inline double simcall_comm_irecv__get__rate(smx_simcall_t simcall)
 564 {
 565   return simgrid::simix::unmarshal<double>(simcall->args_[7]);
 566 }
 567 static inline double simcall_comm_irecv__getraw__rate(smx_simcall_t simcall)
 568 {
 569   return simgrid::simix::unmarshal_raw<double>(simcall->args_[7]);
 570 }
 571 static inline void simcall_comm_irecv__set__rate(smx_simcall_t simcall, double arg)
 572 {
 573   simgrid::simix::marshal<double>(simcall->args_[7], arg);
 574 }
 575 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_comm_irecv__get__result(smx_simcall_t simcall)
 576 {
 577   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result_);
 578 }
 579 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_irecv__getraw__result(smx_simcall_t simcall)
 580 {
 581   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->result_);
 582 }
 583 static inline void simcall_comm_irecv__set__result(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> result)
 584 {
 585   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->result_, result);
 586 }
 587
 588 static inline simgrid::kernel::activity::CommImpl** simcall_comm_waitany__get__comms(smx_simcall_t simcall)
 589 {
 590   return simgrid::simix::unmarshal<simgrid::kernel::activity::CommImpl**>(simcall->args_[0]);
 591 }
 592 static inline simgrid::kernel::activity::CommImpl** simcall_comm_waitany__getraw__comms(smx_simcall_t simcall)
 593 {
 594   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::CommImpl**>(simcall->args_[0]);
 595 }
 596 static inline void simcall_comm_waitany__set__comms(smx_simcall_t simcall, simgrid::kernel::activity::CommImpl** arg)
 597 {
 598   simgrid::simix::marshal<simgrid::kernel::activity::CommImpl**>(simcall->args_[0], arg);
 599 }
 600 static inline size_t simcall_comm_waitany__get__count(smx_simcall_t simcall)
 601 {
 602   return simgrid::simix::unmarshal<size_t>(simcall->args_[1]);
 603 }
 604 static inline size_t simcall_comm_waitany__getraw__count(smx_simcall_t simcall)
 605 {
 606   return simgrid::simix::unmarshal_raw<size_t>(simcall->args_[1]);
 607 }
 608 static inline void simcall_comm_waitany__set__count(smx_simcall_t simcall, size_t arg)
 609 {
 610   simgrid::simix::marshal<size_t>(simcall->args_[1], arg);
 611 }
 612 static inline double simcall_comm_waitany__get__timeout(smx_simcall_t simcall)
 613 {
 614   return simgrid::simix::unmarshal<double>(simcall->args_[2]);
 615 }
 616 static inline double simcall_comm_waitany__getraw__timeout(smx_simcall_t simcall)
 617 {
 618   return simgrid::simix::unmarshal_raw<double>(simcall->args_[2]);
 619 }
 620 static inline void simcall_comm_waitany__set__timeout(smx_simcall_t simcall, double arg)
 621 {
 622   simgrid::simix::marshal<double>(simcall->args_[2], arg);
 623 }
 624 static inline int simcall_comm_waitany__get__result(smx_simcall_t simcall)
 625 {
 626   return simgrid::simix::unmarshal<int>(simcall->result_);
 627 }
 628 static inline int simcall_comm_waitany__getraw__result(smx_simcall_t simcall)
 629 {
 630   return simgrid::simix::unmarshal_raw<int>(simcall->result_);
 631 }
 632 static inline void simcall_comm_waitany__set__result(smx_simcall_t simcall, int result)
 633 {
 634   simgrid::simix::marshal<int>(simcall->result_, result);
 635 }
 636
 637 static inline simgrid::kernel::activity::CommImpl* simcall_comm_wait__get__comm(smx_simcall_t simcall)
 638 {
 639   return simgrid::simix::unmarshal<simgrid::kernel::activity::CommImpl*>(simcall->args_[0]);
 640 }
 641 static inline simgrid::kernel::activity::CommImpl* simcall_comm_wait__getraw__comm(smx_simcall_t simcall)
 642 {
 643   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::CommImpl*>(simcall->args_[0]);
 644 }
 645 static inline void simcall_comm_wait__set__comm(smx_simcall_t simcall, simgrid::kernel::activity::CommImpl* arg)
 646 {
 647   simgrid::simix::marshal<simgrid::kernel::activity::CommImpl*>(simcall->args_[0], arg);
 648 }
 649 static inline double simcall_comm_wait__get__timeout(smx_simcall_t simcall)
 650 {
 651   return simgrid::simix::unmarshal<double>(simcall->args_[1]);
 652 }
 653 static inline double simcall_comm_wait__getraw__timeout(smx_simcall_t simcall)
 654 {
 655   return simgrid::simix::unmarshal_raw<double>(simcall->args_[1]);
 656 }
 657 static inline void simcall_comm_wait__set__timeout(smx_simcall_t simcall, double arg)
 658 {
 659   simgrid::simix::marshal<double>(simcall->args_[1], arg);
 660 }
 661
 662 static inline simgrid::kernel::activity::CommImpl* simcall_comm_test__get__comm(smx_simcall_t simcall)
 663 {
 664   return simgrid::simix::unmarshal<simgrid::kernel::activity::CommImpl*>(simcall->args_[0]);
 665 }
 666 static inline simgrid::kernel::activity::CommImpl* simcall_comm_test__getraw__comm(smx_simcall_t simcall)
 667 {
 668   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::CommImpl*>(simcall->args_[0]);
 669 }
 670 static inline void simcall_comm_test__set__comm(smx_simcall_t simcall, simgrid::kernel::activity::CommImpl* arg)
 671 {
 672   simgrid::simix::marshal<simgrid::kernel::activity::CommImpl*>(simcall->args_[0], arg);
 673 }
 674 static inline bool simcall_comm_test__get__result(smx_simcall_t simcall)
 675 {
 676   return simgrid::simix::unmarshal<bool>(simcall->result_);
 677 }
 678 static inline bool simcall_comm_test__getraw__result(smx_simcall_t simcall)
 679 {
 680   return simgrid::simix::unmarshal_raw<bool>(simcall->result_);
 681 }
 682 static inline void simcall_comm_test__set__result(smx_simcall_t simcall, bool result)
 683 {
 684   simgrid::simix::marshal<bool>(simcall->result_, result);
 685 }
 686
 687 static inline simgrid::kernel::activity::CommImpl** simcall_comm_testany__get__comms(smx_simcall_t simcall)
 688 {
 689   return simgrid::simix::unmarshal<simgrid::kernel::activity::CommImpl**>(simcall->args_[0]);
 690 }
 691 static inline simgrid::kernel::activity::CommImpl** simcall_comm_testany__getraw__comms(smx_simcall_t simcall)
 692 {
 693   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::CommImpl**>(simcall->args_[0]);
 694 }
 695 static inline void simcall_comm_testany__set__comms(smx_simcall_t simcall, simgrid::kernel::activity::CommImpl** arg)
 696 {
 697   simgrid::simix::marshal<simgrid::kernel::activity::CommImpl**>(simcall->args_[0], arg);
 698 }
 699 static inline size_t simcall_comm_testany__get__count(smx_simcall_t simcall)
 700 {
 701   return simgrid::simix::unmarshal<size_t>(simcall->args_[1]);
 702 }
 703 static inline size_t simcall_comm_testany__getraw__count(smx_simcall_t simcall)
 704 {
 705   return simgrid::simix::unmarshal_raw<size_t>(simcall->args_[1]);
 706 }
 707 static inline void simcall_comm_testany__set__count(smx_simcall_t simcall, size_t arg)
 708 {
 709   simgrid::simix::marshal<size_t>(simcall->args_[1], arg);
 710 }
 711 static inline int simcall_comm_testany__get__result(smx_simcall_t simcall)
 712 {
 713   return simgrid::simix::unmarshal<int>(simcall->result_);
 714 }
 715 static inline int simcall_comm_testany__getraw__result(smx_simcall_t simcall)
 716 {
 717   return simgrid::simix::unmarshal_raw<int>(simcall->result_);
 718 }
 719 static inline void simcall_comm_testany__set__result(smx_simcall_t simcall, int result)
 720 {
 721   simgrid::simix::marshal<int>(simcall->result_, result);
 722 }
 723
 724 static inline smx_mutex_t simcall_mutex_lock__get__mutex(smx_simcall_t simcall)
 725 {
 726   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args_[0]);
 727 }
 728 static inline smx_mutex_t simcall_mutex_lock__getraw__mutex(smx_simcall_t simcall)
 729 {
 730   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args_[0]);
 731 }
 732 static inline void simcall_mutex_lock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
 733 {
 734   simgrid::simix::marshal<smx_mutex_t>(simcall->args_[0], arg);
 735 }
 736
 737 static inline smx_mutex_t simcall_mutex_trylock__get__mutex(smx_simcall_t simcall)
 738 {
 739   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args_[0]);
 740 }
 741 static inline smx_mutex_t simcall_mutex_trylock__getraw__mutex(smx_simcall_t simcall)
 742 {
 743   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args_[0]);
 744 }
 745 static inline void simcall_mutex_trylock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
 746 {
 747   simgrid::simix::marshal<smx_mutex_t>(simcall->args_[0], arg);
 748 }
 749 static inline int simcall_mutex_trylock__get__result(smx_simcall_t simcall)
 750 {
 751   return simgrid::simix::unmarshal<int>(simcall->result_);
 752 }
 753 static inline int simcall_mutex_trylock__getraw__result(smx_simcall_t simcall)
 754 {
 755   return simgrid::simix::unmarshal_raw<int>(simcall->result_);
 756 }
 757 static inline void simcall_mutex_trylock__set__result(smx_simcall_t simcall, int result)
 758 {
 759   simgrid::simix::marshal<int>(simcall->result_, result);
 760 }
 761
 762 static inline smx_mutex_t simcall_mutex_unlock__get__mutex(smx_simcall_t simcall)
 763 {
 764   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args_[0]);
 765 }
 766 static inline smx_mutex_t simcall_mutex_unlock__getraw__mutex(smx_simcall_t simcall)
 767 {
 768   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args_[0]);
 769 }
 770 static inline void simcall_mutex_unlock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
 771 {
 772   simgrid::simix::marshal<smx_mutex_t>(simcall->args_[0], arg);
 773 }
 774
 775 static inline smx_cond_t simcall_cond_wait__get__cond(smx_simcall_t simcall)
 776 {
 777   return simgrid::simix::unmarshal<smx_cond_t>(simcall->args_[0]);
 778 }
 779 static inline smx_cond_t simcall_cond_wait__getraw__cond(smx_simcall_t simcall)
 780 {
 781   return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->args_[0]);
 782 }
 783 static inline void simcall_cond_wait__set__cond(smx_simcall_t simcall, smx_cond_t arg)
 784 {
 785   simgrid::simix::marshal<smx_cond_t>(simcall->args_[0], arg);
 786 }
 787 static inline smx_mutex_t simcall_cond_wait__get__mutex(smx_simcall_t simcall)
 788 {
 789   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args_[1]);
 790 }
 791 static inline smx_mutex_t simcall_cond_wait__getraw__mutex(smx_simcall_t simcall)
 792 {
 793   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args_[1]);
 794 }
 795 static inline void simcall_cond_wait__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
 796 {
 797   simgrid::simix::marshal<smx_mutex_t>(simcall->args_[1], arg);
 798 }
 799
 800 static inline smx_cond_t simcall_cond_wait_timeout__get__cond(smx_simcall_t simcall)
 801 {
 802   return simgrid::simix::unmarshal<smx_cond_t>(simcall->args_[0]);
 803 }
 804 static inline smx_cond_t simcall_cond_wait_timeout__getraw__cond(smx_simcall_t simcall)
 805 {
 806   return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->args_[0]);
 807 }
 808 static inline void simcall_cond_wait_timeout__set__cond(smx_simcall_t simcall, smx_cond_t arg)
 809 {
 810   simgrid::simix::marshal<smx_cond_t>(simcall->args_[0], arg);
 811 }
 812 static inline smx_mutex_t simcall_cond_wait_timeout__get__mutex(smx_simcall_t simcall)
 813 {
 814   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args_[1]);
 815 }
 816 static inline smx_mutex_t simcall_cond_wait_timeout__getraw__mutex(smx_simcall_t simcall)
 817 {
 818   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args_[1]);
 819 }
 820 static inline void simcall_cond_wait_timeout__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
 821 {
 822   simgrid::simix::marshal<smx_mutex_t>(simcall->args_[1], arg);
 823 }
 824 static inline double simcall_cond_wait_timeout__get__timeout(smx_simcall_t simcall)
 825 {
 826   return simgrid::simix::unmarshal<double>(simcall->args_[2]);
 827 }
 828 static inline double simcall_cond_wait_timeout__getraw__timeout(smx_simcall_t simcall)
 829 {
 830   return simgrid::simix::unmarshal_raw<double>(simcall->args_[2]);
 831 }
 832 static inline void simcall_cond_wait_timeout__set__timeout(smx_simcall_t simcall, double arg)
 833 {
 834   simgrid::simix::marshal<double>(simcall->args_[2], arg);
 835 }
 836 static inline int simcall_cond_wait_timeout__get__result(smx_simcall_t simcall)
 837 {
 838   return simgrid::simix::unmarshal<int>(simcall->result_);
 839 }
 840 static inline int simcall_cond_wait_timeout__getraw__result(smx_simcall_t simcall)
 841 {
 842   return simgrid::simix::unmarshal_raw<int>(simcall->result_);
 843 }
 844 static inline void simcall_cond_wait_timeout__set__result(smx_simcall_t simcall, int result)
 845 {
 846   simgrid::simix::marshal<int>(simcall->result_, result);
 847 }
 848
 849 static inline smx_sem_t simcall_sem_acquire__get__sem(smx_simcall_t simcall)
 850 {
 851   return simgrid::simix::unmarshal<smx_sem_t>(simcall->args_[0]);
 852 }
 853 static inline smx_sem_t simcall_sem_acquire__getraw__sem(smx_simcall_t simcall)
 854 {
 855   return simgrid::simix::unmarshal_raw<smx_sem_t>(simcall->args_[0]);
 856 }
 857 static inline void simcall_sem_acquire__set__sem(smx_simcall_t simcall, smx_sem_t arg)
 858 {
 859   simgrid::simix::marshal<smx_sem_t>(simcall->args_[0], arg);
 860 }
 861
 862 static inline smx_sem_t simcall_sem_acquire_timeout__get__sem(smx_simcall_t simcall)
 863 {
 864   return simgrid::simix::unmarshal<smx_sem_t>(simcall->args_[0]);
 865 }
 866 static inline smx_sem_t simcall_sem_acquire_timeout__getraw__sem(smx_simcall_t simcall)
 867 {
 868   return simgrid::simix::unmarshal_raw<smx_sem_t>(simcall->args_[0]);
 869 }
 870 static inline void simcall_sem_acquire_timeout__set__sem(smx_simcall_t simcall, smx_sem_t arg)
 871 {
 872   simgrid::simix::marshal<smx_sem_t>(simcall->args_[0], arg);
 873 }
 874 static inline double simcall_sem_acquire_timeout__get__timeout(smx_simcall_t simcall)
 875 {
 876   return simgrid::simix::unmarshal<double>(simcall->args_[1]);
 877 }
 878 static inline double simcall_sem_acquire_timeout__getraw__timeout(smx_simcall_t simcall)
 879 {
 880   return simgrid::simix::unmarshal_raw<double>(simcall->args_[1]);
 881 }
 882 static inline void simcall_sem_acquire_timeout__set__timeout(smx_simcall_t simcall, double arg)
 883 {
 884   simgrid::simix::marshal<double>(simcall->args_[1], arg);
 885 }
 886 static inline int simcall_sem_acquire_timeout__get__result(smx_simcall_t simcall)
 887 {
 888   return simgrid::simix::unmarshal<int>(simcall->result_);
 889 }
 890 static inline int simcall_sem_acquire_timeout__getraw__result(smx_simcall_t simcall)
 891 {
 892   return simgrid::simix::unmarshal_raw<int>(simcall->result_);
 893 }
 894 static inline void simcall_sem_acquire_timeout__set__result(smx_simcall_t simcall, int result)
 895 {
 896   simgrid::simix::marshal<int>(simcall->result_, result);
 897 }
 898
 899 static inline simgrid::kernel::activity::IoImpl* simcall_io_wait__get__io(smx_simcall_t simcall)
 900 {
 901   return simgrid::simix::unmarshal<simgrid::kernel::activity::IoImpl*>(simcall->args_[0]);
 902 }
 903 static inline simgrid::kernel::activity::IoImpl* simcall_io_wait__getraw__io(smx_simcall_t simcall)
 904 {
 905   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::IoImpl*>(simcall->args_[0]);
 906 }
 907 static inline void simcall_io_wait__set__io(smx_simcall_t simcall, simgrid::kernel::activity::IoImpl* arg)
 908 {
 909   simgrid::simix::marshal<simgrid::kernel::activity::IoImpl*>(simcall->args_[0], arg);
 910 }
 911 static inline double simcall_io_wait__get__timeout(smx_simcall_t simcall)
 912 {
 913   return simgrid::simix::unmarshal<double>(simcall->args_[1]);
 914 }
 915 static inline double simcall_io_wait__getraw__timeout(smx_simcall_t simcall)
 916 {
 917   return simgrid::simix::unmarshal_raw<double>(simcall->args_[1]);
 918 }
 919 static inline void simcall_io_wait__set__timeout(smx_simcall_t simcall, double arg)
 920 {
 921   simgrid::simix::marshal<double>(simcall->args_[1], arg);
 922 }
 923 static inline sg_size_t simcall_io_wait__get__result(smx_simcall_t simcall)
 924 {
 925   return simgrid::simix::unmarshal<sg_size_t>(simcall->result_);
 926 }
 927 static inline sg_size_t simcall_io_wait__getraw__result(smx_simcall_t simcall)
 928 {
 929   return simgrid::simix::unmarshal_raw<sg_size_t>(simcall->result_);
 930 }
 931 static inline void simcall_io_wait__set__result(smx_simcall_t simcall, sg_size_t result)
 932 {
 933   simgrid::simix::marshal<sg_size_t>(simcall->result_, result);
 934 }
 935
 936 static inline int simcall_mc_random__get__min(smx_simcall_t simcall)
 937 {
 938   return simgrid::simix::unmarshal<int>(simcall->args_[0]);
 939 }
 940 static inline int simcall_mc_random__getraw__min(smx_simcall_t simcall)
 941 {
 942   return simgrid::simix::unmarshal_raw<int>(simcall->args_[0]);
 943 }
 944 static inline void simcall_mc_random__set__min(smx_simcall_t simcall, int arg)
 945 {
 946   simgrid::simix::marshal<int>(simcall->args_[0], arg);
 947 }
 948 static inline int simcall_mc_random__get__max(smx_simcall_t simcall)
 949 {
 950   return simgrid::simix::unmarshal<int>(simcall->args_[1]);
 951 }
 952 static inline int simcall_mc_random__getraw__max(smx_simcall_t simcall)
 953 {
 954   return simgrid::simix::unmarshal_raw<int>(simcall->args_[1]);
 955 }
 956 static inline void simcall_mc_random__set__max(smx_simcall_t simcall, int arg)
 957 {
 958   simgrid::simix::marshal<int>(simcall->args_[1], arg);
 959 }
 960 static inline int simcall_mc_random__get__result(smx_simcall_t simcall)
 961 {
 962   return simgrid::simix::unmarshal<int>(simcall->result_);
 963 }
 964 static inline int simcall_mc_random__getraw__result(smx_simcall_t simcall)
 965 {
 966   return simgrid::simix::unmarshal_raw<int>(simcall->result_);
 967 }
 968 static inline void simcall_mc_random__set__result(smx_simcall_t simcall, int result)
 969 {
 970   simgrid::simix::marshal<int>(simcall->result_, result);
 971 }
 972
 973 static inline std::function<void()> const* simcall_run_kernel__get__code(smx_simcall_t simcall)
 974 {
 975   return simgrid::simix::unmarshal<std::function<void()> const*>(simcall->args_[0]);
 976 }
 977 static inline std::function<void()> const* simcall_run_kernel__getraw__code(smx_simcall_t simcall)
 978 {
 979   return simgrid::simix::unmarshal_raw<std::function<void()> const*>(simcall->args_[0]);
 980 }
 981 static inline void simcall_run_kernel__set__code(smx_simcall_t simcall, std::function<void()> const* arg)
 982 {
 983   simgrid::simix::marshal<std::function<void()> const*>(simcall->args_[0], arg);
 984 }
 985
 986 static inline std::function<void()> const* simcall_run_blocking__get__code(smx_simcall_t simcall)
 987 {
 988   return simgrid::simix::unmarshal<std::function<void()> const*>(simcall->args_[0]);
 989 }
 990 static inline std::function<void()> const* simcall_run_blocking__getraw__code(smx_simcall_t simcall)
 991 {
 992   return simgrid::simix::unmarshal_raw<std::function<void()> const*>(simcall->args_[0]);
 993 }
 994 static inline void simcall_run_blocking__set__code(smx_simcall_t simcall, std::function<void()> const* arg)
 995 {
 996   simgrid::simix::marshal<std::function<void()> const*>(simcall->args_[0], arg);
 997 }
 998
 999 /* The prototype of all simcall handlers, automatically generated for you */
1000
1001 XBT_PRIVATE void simcall_HANDLER_execution_wait(smx_simcall_t simcall, simgrid::kernel::activity::ExecImpl* execution, double timeout);
1002 XBT_PRIVATE void simcall_HANDLER_execution_waitany_for(smx_simcall_t simcall, simgrid::kernel::activity::ExecImpl** execs, size_t count, double timeout);
1003 XBT_PRIVATE void simcall_HANDLER_comm_send(smx_simcall_t simcall, smx_actor_t sender, smx_mailbox_t mbox, double task_size, double rate, unsigned char* 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);
1004 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, unsigned char* 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, bool detached);
1005 XBT_PRIVATE void simcall_HANDLER_comm_recv(smx_simcall_t simcall, smx_actor_t receiver, smx_mailbox_t mbox, unsigned char* 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);
1006 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, unsigned char* 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);
1007 XBT_PRIVATE void simcall_HANDLER_comm_waitany(smx_simcall_t simcall, simgrid::kernel::activity::CommImpl** comms, size_t count, double timeout);
1008 XBT_PRIVATE void simcall_HANDLER_comm_wait(smx_simcall_t simcall, simgrid::kernel::activity::CommImpl* comm, double timeout);
1009 XBT_PRIVATE void simcall_HANDLER_comm_test(smx_simcall_t simcall, simgrid::kernel::activity::CommImpl* comm);
1010 XBT_PRIVATE void simcall_HANDLER_comm_testany(smx_simcall_t simcall, simgrid::kernel::activity::CommImpl** comms, size_t count);
1011 XBT_PRIVATE void simcall_HANDLER_mutex_lock(smx_simcall_t simcall, smx_mutex_t mutex);
1012 XBT_PRIVATE int simcall_HANDLER_mutex_trylock(smx_simcall_t simcall, smx_mutex_t mutex);
1013 XBT_PRIVATE void simcall_HANDLER_mutex_unlock(smx_simcall_t simcall, smx_mutex_t mutex);
1014 XBT_PRIVATE void simcall_HANDLER_cond_wait(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex);
1015 XBT_PRIVATE void simcall_HANDLER_cond_wait_timeout(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex, double timeout);
1016 XBT_PRIVATE void simcall_HANDLER_sem_acquire(smx_simcall_t simcall, smx_sem_t sem);
1017 XBT_PRIVATE void simcall_HANDLER_sem_acquire_timeout(smx_simcall_t simcall, smx_sem_t sem, double timeout);
1018 XBT_PRIVATE void simcall_HANDLER_io_wait(smx_simcall_t simcall, simgrid::kernel::activity::IoImpl* io, double timeout);
1019 XBT_PRIVATE int simcall_HANDLER_mc_random(smx_simcall_t simcall, int min, int max);