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