src/simix/popping_bodies.cpp

   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 /**********************************************************************/
   8
   9 /*
  10  * Note that the name comes from http://en.wikipedia.org/wiki/Popping
  11  * Indeed, the control flow is doing a strange dance in there.
  12  *
  13  * That's not about http://en.wikipedia.org/wiki/Poop, despite the odor :)
  14  */
  15
  16 #include "smx_private.h"
  17 #include "src/mc/mc_forward.hpp"
  18 #include "xbt/ex.h"
  19 #include <simgrid/simix.hpp>
  20 /** @cond */ // Please Doxygen, don't look at this
  21
  22 template<class R, class... T>
  23 inline static R simcall(e_smx_simcall_t call, T const&... t)
  24 {
  25   smx_process_t self = SIMIX_process_self();
  26   simgrid::simix::marshal(&self->simcall, call, t...);
  27   if (self != simix_global->maestro_process) {
  28     XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name.c_str(),
  29               SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
  30     SIMIX_process_yield(self);
  31   } else {
  32     SIMIX_simcall_handle(&self->simcall, 0);
  33   }
  34   return simgrid::simix::unmarshal<R>(self->simcall.result);
  35 }
  36
  37 inline static void simcall_BODY_vm_suspend(sg_host_t ind_vm) {
  38     /* Go to that function to follow the code flow through the simcall barrier */
  39     if (0) simcall_HANDLER_vm_suspend(&SIMIX_process_self()->simcall, ind_vm);
  40     return simcall<void, sg_host_t>(SIMCALL_VM_SUSPEND, ind_vm);
  41   }
  42
  43 inline static void simcall_BODY_vm_resume(sg_host_t ind_vm) {
  44     /* Go to that function to follow the code flow through the simcall barrier */
  45     if (0) simcall_HANDLER_vm_resume(&SIMIX_process_self()->simcall, ind_vm);
  46     return simcall<void, sg_host_t>(SIMCALL_VM_RESUME, ind_vm);
  47   }
  48
  49 inline static void simcall_BODY_vm_shutdown(sg_host_t ind_vm) {
  50     /* Go to that function to follow the code flow through the simcall barrier */
  51     if (0) simcall_HANDLER_vm_shutdown(&SIMIX_process_self()->simcall, ind_vm);
  52     return simcall<void, sg_host_t>(SIMCALL_VM_SHUTDOWN, ind_vm);
  53   }
  54
  55 inline static void simcall_BODY_vm_save(sg_host_t ind_vm) {
  56     /* Go to that function to follow the code flow through the simcall barrier */
  57     if (0) simcall_HANDLER_vm_save(&SIMIX_process_self()->simcall, ind_vm);
  58     return simcall<void, sg_host_t>(SIMCALL_VM_SAVE, ind_vm);
  59   }
  60
  61 inline static void simcall_BODY_vm_restore(sg_host_t ind_vm) {
  62     /* Go to that function to follow the code flow through the simcall barrier */
  63     if (0) simcall_HANDLER_vm_restore(&SIMIX_process_self()->simcall, ind_vm);
  64     return simcall<void, sg_host_t>(SIMCALL_VM_RESTORE, ind_vm);
  65   }
  66
  67 inline static void simcall_BODY_process_kill(smx_process_t process) {
  68     /* Go to that function to follow the code flow through the simcall barrier */
  69     if (0) simcall_HANDLER_process_kill(&SIMIX_process_self()->simcall, process);
  70     return simcall<void, smx_process_t>(SIMCALL_PROCESS_KILL, process);
  71   }
  72
  73 inline static void simcall_BODY_process_killall(int reset_pid) {
  74     /* Go to that function to follow the code flow through the simcall barrier */
  75     if (0) simcall_HANDLER_process_killall(&SIMIX_process_self()->simcall, reset_pid);
  76     return simcall<void, int>(SIMCALL_PROCESS_KILLALL, reset_pid);
  77   }
  78
  79 inline static void simcall_BODY_process_cleanup(smx_process_t process) {
  80     /* Go to that function to follow the code flow through the simcall barrier */
  81     if (0) SIMIX_process_cleanup(process);
  82     return simcall<void, smx_process_t>(SIMCALL_PROCESS_CLEANUP, process);
  83   }
  84
  85 inline static void simcall_BODY_process_suspend(smx_process_t process) {
  86     /* Go to that function to follow the code flow through the simcall barrier */
  87     if (0) simcall_HANDLER_process_suspend(&SIMIX_process_self()->simcall, process);
  88     return simcall<void, smx_process_t>(SIMCALL_PROCESS_SUSPEND, process);
  89   }
  90
  91 inline static void simcall_BODY_process_resume(smx_process_t process) {
  92     /* Go to that function to follow the code flow through the simcall barrier */
  93     if (0) simcall_HANDLER_process_resume(&SIMIX_process_self()->simcall, process);
  94     return simcall<void, smx_process_t>(SIMCALL_PROCESS_RESUME, process);
  95   }
  96
  97 inline static void simcall_BODY_process_set_host(smx_process_t process, sg_host_t dest) {
  98     /* Go to that function to follow the code flow through the simcall barrier */
  99     if (0) simcall_HANDLER_process_set_host(&SIMIX_process_self()->simcall, process, dest);
 100     return simcall<void, smx_process_t, sg_host_t>(SIMCALL_PROCESS_SET_HOST, process, dest);
 101   }
 102
 103 inline static int simcall_BODY_process_is_suspended(smx_process_t process) {
 104     /* Go to that function to follow the code flow through the simcall barrier */
 105     if (0) SIMIX_process_is_suspended(process);
 106     return simcall<int, smx_process_t>(SIMCALL_PROCESS_IS_SUSPENDED, process);
 107   }
 108
 109 inline static int simcall_BODY_process_join(smx_process_t process, double timeout) {
 110     /* Go to that function to follow the code flow through the simcall barrier */
 111     if (0) simcall_HANDLER_process_join(&SIMIX_process_self()->simcall, process, timeout);
 112     return simcall<int, smx_process_t, double>(SIMCALL_PROCESS_JOIN, process, timeout);
 113   }
 114
 115 inline static int simcall_BODY_process_sleep(double duration) {
 116     /* Go to that function to follow the code flow through the simcall barrier */
 117     if (0) simcall_HANDLER_process_sleep(&SIMIX_process_self()->simcall, duration);
 118     return simcall<int, double>(SIMCALL_PROCESS_SLEEP, duration);
 119   }
 120
 121 inline static smx_synchro_t simcall_BODY_execution_start(const char* name, double flops_amount, double priority, double bound, unsigned long affinity_mask) {
 122     /* Go to that function to follow the code flow through the simcall barrier */
 123     if (0) simcall_HANDLER_execution_start(&SIMIX_process_self()->simcall, name, flops_amount, priority, bound, affinity_mask);
 124     return simcall<smx_synchro_t, const char*, double, double, double, unsigned long>(SIMCALL_EXECUTION_START, name, flops_amount, priority, bound, affinity_mask);
 125   }
 126
 127 inline static smx_synchro_t simcall_BODY_execution_parallel_start(const char* name, int host_nb, sg_host_t* host_list, double* flops_amount, double* bytes_amount, double amount, double rate) {
 128     /* Go to that function to follow the code flow through the simcall barrier */
 129     if (0) SIMIX_execution_parallel_start(name, host_nb, host_list, flops_amount, bytes_amount, amount, rate);
 130     return simcall<smx_synchro_t, const char*, int, sg_host_t*, double*, double*, double, double>(SIMCALL_EXECUTION_PARALLEL_START, name, host_nb, host_list, flops_amount, bytes_amount, amount, rate);
 131   }
 132
 133 inline static void simcall_BODY_execution_cancel(smx_synchro_t execution) {
 134     /* Go to that function to follow the code flow through the simcall barrier */
 135     if (0) SIMIX_execution_cancel(execution);
 136     return simcall<void, smx_synchro_t>(SIMCALL_EXECUTION_CANCEL, execution);
 137   }
 138
 139 inline static void simcall_BODY_execution_set_priority(smx_synchro_t execution, double priority) {
 140     /* Go to that function to follow the code flow through the simcall barrier */
 141     if (0) SIMIX_execution_set_priority(execution, priority);
 142     return simcall<void, smx_synchro_t, double>(SIMCALL_EXECUTION_SET_PRIORITY, execution, priority);
 143   }
 144
 145 inline static void simcall_BODY_execution_set_bound(smx_synchro_t execution, double bound) {
 146     /* Go to that function to follow the code flow through the simcall barrier */
 147     if (0) SIMIX_execution_set_bound(execution, bound);
 148     return simcall<void, smx_synchro_t, double>(SIMCALL_EXECUTION_SET_BOUND, execution, bound);
 149   }
 150
 151 inline static void simcall_BODY_execution_set_affinity(smx_synchro_t execution, sg_host_t ws, unsigned long mask) {
 152     /* Go to that function to follow the code flow through the simcall barrier */
 153     if (0) SIMIX_execution_set_affinity(execution, ws, mask);
 154     return simcall<void, smx_synchro_t, sg_host_t, unsigned long>(SIMCALL_EXECUTION_SET_AFFINITY, execution, ws, mask);
 155   }
 156
 157 inline static int simcall_BODY_execution_wait(smx_synchro_t execution) {
 158     /* Go to that function to follow the code flow through the simcall barrier */
 159     if (0) simcall_HANDLER_execution_wait(&SIMIX_process_self()->simcall, execution);
 160     return simcall<int, smx_synchro_t>(SIMCALL_EXECUTION_WAIT, execution);
 161   }
 162
 163 inline static void simcall_BODY_process_on_exit(smx_process_t process, int_f_pvoid_pvoid_t fun, void* data) {
 164     /* Go to that function to follow the code flow through the simcall barrier */
 165     if (0) SIMIX_process_on_exit(process, fun, data);
 166     return simcall<void, smx_process_t, int_f_pvoid_pvoid_t, void*>(SIMCALL_PROCESS_ON_EXIT, process, fun, data);
 167   }
 168
 169 inline static void simcall_BODY_process_auto_restart_set(smx_process_t process, int auto_restart) {
 170     /* Go to that function to follow the code flow through the simcall barrier */
 171     if (0) SIMIX_process_auto_restart_set(process, auto_restart);
 172     return simcall<void, smx_process_t, int>(SIMCALL_PROCESS_AUTO_RESTART_SET, process, auto_restart);
 173   }
 174
 175 inline static smx_process_t simcall_BODY_process_restart(smx_process_t process) {
 176     /* Go to that function to follow the code flow through the simcall barrier */
 177     if (0) simcall_HANDLER_process_restart(&SIMIX_process_self()->simcall, process);
 178     return simcall<smx_process_t, smx_process_t>(SIMCALL_PROCESS_RESTART, process);
 179   }
 180
 181 inline static smx_mailbox_t simcall_BODY_mbox_create(const char* name) {
 182     /* Go to that function to follow the code flow through the simcall barrier */
 183     if (0) SIMIX_mbox_create(name);
 184     return simcall<smx_mailbox_t, const char*>(SIMCALL_MBOX_CREATE, name);
 185   }
 186
 187 inline static void simcall_BODY_mbox_set_receiver(smx_mailbox_t mbox, smx_process_t receiver) {
 188     /* Go to that function to follow the code flow through the simcall barrier */
 189     if (0) SIMIX_mbox_set_receiver(mbox, receiver);
 190     return simcall<void, smx_mailbox_t, smx_process_t>(SIMCALL_MBOX_SET_RECEIVER, mbox, receiver);
 191   }
 192
 193 inline static smx_synchro_t simcall_BODY_comm_iprobe(smx_mailbox_t mbox, int type, int src, int tag, simix_match_func_t match_fun, void* data) {
 194     /* Go to that function to follow the code flow through the simcall barrier */
 195     if (0) simcall_HANDLER_comm_iprobe(&SIMIX_process_self()->simcall, mbox, type, src, tag, match_fun, data);
 196     return simcall<smx_synchro_t, smx_mailbox_t, int, int, int, simix_match_func_t, void*>(SIMCALL_COMM_IPROBE, mbox, type, src, tag, match_fun, data);
 197   }
 198
 199 inline static void simcall_BODY_comm_send(smx_process_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) {
 200     /* Go to that function to follow the code flow through the simcall barrier */
 201     if (0) simcall_HANDLER_comm_send(&SIMIX_process_self()->simcall, sender, mbox, task_size, rate, src_buff, src_buff_size, match_fun, copy_data_fun, data, timeout);
 202     return simcall<void, smx_process_t, smx_mailbox_t, double, double, void*, size_t, simix_match_func_t, simix_copy_data_func_t, void*, double>(SIMCALL_COMM_SEND, sender, mbox, task_size, rate, src_buff, src_buff_size, match_fun, copy_data_fun, data, timeout);
 203   }
 204
 205 inline static smx_synchro_t simcall_BODY_comm_isend(smx_process_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) {
 206     /* Go to that function to follow the code flow through the simcall barrier */
 207     if (0) simcall_HANDLER_comm_isend(&SIMIX_process_self()->simcall, sender, mbox, task_size, rate, src_buff, src_buff_size, match_fun, clean_fun, copy_data_fun, data, detached);
 208     return simcall<smx_synchro_t, smx_process_t, smx_mailbox_t, double, double, void*, size_t, simix_match_func_t, simix_clean_func_t, simix_copy_data_func_t, void*, int>(SIMCALL_COMM_ISEND, sender, mbox, task_size, rate, src_buff, src_buff_size, match_fun, clean_fun, copy_data_fun, data, detached);
 209   }
 210
 211 inline static void simcall_BODY_comm_recv(smx_process_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) {
 212     /* Go to that function to follow the code flow through the simcall barrier */
 213     if (0) simcall_HANDLER_comm_recv(&SIMIX_process_self()->simcall, receiver, mbox, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, timeout, rate);
 214     return simcall<void, smx_process_t, smx_mailbox_t, void*, size_t*, simix_match_func_t, simix_copy_data_func_t, void*, double, double>(SIMCALL_COMM_RECV, receiver, mbox, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, timeout, rate);
 215   }
 216
 217 inline static smx_synchro_t simcall_BODY_comm_irecv(smx_process_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) {
 218     /* Go to that function to follow the code flow through the simcall barrier */
 219     if (0) simcall_HANDLER_comm_irecv(&SIMIX_process_self()->simcall, receiver, mbox, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, rate);
 220     return simcall<smx_synchro_t, smx_process_t, smx_mailbox_t, void*, size_t*, simix_match_func_t, simix_copy_data_func_t, void*, double>(SIMCALL_COMM_IRECV, receiver, mbox, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, rate);
 221   }
 222
 223 inline static int simcall_BODY_comm_waitany(xbt_dynar_t comms) {
 224     /* Go to that function to follow the code flow through the simcall barrier */
 225     if (0) simcall_HANDLER_comm_waitany(&SIMIX_process_self()->simcall, comms);
 226     return simcall<int, xbt_dynar_t>(SIMCALL_COMM_WAITANY, comms);
 227   }
 228
 229 inline static void simcall_BODY_comm_wait(smx_synchro_t comm, double timeout) {
 230     /* Go to that function to follow the code flow through the simcall barrier */
 231     if (0) simcall_HANDLER_comm_wait(&SIMIX_process_self()->simcall, comm, timeout);
 232     return simcall<void, smx_synchro_t, double>(SIMCALL_COMM_WAIT, comm, timeout);
 233   }
 234
 235 inline static int simcall_BODY_comm_test(smx_synchro_t comm) {
 236     /* Go to that function to follow the code flow through the simcall barrier */
 237     if (0) simcall_HANDLER_comm_test(&SIMIX_process_self()->simcall, comm);
 238     return simcall<int, smx_synchro_t>(SIMCALL_COMM_TEST, comm);
 239   }
 240
 241 inline static int simcall_BODY_comm_testany(xbt_dynar_t comms) {
 242     /* Go to that function to follow the code flow through the simcall barrier */
 243     if (0) simcall_HANDLER_comm_testany(&SIMIX_process_self()->simcall, comms);
 244     return simcall<int, xbt_dynar_t>(SIMCALL_COMM_TESTANY, comms);
 245   }
 246
 247 inline static smx_mutex_t simcall_BODY_mutex_init() {
 248     /* Go to that function to follow the code flow through the simcall barrier */
 249     if (0) simcall_HANDLER_mutex_init(&SIMIX_process_self()->simcall);
 250     return simcall<smx_mutex_t>(SIMCALL_MUTEX_INIT);
 251   }
 252
 253 inline static void simcall_BODY_mutex_lock(smx_mutex_t mutex) {
 254     /* Go to that function to follow the code flow through the simcall barrier */
 255     if (0) simcall_HANDLER_mutex_lock(&SIMIX_process_self()->simcall, mutex);
 256     return simcall<void, smx_mutex_t>(SIMCALL_MUTEX_LOCK, mutex);
 257   }
 258
 259 inline static int simcall_BODY_mutex_trylock(smx_mutex_t mutex) {
 260     /* Go to that function to follow the code flow through the simcall barrier */
 261     if (0) simcall_HANDLER_mutex_trylock(&SIMIX_process_self()->simcall, mutex);
 262     return simcall<int, smx_mutex_t>(SIMCALL_MUTEX_TRYLOCK, mutex);
 263   }
 264
 265 inline static void simcall_BODY_mutex_unlock(smx_mutex_t mutex) {
 266     /* Go to that function to follow the code flow through the simcall barrier */
 267     if (0) simcall_HANDLER_mutex_unlock(&SIMIX_process_self()->simcall, mutex);
 268     return simcall<void, smx_mutex_t>(SIMCALL_MUTEX_UNLOCK, mutex);
 269   }
 270
 271 inline static smx_cond_t simcall_BODY_cond_init() {
 272     /* Go to that function to follow the code flow through the simcall barrier */
 273     if (0) SIMIX_cond_init();
 274     return simcall<smx_cond_t>(SIMCALL_COND_INIT);
 275   }
 276
 277 inline static void simcall_BODY_cond_signal(smx_cond_t cond) {
 278     /* Go to that function to follow the code flow through the simcall barrier */
 279     if (0) SIMIX_cond_signal(cond);
 280     return simcall<void, smx_cond_t>(SIMCALL_COND_SIGNAL, cond);
 281   }
 282
 283 inline static void simcall_BODY_cond_wait(smx_cond_t cond, smx_mutex_t mutex) {
 284     /* Go to that function to follow the code flow through the simcall barrier */
 285     if (0) simcall_HANDLER_cond_wait(&SIMIX_process_self()->simcall, cond, mutex);
 286     return simcall<void, smx_cond_t, smx_mutex_t>(SIMCALL_COND_WAIT, cond, mutex);
 287   }
 288
 289 inline static void simcall_BODY_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double timeout) {
 290     /* Go to that function to follow the code flow through the simcall barrier */
 291     if (0) simcall_HANDLER_cond_wait_timeout(&SIMIX_process_self()->simcall, cond, mutex, timeout);
 292     return simcall<void, smx_cond_t, smx_mutex_t, double>(SIMCALL_COND_WAIT_TIMEOUT, cond, mutex, timeout);
 293   }
 294
 295 inline static void simcall_BODY_cond_broadcast(smx_cond_t cond) {
 296     /* Go to that function to follow the code flow through the simcall barrier */
 297     if (0) SIMIX_cond_broadcast(cond);
 298     return simcall<void, smx_cond_t>(SIMCALL_COND_BROADCAST, cond);
 299   }
 300
 301 inline static smx_sem_t simcall_BODY_sem_init(unsigned int capacity) {
 302     /* Go to that function to follow the code flow through the simcall barrier */
 303     if (0) SIMIX_sem_init(capacity);
 304     return simcall<smx_sem_t, unsigned int>(SIMCALL_SEM_INIT, capacity);
 305   }
 306
 307 inline static void simcall_BODY_sem_release(smx_sem_t sem) {
 308     /* Go to that function to follow the code flow through the simcall barrier */
 309     if (0) simcall_HANDLER_sem_release(&SIMIX_process_self()->simcall, sem);
 310     return simcall<void, smx_sem_t>(SIMCALL_SEM_RELEASE, sem);
 311   }
 312
 313 inline static int simcall_BODY_sem_would_block(smx_sem_t sem) {
 314     /* Go to that function to follow the code flow through the simcall barrier */
 315     if (0) simcall_HANDLER_sem_would_block(&SIMIX_process_self()->simcall, sem);
 316     return simcall<int, smx_sem_t>(SIMCALL_SEM_WOULD_BLOCK, sem);
 317   }
 318
 319 inline static void simcall_BODY_sem_acquire(smx_sem_t sem) {
 320     /* Go to that function to follow the code flow through the simcall barrier */
 321     if (0) simcall_HANDLER_sem_acquire(&SIMIX_process_self()->simcall, sem);
 322     return simcall<void, smx_sem_t>(SIMCALL_SEM_ACQUIRE, sem);
 323   }
 324
 325 inline static void simcall_BODY_sem_acquire_timeout(smx_sem_t sem, double timeout) {
 326     /* Go to that function to follow the code flow through the simcall barrier */
 327     if (0) simcall_HANDLER_sem_acquire_timeout(&SIMIX_process_self()->simcall, sem, timeout);
 328     return simcall<void, smx_sem_t, double>(SIMCALL_SEM_ACQUIRE_TIMEOUT, sem, timeout);
 329   }
 330
 331 inline static int simcall_BODY_sem_get_capacity(smx_sem_t sem) {
 332     /* Go to that function to follow the code flow through the simcall barrier */
 333     if (0) simcall_HANDLER_sem_get_capacity(&SIMIX_process_self()->simcall, sem);
 334     return simcall<int, smx_sem_t>(SIMCALL_SEM_GET_CAPACITY, sem);
 335   }
 336
 337 inline static sg_size_t simcall_BODY_file_read(smx_file_t fd, sg_size_t size, sg_host_t host) {
 338     /* Go to that function to follow the code flow through the simcall barrier */
 339     if (0) simcall_HANDLER_file_read(&SIMIX_process_self()->simcall, fd, size, host);
 340     return simcall<sg_size_t, smx_file_t, sg_size_t, sg_host_t>(SIMCALL_FILE_READ, fd, size, host);
 341   }
 342
 343 inline static sg_size_t simcall_BODY_file_write(smx_file_t fd, sg_size_t size, sg_host_t host) {
 344     /* Go to that function to follow the code flow through the simcall barrier */
 345     if (0) simcall_HANDLER_file_write(&SIMIX_process_self()->simcall, fd, size, host);
 346     return simcall<sg_size_t, smx_file_t, sg_size_t, sg_host_t>(SIMCALL_FILE_WRITE, fd, size, host);
 347   }
 348
 349 inline static smx_file_t simcall_BODY_file_open(const char* fullpath, sg_host_t host) {
 350     /* Go to that function to follow the code flow through the simcall barrier */
 351     if (0) simcall_HANDLER_file_open(&SIMIX_process_self()->simcall, fullpath, host);
 352     return simcall<smx_file_t, const char*, sg_host_t>(SIMCALL_FILE_OPEN, fullpath, host);
 353   }
 354
 355 inline static int simcall_BODY_file_close(smx_file_t fd, sg_host_t host) {
 356     /* Go to that function to follow the code flow through the simcall barrier */
 357     if (0) simcall_HANDLER_file_close(&SIMIX_process_self()->simcall, fd, host);
 358     return simcall<int, smx_file_t, sg_host_t>(SIMCALL_FILE_CLOSE, fd, host);
 359   }
 360
 361 inline static int simcall_BODY_file_unlink(smx_file_t fd, sg_host_t host) {
 362     /* Go to that function to follow the code flow through the simcall barrier */
 363     if (0) SIMIX_file_unlink(fd, host);
 364     return simcall<int, smx_file_t, sg_host_t>(SIMCALL_FILE_UNLINK, fd, host);
 365   }
 366
 367 inline static sg_size_t simcall_BODY_file_get_size(smx_file_t fd) {
 368     /* Go to that function to follow the code flow through the simcall barrier */
 369     if (0) simcall_HANDLER_file_get_size(&SIMIX_process_self()->simcall, fd);
 370     return simcall<sg_size_t, smx_file_t>(SIMCALL_FILE_GET_SIZE, fd);
 371   }
 372
 373 inline static sg_size_t simcall_BODY_file_tell(smx_file_t fd) {
 374     /* Go to that function to follow the code flow through the simcall barrier */
 375     if (0) simcall_HANDLER_file_tell(&SIMIX_process_self()->simcall, fd);
 376     return simcall<sg_size_t, smx_file_t>(SIMCALL_FILE_TELL, fd);
 377   }
 378
 379 inline static int simcall_BODY_file_seek(smx_file_t fd, sg_offset_t offset, int origin) {
 380     /* Go to that function to follow the code flow through the simcall barrier */
 381     if (0) simcall_HANDLER_file_seek(&SIMIX_process_self()->simcall, fd, offset, origin);
 382     return simcall<int, smx_file_t, sg_offset_t, int>(SIMCALL_FILE_SEEK, fd, offset, origin);
 383   }
 384
 385 inline static xbt_dynar_t simcall_BODY_file_get_info(smx_file_t fd) {
 386     /* Go to that function to follow the code flow through the simcall barrier */
 387     if (0) simcall_HANDLER_file_get_info(&SIMIX_process_self()->simcall, fd);
 388     return simcall<xbt_dynar_t, smx_file_t>(SIMCALL_FILE_GET_INFO, fd);
 389   }
 390
 391 inline static int simcall_BODY_file_move(smx_file_t fd, const char* fullpath) {
 392     /* Go to that function to follow the code flow through the simcall barrier */
 393     if (0) simcall_HANDLER_file_move(&SIMIX_process_self()->simcall, fd, fullpath);
 394     return simcall<int, smx_file_t, const char*>(SIMCALL_FILE_MOVE, fd, fullpath);
 395   }
 396
 397 inline static sg_size_t simcall_BODY_storage_get_free_size(smx_storage_t storage) {
 398     /* Go to that function to follow the code flow through the simcall barrier */
 399     if (0) simcall_HANDLER_storage_get_free_size(&SIMIX_process_self()->simcall, storage);
 400     return simcall<sg_size_t, smx_storage_t>(SIMCALL_STORAGE_GET_FREE_SIZE, storage);
 401   }
 402
 403 inline static sg_size_t simcall_BODY_storage_get_used_size(smx_storage_t name) {
 404     /* Go to that function to follow the code flow through the simcall barrier */
 405     if (0) simcall_HANDLER_storage_get_used_size(&SIMIX_process_self()->simcall, name);
 406     return simcall<sg_size_t, smx_storage_t>(SIMCALL_STORAGE_GET_USED_SIZE, name);
 407   }
 408
 409 inline static xbt_dict_t simcall_BODY_storage_get_properties(smx_storage_t storage) {
 410     /* Go to that function to follow the code flow through the simcall barrier */
 411     if (0) SIMIX_storage_get_properties(storage);
 412     return simcall<xbt_dict_t, smx_storage_t>(SIMCALL_STORAGE_GET_PROPERTIES, storage);
 413   }
 414
 415 inline static xbt_dict_t simcall_BODY_storage_get_content(smx_storage_t storage) {
 416     /* Go to that function to follow the code flow through the simcall barrier */
 417     if (0) SIMIX_storage_get_content(storage);
 418     return simcall<xbt_dict_t, smx_storage_t>(SIMCALL_STORAGE_GET_CONTENT, storage);
 419   }
 420
 421 inline static xbt_dict_t simcall_BODY_asr_get_properties(const char* name) {
 422     /* Go to that function to follow the code flow through the simcall barrier */
 423     if (0) simcall_HANDLER_asr_get_properties(&SIMIX_process_self()->simcall, name);
 424     return simcall<xbt_dict_t, const char*>(SIMCALL_ASR_GET_PROPERTIES, name);
 425   }
 426
 427 inline static int simcall_BODY_mc_random(int min, int max) {
 428     /* Go to that function to follow the code flow through the simcall barrier */
 429     if (0) simcall_HANDLER_mc_random(&SIMIX_process_self()->simcall, min, max);
 430     return simcall<int, int, int>(SIMCALL_MC_RANDOM, min, max);
 431   }
 432
 433 inline static void simcall_BODY_set_category(smx_synchro_t synchro, const char* category) {
 434     /* Go to that function to follow the code flow through the simcall barrier */
 435     if (0) SIMIX_set_category(synchro, category);
 436     return simcall<void, smx_synchro_t, const char*>(SIMCALL_SET_CATEGORY, synchro, category);
 437   }
 438
 439 inline static void simcall_BODY_run_kernel(void* code) {
 440     /* Go to that function to follow the code flow through the simcall barrier */
 441     if (0) SIMIX_run_kernel(code);
 442     return simcall<void, void*>(SIMCALL_RUN_KERNEL, code);
 443   }/** @endcond */