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