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