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