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 xbt_dynar_t simcall_comm_waitany__get__comms(smx_simcall_t simcall)
 631 {
 632   return simgrid::simix::unmarshal<xbt_dynar_t>(simcall->args[0]);
 633 }
 634 static inline xbt_dynar_t simcall_comm_waitany__getraw__comms(smx_simcall_t simcall)
 635 {
 636   return simgrid::simix::unmarshal_raw<xbt_dynar_t>(simcall->args[0]);
 637 }
 638 static inline void simcall_comm_waitany__set__comms(smx_simcall_t simcall, xbt_dynar_t arg)
 639 {
 640   simgrid::simix::marshal<xbt_dynar_t>(simcall->args[0], arg);
 641 }
 642 static inline double simcall_comm_waitany__get__timeout(smx_simcall_t simcall)
 643 {
 644   return simgrid::simix::unmarshal<double>(simcall->args[1]);
 645 }
 646 static inline double simcall_comm_waitany__getraw__timeout(smx_simcall_t simcall)
 647 {
 648   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
 649 }
 650 static inline void simcall_comm_waitany__set__timeout(smx_simcall_t simcall, double arg)
 651 {
 652   simgrid::simix::marshal<double>(simcall->args[1], arg);
 653 }
 654 static inline int simcall_comm_waitany__get__result(smx_simcall_t simcall)
 655 {
 656   return simgrid::simix::unmarshal<int>(simcall->result);
 657 }
 658 static inline int simcall_comm_waitany__getraw__result(smx_simcall_t simcall)
 659 {
 660   return simgrid::simix::unmarshal_raw<int>(simcall->result);
 661 }
 662 static inline void simcall_comm_waitany__set__result(smx_simcall_t simcall, int result)
 663 {
 664   simgrid::simix::marshal<int>(simcall->result, result);
 665 }
 666
 667 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_comm_wait__get__comm(smx_simcall_t simcall)
 668 {
 669   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
 670 }
 671 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_wait__getraw__comm(smx_simcall_t simcall)
 672 {
 673   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
 674 }
 675 static inline void simcall_comm_wait__set__comm(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
 676 {
 677   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
 678 }
 679 static inline double simcall_comm_wait__get__timeout(smx_simcall_t simcall)
 680 {
 681   return simgrid::simix::unmarshal<double>(simcall->args[1]);
 682 }
 683 static inline double simcall_comm_wait__getraw__timeout(smx_simcall_t simcall)
 684 {
 685   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
 686 }
 687 static inline void simcall_comm_wait__set__timeout(smx_simcall_t simcall, double arg)
 688 {
 689   simgrid::simix::marshal<double>(simcall->args[1], arg);
 690 }
 691
 692 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_comm_test__get__comm(smx_simcall_t simcall)
 693 {
 694   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
 695 }
 696 static inline simgrid::kernel::activity::ActivityImpl* simcall_comm_test__getraw__comm(smx_simcall_t simcall)
 697 {
 698   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
 699 }
 700 static inline void simcall_comm_test__set__comm(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
 701 {
 702   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
 703 }
 704 static inline int simcall_comm_test__get__result(smx_simcall_t simcall)
 705 {
 706   return simgrid::simix::unmarshal<int>(simcall->result);
 707 }
 708 static inline int simcall_comm_test__getraw__result(smx_simcall_t simcall)
 709 {
 710   return simgrid::simix::unmarshal_raw<int>(simcall->result);
 711 }
 712 static inline void simcall_comm_test__set__result(smx_simcall_t simcall, int result)
 713 {
 714   simgrid::simix::marshal<int>(simcall->result, result);
 715 }
 716
 717 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>* simcall_comm_testany__get__comms(smx_simcall_t simcall)
 718 {
 719   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>*>(simcall->args[0]);
 720 }
 721 static inline simgrid::kernel::activity::ActivityImpl** simcall_comm_testany__getraw__comms(smx_simcall_t simcall)
 722 {
 723   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl**>(simcall->args[0]);
 724 }
 725 static inline void simcall_comm_testany__set__comms(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>* arg)
 726 {
 727   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>*>(simcall->args[0], arg);
 728 }
 729 static inline size_t simcall_comm_testany__get__count(smx_simcall_t simcall)
 730 {
 731   return simgrid::simix::unmarshal<size_t>(simcall->args[1]);
 732 }
 733 static inline size_t simcall_comm_testany__getraw__count(smx_simcall_t simcall)
 734 {
 735   return simgrid::simix::unmarshal_raw<size_t>(simcall->args[1]);
 736 }
 737 static inline void simcall_comm_testany__set__count(smx_simcall_t simcall, size_t arg)
 738 {
 739   simgrid::simix::marshal<size_t>(simcall->args[1], arg);
 740 }
 741 static inline int simcall_comm_testany__get__result(smx_simcall_t simcall)
 742 {
 743   return simgrid::simix::unmarshal<int>(simcall->result);
 744 }
 745 static inline int simcall_comm_testany__getraw__result(smx_simcall_t simcall)
 746 {
 747   return simgrid::simix::unmarshal_raw<int>(simcall->result);
 748 }
 749 static inline void simcall_comm_testany__set__result(smx_simcall_t simcall, int result)
 750 {
 751   simgrid::simix::marshal<int>(simcall->result, result);
 752 }
 753
 754 static inline smx_mutex_t simcall_mutex_lock__get__mutex(smx_simcall_t simcall)
 755 {
 756   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[0]);
 757 }
 758 static inline smx_mutex_t simcall_mutex_lock__getraw__mutex(smx_simcall_t simcall)
 759 {
 760   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[0]);
 761 }
 762 static inline void simcall_mutex_lock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
 763 {
 764   simgrid::simix::marshal<smx_mutex_t>(simcall->args[0], arg);
 765 }
 766
 767 static inline smx_mutex_t simcall_mutex_trylock__get__mutex(smx_simcall_t simcall)
 768 {
 769   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[0]);
 770 }
 771 static inline smx_mutex_t simcall_mutex_trylock__getraw__mutex(smx_simcall_t simcall)
 772 {
 773   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[0]);
 774 }
 775 static inline void simcall_mutex_trylock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
 776 {
 777   simgrid::simix::marshal<smx_mutex_t>(simcall->args[0], arg);
 778 }
 779 static inline int simcall_mutex_trylock__get__result(smx_simcall_t simcall)
 780 {
 781   return simgrid::simix::unmarshal<int>(simcall->result);
 782 }
 783 static inline int simcall_mutex_trylock__getraw__result(smx_simcall_t simcall)
 784 {
 785   return simgrid::simix::unmarshal_raw<int>(simcall->result);
 786 }
 787 static inline void simcall_mutex_trylock__set__result(smx_simcall_t simcall, int result)
 788 {
 789   simgrid::simix::marshal<int>(simcall->result, result);
 790 }
 791
 792 static inline smx_mutex_t simcall_mutex_unlock__get__mutex(smx_simcall_t simcall)
 793 {
 794   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[0]);
 795 }
 796 static inline smx_mutex_t simcall_mutex_unlock__getraw__mutex(smx_simcall_t simcall)
 797 {
 798   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[0]);
 799 }
 800 static inline void simcall_mutex_unlock__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
 801 {
 802   simgrid::simix::marshal<smx_mutex_t>(simcall->args[0], arg);
 803 }
 804
 805 static inline smx_cond_t simcall_cond_wait__get__cond(smx_simcall_t simcall)
 806 {
 807   return simgrid::simix::unmarshal<smx_cond_t>(simcall->args[0]);
 808 }
 809 static inline smx_cond_t simcall_cond_wait__getraw__cond(smx_simcall_t simcall)
 810 {
 811   return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->args[0]);
 812 }
 813 static inline void simcall_cond_wait__set__cond(smx_simcall_t simcall, smx_cond_t arg)
 814 {
 815   simgrid::simix::marshal<smx_cond_t>(simcall->args[0], arg);
 816 }
 817 static inline smx_mutex_t simcall_cond_wait__get__mutex(smx_simcall_t simcall)
 818 {
 819   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[1]);
 820 }
 821 static inline smx_mutex_t simcall_cond_wait__getraw__mutex(smx_simcall_t simcall)
 822 {
 823   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[1]);
 824 }
 825 static inline void simcall_cond_wait__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
 826 {
 827   simgrid::simix::marshal<smx_mutex_t>(simcall->args[1], arg);
 828 }
 829
 830 static inline smx_cond_t simcall_cond_wait_timeout__get__cond(smx_simcall_t simcall)
 831 {
 832   return simgrid::simix::unmarshal<smx_cond_t>(simcall->args[0]);
 833 }
 834 static inline smx_cond_t simcall_cond_wait_timeout__getraw__cond(smx_simcall_t simcall)
 835 {
 836   return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->args[0]);
 837 }
 838 static inline void simcall_cond_wait_timeout__set__cond(smx_simcall_t simcall, smx_cond_t arg)
 839 {
 840   simgrid::simix::marshal<smx_cond_t>(simcall->args[0], arg);
 841 }
 842 static inline smx_mutex_t simcall_cond_wait_timeout__get__mutex(smx_simcall_t simcall)
 843 {
 844   return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args[1]);
 845 }
 846 static inline smx_mutex_t simcall_cond_wait_timeout__getraw__mutex(smx_simcall_t simcall)
 847 {
 848   return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args[1]);
 849 }
 850 static inline void simcall_cond_wait_timeout__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
 851 {
 852   simgrid::simix::marshal<smx_mutex_t>(simcall->args[1], arg);
 853 }
 854 static inline double simcall_cond_wait_timeout__get__timeout(smx_simcall_t simcall)
 855 {
 856   return simgrid::simix::unmarshal<double>(simcall->args[2]);
 857 }
 858 static inline double simcall_cond_wait_timeout__getraw__timeout(smx_simcall_t simcall)
 859 {
 860   return simgrid::simix::unmarshal_raw<double>(simcall->args[2]);
 861 }
 862 static inline void simcall_cond_wait_timeout__set__timeout(smx_simcall_t simcall, double arg)
 863 {
 864   simgrid::simix::marshal<double>(simcall->args[2], arg);
 865 }
 866 static inline int simcall_cond_wait_timeout__get__result(smx_simcall_t simcall)
 867 {
 868   return simgrid::simix::unmarshal<int>(simcall->result);
 869 }
 870 static inline int simcall_cond_wait_timeout__getraw__result(smx_simcall_t simcall)
 871 {
 872   return simgrid::simix::unmarshal_raw<int>(simcall->result);
 873 }
 874 static inline void simcall_cond_wait_timeout__set__result(smx_simcall_t simcall, int result)
 875 {
 876   simgrid::simix::marshal<int>(simcall->result, result);
 877 }
 878
 879 static inline smx_sem_t simcall_sem_acquire__get__sem(smx_simcall_t simcall)
 880 {
 881   return simgrid::simix::unmarshal<smx_sem_t>(simcall->args[0]);
 882 }
 883 static inline smx_sem_t simcall_sem_acquire__getraw__sem(smx_simcall_t simcall)
 884 {
 885   return simgrid::simix::unmarshal_raw<smx_sem_t>(simcall->args[0]);
 886 }
 887 static inline void simcall_sem_acquire__set__sem(smx_simcall_t simcall, smx_sem_t arg)
 888 {
 889   simgrid::simix::marshal<smx_sem_t>(simcall->args[0], arg);
 890 }
 891
 892 static inline smx_sem_t simcall_sem_acquire_timeout__get__sem(smx_simcall_t simcall)
 893 {
 894   return simgrid::simix::unmarshal<smx_sem_t>(simcall->args[0]);
 895 }
 896 static inline smx_sem_t simcall_sem_acquire_timeout__getraw__sem(smx_simcall_t simcall)
 897 {
 898   return simgrid::simix::unmarshal_raw<smx_sem_t>(simcall->args[0]);
 899 }
 900 static inline void simcall_sem_acquire_timeout__set__sem(smx_simcall_t simcall, smx_sem_t arg)
 901 {
 902   simgrid::simix::marshal<smx_sem_t>(simcall->args[0], arg);
 903 }
 904 static inline double simcall_sem_acquire_timeout__get__timeout(smx_simcall_t simcall)
 905 {
 906   return simgrid::simix::unmarshal<double>(simcall->args[1]);
 907 }
 908 static inline double simcall_sem_acquire_timeout__getraw__timeout(smx_simcall_t simcall)
 909 {
 910   return simgrid::simix::unmarshal_raw<double>(simcall->args[1]);
 911 }
 912 static inline void simcall_sem_acquire_timeout__set__timeout(smx_simcall_t simcall, double arg)
 913 {
 914   simgrid::simix::marshal<double>(simcall->args[1], arg);
 915 }
 916 static inline int simcall_sem_acquire_timeout__get__result(smx_simcall_t simcall)
 917 {
 918   return simgrid::simix::unmarshal<int>(simcall->result);
 919 }
 920 static inline int simcall_sem_acquire_timeout__getraw__result(smx_simcall_t simcall)
 921 {
 922   return simgrid::simix::unmarshal_raw<int>(simcall->result);
 923 }
 924 static inline void simcall_sem_acquire_timeout__set__result(smx_simcall_t simcall, int result)
 925 {
 926   simgrid::simix::marshal<int>(simcall->result, result);
 927 }
 928
 929 static inline boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>
 930 simcall_io_wait__get__io(smx_simcall_t simcall)
 931 {
 932   return simgrid::simix::unmarshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0]);
 933 }
 934 static inline simgrid::kernel::activity::ActivityImpl* simcall_io_wait__getraw__io(smx_simcall_t simcall)
 935 {
 936   return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ActivityImpl*>(simcall->args[0]);
 937 }
 938 static inline void simcall_io_wait__set__io(smx_simcall_t simcall,
 939                                             boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> arg)
 940 {
 941   simgrid::simix::marshal<boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>>(simcall->args[0], arg);
 942 }
 943 static inline sg_size_t simcall_io_wait__get__result(smx_simcall_t simcall)
 944 {
 945   return simgrid::simix::unmarshal<sg_size_t>(simcall->result);
 946 }
 947 static inline sg_size_t simcall_io_wait__getraw__result(smx_simcall_t simcall)
 948 {
 949   return simgrid::simix::unmarshal_raw<sg_size_t>(simcall->result);
 950 }
 951 static inline void simcall_io_wait__set__result(smx_simcall_t simcall, sg_size_t result)
 952 {
 953   simgrid::simix::marshal<sg_size_t>(simcall->result, result);
 954 }
 955
 956 static inline int simcall_mc_random__get__min(smx_simcall_t simcall)
 957 {
 958   return simgrid::simix::unmarshal<int>(simcall->args[0]);
 959 }
 960 static inline int simcall_mc_random__getraw__min(smx_simcall_t simcall)
 961 {
 962   return simgrid::simix::unmarshal_raw<int>(simcall->args[0]);
 963 }
 964 static inline void simcall_mc_random__set__min(smx_simcall_t simcall, int arg)
 965 {
 966   simgrid::simix::marshal<int>(simcall->args[0], arg);
 967 }
 968 static inline int simcall_mc_random__get__max(smx_simcall_t simcall)
 969 {
 970   return simgrid::simix::unmarshal<int>(simcall->args[1]);
 971 }
 972 static inline int simcall_mc_random__getraw__max(smx_simcall_t simcall)
 973 {
 974   return simgrid::simix::unmarshal_raw<int>(simcall->args[1]);
 975 }
 976 static inline void simcall_mc_random__set__max(smx_simcall_t simcall, int arg)
 977 {
 978   simgrid::simix::marshal<int>(simcall->args[1], arg);
 979 }
 980 static inline int simcall_mc_random__get__result(smx_simcall_t simcall)
 981 {
 982   return simgrid::simix::unmarshal<int>(simcall->result);
 983 }
 984 static inline int simcall_mc_random__getraw__result(smx_simcall_t simcall)
 985 {
 986   return simgrid::simix::unmarshal_raw<int>(simcall->result);
 987 }
 988 static inline void simcall_mc_random__set__result(smx_simcall_t simcall, int result)
 989 {
 990   simgrid::simix::marshal<int>(simcall->result, result);
 991 }
 992
 993 static inline std::function<void()> const* simcall_run_kernel__get__code(smx_simcall_t simcall)
 994 {
 995   return simgrid::simix::unmarshal<std::function<void()> const*>(simcall->args[0]);
 996 }
 997 static inline std::function<void()> const* simcall_run_kernel__getraw__code(smx_simcall_t simcall)
 998 {
 999   return simgrid::simix::unmarshal_raw<std::function<void()> const*>(simcall->args[0]);
1000 }
1001 static inline void simcall_run_kernel__set__code(smx_simcall_t simcall, std::function<void()> const* arg)
1002 {
1003   simgrid::simix::marshal<std::function<void()> const*>(simcall->args[0], arg);
1004 }
1005
1006 static inline std::function<void()> const* simcall_run_blocking__get__code(smx_simcall_t simcall)
1007 {
1008   return simgrid::simix::unmarshal<std::function<void()> const*>(simcall->args[0]);
1009 }
1010 static inline std::function<void()> const* simcall_run_blocking__getraw__code(smx_simcall_t simcall)
1011 {
1012   return simgrid::simix::unmarshal_raw<std::function<void()> const*>(simcall->args[0]);
1013 }
1014 static inline void simcall_run_blocking__set__code(smx_simcall_t simcall, std::function<void()> const* arg)
1015 {
1016   simgrid::simix::marshal<std::function<void()> const*>(simcall->args[0], arg);
1017 }
1018
1019 /* The prototype of all simcall handlers, automatically generated for you */
1020
1021 XBT_PRIVATE void simcall_HANDLER_process_suspend(smx_simcall_t simcall, smx_actor_t process);
1022 XBT_PRIVATE void simcall_HANDLER_process_join(smx_simcall_t simcall, smx_actor_t process, double timeout);
1023 XBT_PRIVATE void simcall_HANDLER_process_sleep(smx_simcall_t simcall, double duration);
1024 XBT_PRIVATE void simcall_HANDLER_execution_wait(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> execution);
1025 XBT_PRIVATE void
1026 simcall_HANDLER_execution_test(smx_simcall_t simcall,
1027                                boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> execution);
1028 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);
1029 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);
1030 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);
1031 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);
1032 XBT_PRIVATE void simcall_HANDLER_comm_waitany(smx_simcall_t simcall, xbt_dynar_t comms, double timeout);
1033 XBT_PRIVATE void simcall_HANDLER_comm_wait(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> comm, double timeout);
1034 XBT_PRIVATE void simcall_HANDLER_comm_test(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> comm);
1035 XBT_PRIVATE void simcall_HANDLER_comm_testany(smx_simcall_t simcall, boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl>* comms, size_t count);
1036 XBT_PRIVATE void simcall_HANDLER_mutex_lock(smx_simcall_t simcall, smx_mutex_t mutex);
1037 XBT_PRIVATE int simcall_HANDLER_mutex_trylock(smx_simcall_t simcall, smx_mutex_t mutex);
1038 XBT_PRIVATE void simcall_HANDLER_mutex_unlock(smx_simcall_t simcall, smx_mutex_t mutex);
1039 XBT_PRIVATE void simcall_HANDLER_cond_wait(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex);
1040 XBT_PRIVATE void simcall_HANDLER_cond_wait_timeout(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex, double timeout);
1041 XBT_PRIVATE void simcall_HANDLER_sem_acquire(smx_simcall_t simcall, smx_sem_t sem);
1042 XBT_PRIVATE void simcall_HANDLER_sem_acquire_timeout(smx_simcall_t simcall, smx_sem_t sem, double timeout);
1043 XBT_PRIVATE void simcall_HANDLER_io_wait(smx_simcall_t simcall,
1044                                          boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> io);
1045 XBT_PRIVATE int simcall_HANDLER_mc_random(smx_simcall_t simcall, int min, int max);