src/simix/popping_accessors.hpp

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