src/simix/popping_accessors.hpp

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