src/simix/popping_accessors.hpp

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