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