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