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