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
  21 inline static void simcall_BODY_vm_suspend(sg_host_t ind_vm) {
  22     smx_process_t self = SIMIX_process_self();
  23
  24     /* Go to that function to follow the code flow through the simcall barrier */
  25     if (0) simcall_HANDLER_vm_suspend(&self->simcall, ind_vm);
  26     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
  27
  28     self->simcall.call = SIMCALL_VM_SUSPEND;
  29     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
  30     memset(self->simcall.args, 0, sizeof(self->simcall.args));
  31     self->simcall.args[0].dp = (void*) ind_vm;
  32     if (self != simix_global->maestro_process) {
  33       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
  34                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
  35       SIMIX_process_yield(self);
  36     } else {
  37       SIMIX_simcall_handle(&self->simcall, 0);
  38     }
  39
  40   }
  41
  42 inline static void simcall_BODY_vm_resume(sg_host_t ind_vm) {
  43     smx_process_t self = SIMIX_process_self();
  44
  45     /* Go to that function to follow the code flow through the simcall barrier */
  46     if (0) simcall_HANDLER_vm_resume(&self->simcall, ind_vm);
  47     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
  48
  49     self->simcall.call = SIMCALL_VM_RESUME;
  50     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
  51     memset(self->simcall.args, 0, sizeof(self->simcall.args));
  52     self->simcall.args[0].dp = (void*) ind_vm;
  53     if (self != simix_global->maestro_process) {
  54       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
  55                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
  56       SIMIX_process_yield(self);
  57     } else {
  58       SIMIX_simcall_handle(&self->simcall, 0);
  59     }
  60
  61   }
  62
  63 inline static void simcall_BODY_vm_shutdown(sg_host_t ind_vm) {
  64     smx_process_t self = SIMIX_process_self();
  65
  66     /* Go to that function to follow the code flow through the simcall barrier */
  67     if (0) simcall_HANDLER_vm_shutdown(&self->simcall, ind_vm);
  68     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
  69
  70     self->simcall.call = SIMCALL_VM_SHUTDOWN;
  71     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
  72     memset(self->simcall.args, 0, sizeof(self->simcall.args));
  73     self->simcall.args[0].dp = (void*) ind_vm;
  74     if (self != simix_global->maestro_process) {
  75       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
  76                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
  77       SIMIX_process_yield(self);
  78     } else {
  79       SIMIX_simcall_handle(&self->simcall, 0);
  80     }
  81
  82   }
  83
  84 inline static void simcall_BODY_vm_save(sg_host_t ind_vm) {
  85     smx_process_t self = SIMIX_process_self();
  86
  87     /* Go to that function to follow the code flow through the simcall barrier */
  88     if (0) simcall_HANDLER_vm_save(&self->simcall, ind_vm);
  89     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
  90
  91     self->simcall.call = SIMCALL_VM_SAVE;
  92     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
  93     memset(self->simcall.args, 0, sizeof(self->simcall.args));
  94     self->simcall.args[0].dp = (void*) ind_vm;
  95     if (self != simix_global->maestro_process) {
  96       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
  97                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
  98       SIMIX_process_yield(self);
  99     } else {
 100       SIMIX_simcall_handle(&self->simcall, 0);
 101     }
 102
 103   }
 104
 105 inline static void simcall_BODY_vm_restore(sg_host_t ind_vm) {
 106     smx_process_t self = SIMIX_process_self();
 107
 108     /* Go to that function to follow the code flow through the simcall barrier */
 109     if (0) simcall_HANDLER_vm_restore(&self->simcall, ind_vm);
 110     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 111
 112     self->simcall.call = SIMCALL_VM_RESTORE;
 113     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 114     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 115     self->simcall.args[0].dp = (void*) ind_vm;
 116     if (self != simix_global->maestro_process) {
 117       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 118                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 119       SIMIX_process_yield(self);
 120     } else {
 121       SIMIX_simcall_handle(&self->simcall, 0);
 122     }
 123
 124   }
 125
 126 inline static void* simcall_BODY_process_create(const char* name, xbt_main_func_t code, void* data, const char* hostname, double kill_time, int argc, char** argv, xbt_dict_t properties, int auto_restart) {
 127     smx_process_t self = SIMIX_process_self();
 128
 129     /* Go to that function to follow the code flow through the simcall barrier */
 130     if (0) simcall_HANDLER_process_create(&self->simcall, name, code, data, hostname, kill_time, argc, argv, properties, auto_restart);
 131     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 132
 133     self->simcall.call = SIMCALL_PROCESS_CREATE;
 134     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 135     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 136     self->simcall.args[0].cc = (const char*) name;
 137     self->simcall.args[1].fp = (FPtr) code;
 138     self->simcall.args[2].dp = (void*) data;
 139     self->simcall.args[3].cc = (const char*) hostname;
 140     self->simcall.args[4].d = (double) kill_time;
 141     self->simcall.args[5].i = (int) argc;
 142     self->simcall.args[6].dp = (void*) argv;
 143     self->simcall.args[7].dp = (void*) properties;
 144     self->simcall.args[8].i = (int) auto_restart;
 145     if (self != simix_global->maestro_process) {
 146       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 147                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 148       SIMIX_process_yield(self);
 149     } else {
 150       SIMIX_simcall_handle(&self->simcall, 0);
 151     }
 152     return (void*) self->simcall.result.dp;
 153   }
 154
 155 inline static void simcall_BODY_process_kill(smx_process_t process) {
 156     smx_process_t self = SIMIX_process_self();
 157
 158     /* Go to that function to follow the code flow through the simcall barrier */
 159     if (0) simcall_HANDLER_process_kill(&self->simcall, process);
 160     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 161
 162     self->simcall.call = SIMCALL_PROCESS_KILL;
 163     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 164     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 165     self->simcall.args[0].dp = (void*) process;
 166     if (self != simix_global->maestro_process) {
 167       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 168                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 169       SIMIX_process_yield(self);
 170     } else {
 171       SIMIX_simcall_handle(&self->simcall, 0);
 172     }
 173
 174   }
 175
 176 inline static void simcall_BODY_process_killall(int reset_pid) {
 177     smx_process_t self = SIMIX_process_self();
 178
 179     /* Go to that function to follow the code flow through the simcall barrier */
 180     if (0) simcall_HANDLER_process_killall(&self->simcall, reset_pid);
 181     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 182
 183     self->simcall.call = SIMCALL_PROCESS_KILLALL;
 184     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 185     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 186     self->simcall.args[0].i = (int) reset_pid;
 187     if (self != simix_global->maestro_process) {
 188       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 189                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 190       SIMIX_process_yield(self);
 191     } else {
 192       SIMIX_simcall_handle(&self->simcall, 0);
 193     }
 194
 195   }
 196
 197 inline static void simcall_BODY_process_cleanup(smx_process_t process) {
 198     smx_process_t self = SIMIX_process_self();
 199
 200     /* Go to that function to follow the code flow through the simcall barrier */
 201     if (0) SIMIX_process_cleanup(process);
 202     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 203
 204     self->simcall.call = SIMCALL_PROCESS_CLEANUP;
 205     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 206     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 207     self->simcall.args[0].dp = (void*) process;
 208     if (self != simix_global->maestro_process) {
 209       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 210                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 211       SIMIX_process_yield(self);
 212     } else {
 213       SIMIX_simcall_handle(&self->simcall, 0);
 214     }
 215
 216   }
 217
 218 inline static void simcall_BODY_process_suspend(smx_process_t process) {
 219     smx_process_t self = SIMIX_process_self();
 220
 221     /* Go to that function to follow the code flow through the simcall barrier */
 222     if (0) simcall_HANDLER_process_suspend(&self->simcall, process);
 223     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 224
 225     self->simcall.call = SIMCALL_PROCESS_SUSPEND;
 226     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 227     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 228     self->simcall.args[0].dp = (void*) process;
 229     if (self != simix_global->maestro_process) {
 230       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 231                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 232       SIMIX_process_yield(self);
 233     } else {
 234       SIMIX_simcall_handle(&self->simcall, 0);
 235     }
 236
 237   }
 238
 239 inline static void simcall_BODY_process_resume(smx_process_t process) {
 240     smx_process_t self = SIMIX_process_self();
 241
 242     /* Go to that function to follow the code flow through the simcall barrier */
 243     if (0) simcall_HANDLER_process_resume(&self->simcall, process);
 244     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 245
 246     self->simcall.call = SIMCALL_PROCESS_RESUME;
 247     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 248     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 249     self->simcall.args[0].dp = (void*) process;
 250     if (self != simix_global->maestro_process) {
 251       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 252                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 253       SIMIX_process_yield(self);
 254     } else {
 255       SIMIX_simcall_handle(&self->simcall, 0);
 256     }
 257
 258   }
 259
 260 inline static void simcall_BODY_process_set_host(smx_process_t process, sg_host_t dest) {
 261     smx_process_t self = SIMIX_process_self();
 262
 263     /* Go to that function to follow the code flow through the simcall barrier */
 264     if (0) simcall_HANDLER_process_set_host(&self->simcall, process, dest);
 265     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 266
 267     self->simcall.call = SIMCALL_PROCESS_SET_HOST;
 268     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 269     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 270     self->simcall.args[0].dp = (void*) process;
 271     self->simcall.args[1].dp = (void*) dest;
 272     if (self != simix_global->maestro_process) {
 273       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 274                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 275       SIMIX_process_yield(self);
 276     } else {
 277       SIMIX_simcall_handle(&self->simcall, 0);
 278     }
 279
 280   }
 281
 282 inline static int simcall_BODY_process_is_suspended(smx_process_t process) {
 283     smx_process_t self = SIMIX_process_self();
 284
 285     /* Go to that function to follow the code flow through the simcall barrier */
 286     if (0) SIMIX_process_is_suspended(process);
 287     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 288
 289     self->simcall.call = SIMCALL_PROCESS_IS_SUSPENDED;
 290     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 291     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 292     self->simcall.args[0].dp = (void*) process;
 293     if (self != simix_global->maestro_process) {
 294       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 295                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 296       SIMIX_process_yield(self);
 297     } else {
 298       SIMIX_simcall_handle(&self->simcall, 0);
 299     }
 300     return (int) self->simcall.result.i;
 301   }
 302
 303 inline static int simcall_BODY_process_join(smx_process_t process, double timeout) {
 304     smx_process_t self = SIMIX_process_self();
 305
 306     /* Go to that function to follow the code flow through the simcall barrier */
 307     if (0) simcall_HANDLER_process_join(&self->simcall, process, timeout);
 308     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 309
 310     self->simcall.call = SIMCALL_PROCESS_JOIN;
 311     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 312     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 313     self->simcall.args[0].dp = (void*) process;
 314     self->simcall.args[1].d = (double) timeout;
 315     if (self != simix_global->maestro_process) {
 316       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 317                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 318       SIMIX_process_yield(self);
 319     } else {
 320       SIMIX_simcall_handle(&self->simcall, 0);
 321     }
 322     return (int) self->simcall.result.i;
 323   }
 324
 325 inline static int simcall_BODY_process_sleep(double duration) {
 326     smx_process_t self = SIMIX_process_self();
 327
 328     /* Go to that function to follow the code flow through the simcall barrier */
 329     if (0) simcall_HANDLER_process_sleep(&self->simcall, duration);
 330     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 331
 332     self->simcall.call = SIMCALL_PROCESS_SLEEP;
 333     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 334     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 335     self->simcall.args[0].d = (double) duration;
 336     if (self != simix_global->maestro_process) {
 337       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 338                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 339       SIMIX_process_yield(self);
 340     } else {
 341       SIMIX_simcall_handle(&self->simcall, 0);
 342     }
 343     return (int) self->simcall.result.i;
 344   }
 345
 346 inline static smx_synchro_t simcall_BODY_execution_start(const char* name, double flops_amount, double priority, double bound, unsigned long affinity_mask) {
 347     smx_process_t self = SIMIX_process_self();
 348
 349     /* Go to that function to follow the code flow through the simcall barrier */
 350     if (0) simcall_HANDLER_execution_start(&self->simcall, name, flops_amount, priority, bound, affinity_mask);
 351     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 352
 353     self->simcall.call = SIMCALL_EXECUTION_START;
 354     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 355     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 356     self->simcall.args[0].cc = (const char*) name;
 357     self->simcall.args[1].d = (double) flops_amount;
 358     self->simcall.args[2].d = (double) priority;
 359     self->simcall.args[3].d = (double) bound;
 360     self->simcall.args[4].ul = (unsigned long) affinity_mask;
 361     if (self != simix_global->maestro_process) {
 362       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 363                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 364       SIMIX_process_yield(self);
 365     } else {
 366       SIMIX_simcall_handle(&self->simcall, 0);
 367     }
 368     return (smx_synchro_t) self->simcall.result.dp;
 369   }
 370
 371 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) {
 372     smx_process_t self = SIMIX_process_self();
 373
 374     /* Go to that function to follow the code flow through the simcall barrier */
 375     if (0) SIMIX_execution_parallel_start(name, host_nb, host_list, flops_amount, bytes_amount, amount, rate);
 376     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 377
 378     self->simcall.call = SIMCALL_EXECUTION_PARALLEL_START;
 379     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 380     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 381     self->simcall.args[0].cc = (const char*) name;
 382     self->simcall.args[1].i = (int) host_nb;
 383     self->simcall.args[2].dp = (void*) host_list;
 384     self->simcall.args[3].dp = (void*) flops_amount;
 385     self->simcall.args[4].dp = (void*) bytes_amount;
 386     self->simcall.args[5].d = (double) amount;
 387     self->simcall.args[6].d = (double) rate;
 388     if (self != simix_global->maestro_process) {
 389       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 390                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 391       SIMIX_process_yield(self);
 392     } else {
 393       SIMIX_simcall_handle(&self->simcall, 0);
 394     }
 395     return (smx_synchro_t) self->simcall.result.dp;
 396   }
 397
 398 inline static void simcall_BODY_execution_destroy(smx_synchro_t execution) {
 399     smx_process_t self = SIMIX_process_self();
 400
 401     /* Go to that function to follow the code flow through the simcall barrier */
 402     if (0) SIMIX_execution_destroy(execution);
 403     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 404
 405     self->simcall.call = SIMCALL_EXECUTION_DESTROY;
 406     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 407     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 408     self->simcall.args[0].dp = (void*) execution;
 409     if (self != simix_global->maestro_process) {
 410       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 411                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 412       SIMIX_process_yield(self);
 413     } else {
 414       SIMIX_simcall_handle(&self->simcall, 0);
 415     }
 416
 417   }
 418
 419 inline static void simcall_BODY_execution_cancel(smx_synchro_t execution) {
 420     smx_process_t self = SIMIX_process_self();
 421
 422     /* Go to that function to follow the code flow through the simcall barrier */
 423     if (0) SIMIX_execution_cancel(execution);
 424     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 425
 426     self->simcall.call = SIMCALL_EXECUTION_CANCEL;
 427     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 428     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 429     self->simcall.args[0].dp = (void*) execution;
 430     if (self != simix_global->maestro_process) {
 431       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 432                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 433       SIMIX_process_yield(self);
 434     } else {
 435       SIMIX_simcall_handle(&self->simcall, 0);
 436     }
 437
 438   }
 439
 440 inline static double simcall_BODY_execution_get_remains(smx_synchro_t execution) {
 441     smx_process_t self = SIMIX_process_self();
 442
 443     /* Go to that function to follow the code flow through the simcall barrier */
 444     if (0) SIMIX_execution_get_remains(execution);
 445     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 446
 447     self->simcall.call = SIMCALL_EXECUTION_GET_REMAINS;
 448     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 449     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 450     self->simcall.args[0].dp = (void*) execution;
 451     if (self != simix_global->maestro_process) {
 452       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 453                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 454       SIMIX_process_yield(self);
 455     } else {
 456       SIMIX_simcall_handle(&self->simcall, 0);
 457     }
 458     return (double) self->simcall.result.d;
 459   }
 460
 461 inline static e_smx_state_t simcall_BODY_execution_get_state(smx_synchro_t execution) {
 462     smx_process_t self = SIMIX_process_self();
 463
 464     /* Go to that function to follow the code flow through the simcall barrier */
 465     if (0) SIMIX_execution_get_state(execution);
 466     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 467
 468     self->simcall.call = SIMCALL_EXECUTION_GET_STATE;
 469     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 470     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 471     self->simcall.args[0].dp = (void*) execution;
 472     if (self != simix_global->maestro_process) {
 473       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 474                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 475       SIMIX_process_yield(self);
 476     } else {
 477       SIMIX_simcall_handle(&self->simcall, 0);
 478     }
 479     return (e_smx_state_t) self->simcall.result.i;
 480   }
 481
 482 inline static void simcall_BODY_execution_set_priority(smx_synchro_t execution, double priority) {
 483     smx_process_t self = SIMIX_process_self();
 484
 485     /* Go to that function to follow the code flow through the simcall barrier */
 486     if (0) SIMIX_execution_set_priority(execution, priority);
 487     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 488
 489     self->simcall.call = SIMCALL_EXECUTION_SET_PRIORITY;
 490     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 491     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 492     self->simcall.args[0].dp = (void*) execution;
 493     self->simcall.args[1].d = (double) priority;
 494     if (self != simix_global->maestro_process) {
 495       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 496                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 497       SIMIX_process_yield(self);
 498     } else {
 499       SIMIX_simcall_handle(&self->simcall, 0);
 500     }
 501
 502   }
 503
 504 inline static void simcall_BODY_execution_set_bound(smx_synchro_t execution, double bound) {
 505     smx_process_t self = SIMIX_process_self();
 506
 507     /* Go to that function to follow the code flow through the simcall barrier */
 508     if (0) SIMIX_execution_set_bound(execution, bound);
 509     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 510
 511     self->simcall.call = SIMCALL_EXECUTION_SET_BOUND;
 512     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 513     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 514     self->simcall.args[0].dp = (void*) execution;
 515     self->simcall.args[1].d = (double) bound;
 516     if (self != simix_global->maestro_process) {
 517       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 518                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 519       SIMIX_process_yield(self);
 520     } else {
 521       SIMIX_simcall_handle(&self->simcall, 0);
 522     }
 523
 524   }
 525
 526 inline static void simcall_BODY_execution_set_affinity(smx_synchro_t execution, sg_host_t ws, unsigned long mask) {
 527     smx_process_t self = SIMIX_process_self();
 528
 529     /* Go to that function to follow the code flow through the simcall barrier */
 530     if (0) SIMIX_execution_set_affinity(execution, ws, mask);
 531     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 532
 533     self->simcall.call = SIMCALL_EXECUTION_SET_AFFINITY;
 534     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 535     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 536     self->simcall.args[0].dp = (void*) execution;
 537     self->simcall.args[1].dp = (void*) ws;
 538     self->simcall.args[2].ul = (unsigned long) mask;
 539     if (self != simix_global->maestro_process) {
 540       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 541                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 542       SIMIX_process_yield(self);
 543     } else {
 544       SIMIX_simcall_handle(&self->simcall, 0);
 545     }
 546
 547   }
 548
 549 inline static int simcall_BODY_execution_wait(smx_synchro_t execution) {
 550     smx_process_t self = SIMIX_process_self();
 551
 552     /* Go to that function to follow the code flow through the simcall barrier */
 553     if (0) simcall_HANDLER_execution_wait(&self->simcall, execution);
 554     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 555
 556     self->simcall.call = SIMCALL_EXECUTION_WAIT;
 557     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 558     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 559     self->simcall.args[0].dp = (void*) execution;
 560     if (self != simix_global->maestro_process) {
 561       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 562                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 563       SIMIX_process_yield(self);
 564     } else {
 565       SIMIX_simcall_handle(&self->simcall, 0);
 566     }
 567     return (int) self->simcall.result.i;
 568   }
 569
 570 inline static void simcall_BODY_process_on_exit(smx_process_t process, int_f_pvoid_pvoid_t fun, void* data) {
 571     smx_process_t self = SIMIX_process_self();
 572
 573     /* Go to that function to follow the code flow through the simcall barrier */
 574     if (0) SIMIX_process_on_exit(process, fun, data);
 575     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 576
 577     self->simcall.call = SIMCALL_PROCESS_ON_EXIT;
 578     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 579     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 580     self->simcall.args[0].dp = (void*) process;
 581     self->simcall.args[1].fp = (FPtr) fun;
 582     self->simcall.args[2].dp = (void*) data;
 583     if (self != simix_global->maestro_process) {
 584       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 585                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 586       SIMIX_process_yield(self);
 587     } else {
 588       SIMIX_simcall_handle(&self->simcall, 0);
 589     }
 590
 591   }
 592
 593 inline static void simcall_BODY_process_auto_restart_set(smx_process_t process, int auto_restart) {
 594     smx_process_t self = SIMIX_process_self();
 595
 596     /* Go to that function to follow the code flow through the simcall barrier */
 597     if (0) SIMIX_process_auto_restart_set(process, auto_restart);
 598     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 599
 600     self->simcall.call = SIMCALL_PROCESS_AUTO_RESTART_SET;
 601     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 602     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 603     self->simcall.args[0].dp = (void*) process;
 604     self->simcall.args[1].i = (int) auto_restart;
 605     if (self != simix_global->maestro_process) {
 606       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 607                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 608       SIMIX_process_yield(self);
 609     } else {
 610       SIMIX_simcall_handle(&self->simcall, 0);
 611     }
 612
 613   }
 614
 615 inline static smx_process_t simcall_BODY_process_restart(smx_process_t process) {
 616     smx_process_t self = SIMIX_process_self();
 617
 618     /* Go to that function to follow the code flow through the simcall barrier */
 619     if (0) simcall_HANDLER_process_restart(&self->simcall, process);
 620     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 621
 622     self->simcall.call = SIMCALL_PROCESS_RESTART;
 623     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 624     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 625     self->simcall.args[0].dp = (void*) process;
 626     if (self != simix_global->maestro_process) {
 627       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 628                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 629       SIMIX_process_yield(self);
 630     } else {
 631       SIMIX_simcall_handle(&self->simcall, 0);
 632     }
 633     return (smx_process_t) self->simcall.result.dp;
 634   }
 635
 636 inline static smx_mailbox_t simcall_BODY_mbox_create(const char* name) {
 637     smx_process_t self = SIMIX_process_self();
 638
 639     /* Go to that function to follow the code flow through the simcall barrier */
 640     if (0) SIMIX_mbox_create(name);
 641     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 642
 643     self->simcall.call = SIMCALL_MBOX_CREATE;
 644     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 645     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 646     self->simcall.args[0].cc = (const char*) name;
 647     if (self != simix_global->maestro_process) {
 648       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 649                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 650       SIMIX_process_yield(self);
 651     } else {
 652       SIMIX_simcall_handle(&self->simcall, 0);
 653     }
 654     return (smx_mailbox_t) self->simcall.result.dp;
 655   }
 656
 657 inline static unsigned int simcall_BODY_mbox_comm_count_by_host(smx_mailbox_t mbox, sg_host_t host) {
 658     smx_process_t self = SIMIX_process_self();
 659
 660     /* Go to that function to follow the code flow through the simcall barrier */
 661     if (0) SIMIX_mbox_comm_count_by_host(mbox, host);
 662     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 663
 664     self->simcall.call = SIMCALL_MBOX_COMM_COUNT_BY_HOST;
 665     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 666     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 667     self->simcall.args[0].dp = (void*) mbox;
 668     self->simcall.args[1].dp = (void*) host;
 669     if (self != simix_global->maestro_process) {
 670       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 671                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 672       SIMIX_process_yield(self);
 673     } else {
 674       SIMIX_simcall_handle(&self->simcall, 0);
 675     }
 676     return (unsigned int) self->simcall.result.ui;
 677   }
 678
 679 inline static smx_synchro_t simcall_BODY_mbox_get_head(smx_mailbox_t mbox) {
 680     smx_process_t self = SIMIX_process_self();
 681
 682     /* Go to that function to follow the code flow through the simcall barrier */
 683     if (0) SIMIX_mbox_get_head(mbox);
 684     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 685
 686     self->simcall.call = SIMCALL_MBOX_GET_HEAD;
 687     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 688     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 689     self->simcall.args[0].dp = (void*) mbox;
 690     if (self != simix_global->maestro_process) {
 691       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 692                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 693       SIMIX_process_yield(self);
 694     } else {
 695       SIMIX_simcall_handle(&self->simcall, 0);
 696     }
 697     return (smx_synchro_t) self->simcall.result.dp;
 698   }
 699
 700 inline static void simcall_BODY_mbox_set_receiver(smx_mailbox_t mbox, smx_process_t receiver) {
 701     smx_process_t self = SIMIX_process_self();
 702
 703     /* Go to that function to follow the code flow through the simcall barrier */
 704     if (0) SIMIX_mbox_set_receiver(mbox, receiver);
 705     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 706
 707     self->simcall.call = SIMCALL_MBOX_SET_RECEIVER;
 708     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 709     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 710     self->simcall.args[0].dp = (void*) mbox;
 711     self->simcall.args[1].dp = (void*) receiver;
 712     if (self != simix_global->maestro_process) {
 713       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 714                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 715       SIMIX_process_yield(self);
 716     } else {
 717       SIMIX_simcall_handle(&self->simcall, 0);
 718     }
 719
 720   }
 721
 722 inline static smx_process_t simcall_BODY_mbox_get_receiver(smx_mailbox_t mbox) {
 723     smx_process_t self = SIMIX_process_self();
 724
 725     /* Go to that function to follow the code flow through the simcall barrier */
 726     if (0) SIMIX_mbox_get_receiver(mbox);
 727     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 728
 729     self->simcall.call = SIMCALL_MBOX_GET_RECEIVER;
 730     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 731     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 732     self->simcall.args[0].dp = (void*) mbox;
 733     if (self != simix_global->maestro_process) {
 734       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 735                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 736       SIMIX_process_yield(self);
 737     } else {
 738       SIMIX_simcall_handle(&self->simcall, 0);
 739     }
 740     return (smx_process_t) self->simcall.result.dp;
 741   }
 742
 743 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) {
 744     smx_process_t self = SIMIX_process_self();
 745
 746     /* Go to that function to follow the code flow through the simcall barrier */
 747     if (0) simcall_HANDLER_comm_iprobe(&self->simcall, mbox, type, src, tag, match_fun, data);
 748     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 749
 750     self->simcall.call = SIMCALL_COMM_IPROBE;
 751     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 752     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 753     self->simcall.args[0].dp = (void*) mbox;
 754     self->simcall.args[1].i = (int) type;
 755     self->simcall.args[2].i = (int) src;
 756     self->simcall.args[3].i = (int) tag;
 757     self->simcall.args[4].fp = (FPtr) match_fun;
 758     self->simcall.args[5].dp = (void*) data;
 759     if (self != simix_global->maestro_process) {
 760       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 761                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 762       SIMIX_process_yield(self);
 763     } else {
 764       SIMIX_simcall_handle(&self->simcall, 0);
 765     }
 766     return (smx_synchro_t) self->simcall.result.dp;
 767   }
 768
 769 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) {
 770     smx_process_t self = SIMIX_process_self();
 771
 772     /* Go to that function to follow the code flow through the simcall barrier */
 773     if (0) simcall_HANDLER_comm_send(&self->simcall, sender, mbox, task_size, rate, src_buff, src_buff_size, match_fun, copy_data_fun, data, timeout);
 774     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 775
 776     self->simcall.call = SIMCALL_COMM_SEND;
 777     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 778     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 779     self->simcall.args[0].dp = (void*) sender;
 780     self->simcall.args[1].dp = (void*) mbox;
 781     self->simcall.args[2].d = (double) task_size;
 782     self->simcall.args[3].d = (double) rate;
 783     self->simcall.args[4].dp = (void*) src_buff;
 784     self->simcall.args[5].sz = (size_t) src_buff_size;
 785     self->simcall.args[6].fp = (FPtr) match_fun;
 786     self->simcall.args[7].fp = (FPtr) copy_data_fun;
 787     self->simcall.args[8].dp = (void*) data;
 788     self->simcall.args[9].d = (double) timeout;
 789     if (self != simix_global->maestro_process) {
 790       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 791                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 792       SIMIX_process_yield(self);
 793     } else {
 794       SIMIX_simcall_handle(&self->simcall, 0);
 795     }
 796
 797   }
 798
 799 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) {
 800     smx_process_t self = SIMIX_process_self();
 801
 802     /* Go to that function to follow the code flow through the simcall barrier */
 803     if (0) simcall_HANDLER_comm_isend(&self->simcall, sender, mbox, task_size, rate, src_buff, src_buff_size, match_fun, clean_fun, copy_data_fun, data, detached);
 804     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 805
 806     self->simcall.call = SIMCALL_COMM_ISEND;
 807     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 808     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 809     self->simcall.args[0].dp = (void*) sender;
 810     self->simcall.args[1].dp = (void*) mbox;
 811     self->simcall.args[2].d = (double) task_size;
 812     self->simcall.args[3].d = (double) rate;
 813     self->simcall.args[4].dp = (void*) src_buff;
 814     self->simcall.args[5].sz = (size_t) src_buff_size;
 815     self->simcall.args[6].fp = (FPtr) match_fun;
 816     self->simcall.args[7].fp = (FPtr) clean_fun;
 817     self->simcall.args[8].fp = (FPtr) copy_data_fun;
 818     self->simcall.args[9].dp = (void*) data;
 819     self->simcall.args[10].i = (int) detached;
 820     if (self != simix_global->maestro_process) {
 821       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 822                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 823       SIMIX_process_yield(self);
 824     } else {
 825       SIMIX_simcall_handle(&self->simcall, 0);
 826     }
 827     return (smx_synchro_t) self->simcall.result.dp;
 828   }
 829
 830 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) {
 831     smx_process_t self = SIMIX_process_self();
 832
 833     /* Go to that function to follow the code flow through the simcall barrier */
 834     if (0) simcall_HANDLER_comm_recv(&self->simcall, receiver, mbox, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, timeout, rate);
 835     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 836
 837     self->simcall.call = SIMCALL_COMM_RECV;
 838     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 839     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 840     self->simcall.args[0].dp = (void*) receiver;
 841     self->simcall.args[1].dp = (void*) mbox;
 842     self->simcall.args[2].dp = (void*) dst_buff;
 843     self->simcall.args[3].dp = (void*) dst_buff_size;
 844     self->simcall.args[4].fp = (FPtr) match_fun;
 845     self->simcall.args[5].fp = (FPtr) copy_data_fun;
 846     self->simcall.args[6].dp = (void*) data;
 847     self->simcall.args[7].d = (double) timeout;
 848     self->simcall.args[8].d = (double) rate;
 849     if (self != simix_global->maestro_process) {
 850       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 851                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 852       SIMIX_process_yield(self);
 853     } else {
 854       SIMIX_simcall_handle(&self->simcall, 0);
 855     }
 856
 857   }
 858
 859 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) {
 860     smx_process_t self = SIMIX_process_self();
 861
 862     /* Go to that function to follow the code flow through the simcall barrier */
 863     if (0) simcall_HANDLER_comm_irecv(&self->simcall, receiver, mbox, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, rate);
 864     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 865
 866     self->simcall.call = SIMCALL_COMM_IRECV;
 867     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 868     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 869     self->simcall.args[0].dp = (void*) receiver;
 870     self->simcall.args[1].dp = (void*) mbox;
 871     self->simcall.args[2].dp = (void*) dst_buff;
 872     self->simcall.args[3].dp = (void*) dst_buff_size;
 873     self->simcall.args[4].fp = (FPtr) match_fun;
 874     self->simcall.args[5].fp = (FPtr) copy_data_fun;
 875     self->simcall.args[6].dp = (void*) data;
 876     self->simcall.args[7].d = (double) rate;
 877     if (self != simix_global->maestro_process) {
 878       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 879                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 880       SIMIX_process_yield(self);
 881     } else {
 882       SIMIX_simcall_handle(&self->simcall, 0);
 883     }
 884     return (smx_synchro_t) self->simcall.result.dp;
 885   }
 886
 887 inline static void simcall_BODY_comm_cancel(smx_synchro_t comm) {
 888     smx_process_t self = SIMIX_process_self();
 889
 890     /* Go to that function to follow the code flow through the simcall barrier */
 891     if (0) SIMIX_comm_cancel(comm);
 892     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 893
 894     self->simcall.call = SIMCALL_COMM_CANCEL;
 895     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 896     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 897     self->simcall.args[0].dp = (void*) comm;
 898     if (self != simix_global->maestro_process) {
 899       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 900                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 901       SIMIX_process_yield(self);
 902     } else {
 903       SIMIX_simcall_handle(&self->simcall, 0);
 904     }
 905
 906   }
 907
 908 inline static int simcall_BODY_comm_waitany(xbt_dynar_t comms) {
 909     smx_process_t self = SIMIX_process_self();
 910
 911     /* Go to that function to follow the code flow through the simcall barrier */
 912     if (0) simcall_HANDLER_comm_waitany(&self->simcall, comms);
 913     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 914
 915     self->simcall.call = SIMCALL_COMM_WAITANY;
 916     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 917     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 918     self->simcall.args[0].dp = (void*) comms;
 919     if (self != simix_global->maestro_process) {
 920       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 921                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 922       SIMIX_process_yield(self);
 923     } else {
 924       SIMIX_simcall_handle(&self->simcall, 0);
 925     }
 926     return (int) self->simcall.result.i;
 927   }
 928
 929 inline static void simcall_BODY_comm_wait(smx_synchro_t comm, double timeout) {
 930     smx_process_t self = SIMIX_process_self();
 931
 932     /* Go to that function to follow the code flow through the simcall barrier */
 933     if (0) simcall_HANDLER_comm_wait(&self->simcall, comm, timeout);
 934     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 935
 936     self->simcall.call = SIMCALL_COMM_WAIT;
 937     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 938     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 939     self->simcall.args[0].dp = (void*) comm;
 940     self->simcall.args[1].d = (double) timeout;
 941     if (self != simix_global->maestro_process) {
 942       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 943                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 944       SIMIX_process_yield(self);
 945     } else {
 946       SIMIX_simcall_handle(&self->simcall, 0);
 947     }
 948
 949   }
 950
 951 inline static int simcall_BODY_comm_test(smx_synchro_t comm) {
 952     smx_process_t self = SIMIX_process_self();
 953
 954     /* Go to that function to follow the code flow through the simcall barrier */
 955     if (0) simcall_HANDLER_comm_test(&self->simcall, comm);
 956     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 957
 958     self->simcall.call = SIMCALL_COMM_TEST;
 959     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 960     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 961     self->simcall.args[0].dp = (void*) comm;
 962     if (self != simix_global->maestro_process) {
 963       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 964                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 965       SIMIX_process_yield(self);
 966     } else {
 967       SIMIX_simcall_handle(&self->simcall, 0);
 968     }
 969     return (int) self->simcall.result.i;
 970   }
 971
 972 inline static int simcall_BODY_comm_testany(xbt_dynar_t comms) {
 973     smx_process_t self = SIMIX_process_self();
 974
 975     /* Go to that function to follow the code flow through the simcall barrier */
 976     if (0) simcall_HANDLER_comm_testany(&self->simcall, comms);
 977     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 978
 979     self->simcall.call = SIMCALL_COMM_TESTANY;
 980     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 981     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 982     self->simcall.args[0].dp = (void*) comms;
 983     if (self != simix_global->maestro_process) {
 984       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 985                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 986       SIMIX_process_yield(self);
 987     } else {
 988       SIMIX_simcall_handle(&self->simcall, 0);
 989     }
 990     return (int) self->simcall.result.i;
 991   }
 992
 993 inline static double simcall_BODY_comm_get_remains(smx_synchro_t comm) {
 994     smx_process_t self = SIMIX_process_self();
 995
 996     /* Go to that function to follow the code flow through the simcall barrier */
 997     if (0) SIMIX_comm_get_remains(comm);
 998     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 999
1000     self->simcall.call = SIMCALL_COMM_GET_REMAINS;
1001     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1002     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1003     self->simcall.args[0].dp = (void*) comm;
1004     if (self != simix_global->maestro_process) {
1005       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1006                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1007       SIMIX_process_yield(self);
1008     } else {
1009       SIMIX_simcall_handle(&self->simcall, 0);
1010     }
1011     return (double) self->simcall.result.d;
1012   }
1013
1014 inline static e_smx_state_t simcall_BODY_comm_get_state(smx_synchro_t comm) {
1015     smx_process_t self = SIMIX_process_self();
1016
1017     /* Go to that function to follow the code flow through the simcall barrier */
1018     if (0) SIMIX_comm_get_state(comm);
1019     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1020
1021     self->simcall.call = SIMCALL_COMM_GET_STATE;
1022     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1023     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1024     self->simcall.args[0].dp = (void*) comm;
1025     if (self != simix_global->maestro_process) {
1026       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1027                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1028       SIMIX_process_yield(self);
1029     } else {
1030       SIMIX_simcall_handle(&self->simcall, 0);
1031     }
1032     return (e_smx_state_t) self->simcall.result.i;
1033   }
1034
1035 inline static void* simcall_BODY_comm_get_src_data(smx_synchro_t comm) {
1036     smx_process_t self = SIMIX_process_self();
1037
1038     /* Go to that function to follow the code flow through the simcall barrier */
1039     if (0) SIMIX_comm_get_src_data(comm);
1040     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1041
1042     self->simcall.call = SIMCALL_COMM_GET_SRC_DATA;
1043     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1044     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1045     self->simcall.args[0].dp = (void*) comm;
1046     if (self != simix_global->maestro_process) {
1047       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1048                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1049       SIMIX_process_yield(self);
1050     } else {
1051       SIMIX_simcall_handle(&self->simcall, 0);
1052     }
1053     return (void*) self->simcall.result.dp;
1054   }
1055
1056 inline static void* simcall_BODY_comm_get_dst_data(smx_synchro_t comm) {
1057     smx_process_t self = SIMIX_process_self();
1058
1059     /* Go to that function to follow the code flow through the simcall barrier */
1060     if (0) SIMIX_comm_get_dst_data(comm);
1061     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1062
1063     self->simcall.call = SIMCALL_COMM_GET_DST_DATA;
1064     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1065     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1066     self->simcall.args[0].dp = (void*) comm;
1067     if (self != simix_global->maestro_process) {
1068       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1069                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1070       SIMIX_process_yield(self);
1071     } else {
1072       SIMIX_simcall_handle(&self->simcall, 0);
1073     }
1074     return (void*) self->simcall.result.dp;
1075   }
1076
1077 inline static smx_process_t simcall_BODY_comm_get_src_proc(smx_synchro_t comm) {
1078     smx_process_t self = SIMIX_process_self();
1079
1080     /* Go to that function to follow the code flow through the simcall barrier */
1081     if (0) SIMIX_comm_get_src_proc(comm);
1082     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1083
1084     self->simcall.call = SIMCALL_COMM_GET_SRC_PROC;
1085     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1086     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1087     self->simcall.args[0].dp = (void*) comm;
1088     if (self != simix_global->maestro_process) {
1089       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1090                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1091       SIMIX_process_yield(self);
1092     } else {
1093       SIMIX_simcall_handle(&self->simcall, 0);
1094     }
1095     return (smx_process_t) self->simcall.result.dp;
1096   }
1097
1098 inline static smx_process_t simcall_BODY_comm_get_dst_proc(smx_synchro_t comm) {
1099     smx_process_t self = SIMIX_process_self();
1100
1101     /* Go to that function to follow the code flow through the simcall barrier */
1102     if (0) SIMIX_comm_get_dst_proc(comm);
1103     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1104
1105     self->simcall.call = SIMCALL_COMM_GET_DST_PROC;
1106     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1107     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1108     self->simcall.args[0].dp = (void*) comm;
1109     if (self != simix_global->maestro_process) {
1110       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1111                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1112       SIMIX_process_yield(self);
1113     } else {
1114       SIMIX_simcall_handle(&self->simcall, 0);
1115     }
1116     return (smx_process_t) self->simcall.result.dp;
1117   }
1118
1119 inline static smx_mutex_t simcall_BODY_mutex_init() {
1120     smx_process_t self = SIMIX_process_self();
1121
1122     /* Go to that function to follow the code flow through the simcall barrier */
1123     if (0) simcall_HANDLER_mutex_init(&self->simcall);
1124     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1125
1126     self->simcall.call = SIMCALL_MUTEX_INIT;
1127     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1128     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1129
1130     if (self != simix_global->maestro_process) {
1131       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1132                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1133       SIMIX_process_yield(self);
1134     } else {
1135       SIMIX_simcall_handle(&self->simcall, 0);
1136     }
1137     return (smx_mutex_t) self->simcall.result.dp;
1138   }
1139
1140 inline static void simcall_BODY_mutex_lock(smx_mutex_t mutex) {
1141     smx_process_t self = SIMIX_process_self();
1142
1143     /* Go to that function to follow the code flow through the simcall barrier */
1144     if (0) simcall_HANDLER_mutex_lock(&self->simcall, mutex);
1145     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1146
1147     self->simcall.call = SIMCALL_MUTEX_LOCK;
1148     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1149     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1150     self->simcall.args[0].dp = (void*) mutex;
1151     if (self != simix_global->maestro_process) {
1152       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1153                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1154       SIMIX_process_yield(self);
1155     } else {
1156       SIMIX_simcall_handle(&self->simcall, 0);
1157     }
1158
1159   }
1160
1161 inline static int simcall_BODY_mutex_trylock(smx_mutex_t mutex) {
1162     smx_process_t self = SIMIX_process_self();
1163
1164     /* Go to that function to follow the code flow through the simcall barrier */
1165     if (0) simcall_HANDLER_mutex_trylock(&self->simcall, mutex);
1166     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1167
1168     self->simcall.call = SIMCALL_MUTEX_TRYLOCK;
1169     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1170     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1171     self->simcall.args[0].dp = (void*) mutex;
1172     if (self != simix_global->maestro_process) {
1173       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1174                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1175       SIMIX_process_yield(self);
1176     } else {
1177       SIMIX_simcall_handle(&self->simcall, 0);
1178     }
1179     return (int) self->simcall.result.i;
1180   }
1181
1182 inline static void simcall_BODY_mutex_unlock(smx_mutex_t mutex) {
1183     smx_process_t self = SIMIX_process_self();
1184
1185     /* Go to that function to follow the code flow through the simcall barrier */
1186     if (0) simcall_HANDLER_mutex_unlock(&self->simcall, mutex);
1187     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1188
1189     self->simcall.call = SIMCALL_MUTEX_UNLOCK;
1190     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1191     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1192     self->simcall.args[0].dp = (void*) mutex;
1193     if (self != simix_global->maestro_process) {
1194       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1195                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1196       SIMIX_process_yield(self);
1197     } else {
1198       SIMIX_simcall_handle(&self->simcall, 0);
1199     }
1200
1201   }
1202
1203 inline static smx_cond_t simcall_BODY_cond_init() {
1204     smx_process_t self = SIMIX_process_self();
1205
1206     /* Go to that function to follow the code flow through the simcall barrier */
1207     if (0) SIMIX_cond_init();
1208     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1209
1210     self->simcall.call = SIMCALL_COND_INIT;
1211     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1212     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1213
1214     if (self != simix_global->maestro_process) {
1215       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1216                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1217       SIMIX_process_yield(self);
1218     } else {
1219       SIMIX_simcall_handle(&self->simcall, 0);
1220     }
1221     return (smx_cond_t) self->simcall.result.dp;
1222   }
1223
1224 inline static void simcall_BODY_cond_signal(smx_cond_t cond) {
1225     smx_process_t self = SIMIX_process_self();
1226
1227     /* Go to that function to follow the code flow through the simcall barrier */
1228     if (0) SIMIX_cond_signal(cond);
1229     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1230
1231     self->simcall.call = SIMCALL_COND_SIGNAL;
1232     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1233     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1234     self->simcall.args[0].dp = (void*) cond;
1235     if (self != simix_global->maestro_process) {
1236       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1237                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1238       SIMIX_process_yield(self);
1239     } else {
1240       SIMIX_simcall_handle(&self->simcall, 0);
1241     }
1242
1243   }
1244
1245 inline static void simcall_BODY_cond_wait(smx_cond_t cond, smx_mutex_t mutex) {
1246     smx_process_t self = SIMIX_process_self();
1247
1248     /* Go to that function to follow the code flow through the simcall barrier */
1249     if (0) simcall_HANDLER_cond_wait(&self->simcall, cond, mutex);
1250     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1251
1252     self->simcall.call = SIMCALL_COND_WAIT;
1253     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1254     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1255     self->simcall.args[0].dp = (void*) cond;
1256     self->simcall.args[1].dp = (void*) mutex;
1257     if (self != simix_global->maestro_process) {
1258       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1259                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1260       SIMIX_process_yield(self);
1261     } else {
1262       SIMIX_simcall_handle(&self->simcall, 0);
1263     }
1264
1265   }
1266
1267 inline static void simcall_BODY_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double timeout) {
1268     smx_process_t self = SIMIX_process_self();
1269
1270     /* Go to that function to follow the code flow through the simcall barrier */
1271     if (0) simcall_HANDLER_cond_wait_timeout(&self->simcall, cond, mutex, timeout);
1272     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1273
1274     self->simcall.call = SIMCALL_COND_WAIT_TIMEOUT;
1275     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1276     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1277     self->simcall.args[0].dp = (void*) cond;
1278     self->simcall.args[1].dp = (void*) mutex;
1279     self->simcall.args[2].d = (double) timeout;
1280     if (self != simix_global->maestro_process) {
1281       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1282                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1283       SIMIX_process_yield(self);
1284     } else {
1285       SIMIX_simcall_handle(&self->simcall, 0);
1286     }
1287
1288   }
1289
1290 inline static void simcall_BODY_cond_broadcast(smx_cond_t cond) {
1291     smx_process_t self = SIMIX_process_self();
1292
1293     /* Go to that function to follow the code flow through the simcall barrier */
1294     if (0) SIMIX_cond_broadcast(cond);
1295     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1296
1297     self->simcall.call = SIMCALL_COND_BROADCAST;
1298     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1299     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1300     self->simcall.args[0].dp = (void*) cond;
1301     if (self != simix_global->maestro_process) {
1302       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1303                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1304       SIMIX_process_yield(self);
1305     } else {
1306       SIMIX_simcall_handle(&self->simcall, 0);
1307     }
1308
1309   }
1310
1311 inline static smx_sem_t simcall_BODY_sem_init(unsigned int capacity) {
1312     smx_process_t self = SIMIX_process_self();
1313
1314     /* Go to that function to follow the code flow through the simcall barrier */
1315     if (0) SIMIX_sem_init(capacity);
1316     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1317
1318     self->simcall.call = SIMCALL_SEM_INIT;
1319     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1320     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1321     self->simcall.args[0].ui = (unsigned int) capacity;
1322     if (self != simix_global->maestro_process) {
1323       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1324                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1325       SIMIX_process_yield(self);
1326     } else {
1327       SIMIX_simcall_handle(&self->simcall, 0);
1328     }
1329     return (smx_sem_t) self->simcall.result.dp;
1330   }
1331
1332 inline static void simcall_BODY_sem_release(smx_sem_t sem) {
1333     smx_process_t self = SIMIX_process_self();
1334
1335     /* Go to that function to follow the code flow through the simcall barrier */
1336     if (0) simcall_HANDLER_sem_release(&self->simcall, sem);
1337     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1338
1339     self->simcall.call = SIMCALL_SEM_RELEASE;
1340     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1341     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1342     self->simcall.args[0].dp = (void*) sem;
1343     if (self != simix_global->maestro_process) {
1344       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1345                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1346       SIMIX_process_yield(self);
1347     } else {
1348       SIMIX_simcall_handle(&self->simcall, 0);
1349     }
1350
1351   }
1352
1353 inline static int simcall_BODY_sem_would_block(smx_sem_t sem) {
1354     smx_process_t self = SIMIX_process_self();
1355
1356     /* Go to that function to follow the code flow through the simcall barrier */
1357     if (0) simcall_HANDLER_sem_would_block(&self->simcall, sem);
1358     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1359
1360     self->simcall.call = SIMCALL_SEM_WOULD_BLOCK;
1361     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1362     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1363     self->simcall.args[0].dp = (void*) sem;
1364     if (self != simix_global->maestro_process) {
1365       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1366                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1367       SIMIX_process_yield(self);
1368     } else {
1369       SIMIX_simcall_handle(&self->simcall, 0);
1370     }
1371     return (int) self->simcall.result.i;
1372   }
1373
1374 inline static void simcall_BODY_sem_acquire(smx_sem_t sem) {
1375     smx_process_t self = SIMIX_process_self();
1376
1377     /* Go to that function to follow the code flow through the simcall barrier */
1378     if (0) simcall_HANDLER_sem_acquire(&self->simcall, sem);
1379     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1380
1381     self->simcall.call = SIMCALL_SEM_ACQUIRE;
1382     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1383     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1384     self->simcall.args[0].dp = (void*) sem;
1385     if (self != simix_global->maestro_process) {
1386       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1387                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1388       SIMIX_process_yield(self);
1389     } else {
1390       SIMIX_simcall_handle(&self->simcall, 0);
1391     }
1392
1393   }
1394
1395 inline static void simcall_BODY_sem_acquire_timeout(smx_sem_t sem, double timeout) {
1396     smx_process_t self = SIMIX_process_self();
1397
1398     /* Go to that function to follow the code flow through the simcall barrier */
1399     if (0) simcall_HANDLER_sem_acquire_timeout(&self->simcall, sem, timeout);
1400     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1401
1402     self->simcall.call = SIMCALL_SEM_ACQUIRE_TIMEOUT;
1403     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1404     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1405     self->simcall.args[0].dp = (void*) sem;
1406     self->simcall.args[1].d = (double) timeout;
1407     if (self != simix_global->maestro_process) {
1408       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1409                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1410       SIMIX_process_yield(self);
1411     } else {
1412       SIMIX_simcall_handle(&self->simcall, 0);
1413     }
1414
1415   }
1416
1417 inline static int simcall_BODY_sem_get_capacity(smx_sem_t sem) {
1418     smx_process_t self = SIMIX_process_self();
1419
1420     /* Go to that function to follow the code flow through the simcall barrier */
1421     if (0) simcall_HANDLER_sem_get_capacity(&self->simcall, sem);
1422     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1423
1424     self->simcall.call = SIMCALL_SEM_GET_CAPACITY;
1425     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1426     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1427     self->simcall.args[0].dp = (void*) sem;
1428     if (self != simix_global->maestro_process) {
1429       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1430                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1431       SIMIX_process_yield(self);
1432     } else {
1433       SIMIX_simcall_handle(&self->simcall, 0);
1434     }
1435     return (int) self->simcall.result.i;
1436   }
1437
1438 inline static sg_size_t simcall_BODY_file_read(smx_file_t fd, sg_size_t size, sg_host_t host) {
1439     smx_process_t self = SIMIX_process_self();
1440
1441     /* Go to that function to follow the code flow through the simcall barrier */
1442     if (0) simcall_HANDLER_file_read(&self->simcall, fd, size, host);
1443     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1444
1445     self->simcall.call = SIMCALL_FILE_READ;
1446     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1447     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1448     self->simcall.args[0].dp = (void*) fd;
1449     self->simcall.args[1].sgsz = (sg_size_t) size;
1450     self->simcall.args[2].dp = (void*) host;
1451     if (self != simix_global->maestro_process) {
1452       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1453                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1454       SIMIX_process_yield(self);
1455     } else {
1456       SIMIX_simcall_handle(&self->simcall, 0);
1457     }
1458     return (sg_size_t) self->simcall.result.sgsz;
1459   }
1460
1461 inline static sg_size_t simcall_BODY_file_write(smx_file_t fd, sg_size_t size, sg_host_t host) {
1462     smx_process_t self = SIMIX_process_self();
1463
1464     /* Go to that function to follow the code flow through the simcall barrier */
1465     if (0) simcall_HANDLER_file_write(&self->simcall, fd, size, host);
1466     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1467
1468     self->simcall.call = SIMCALL_FILE_WRITE;
1469     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1470     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1471     self->simcall.args[0].dp = (void*) fd;
1472     self->simcall.args[1].sgsz = (sg_size_t) size;
1473     self->simcall.args[2].dp = (void*) host;
1474     if (self != simix_global->maestro_process) {
1475       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1476                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1477       SIMIX_process_yield(self);
1478     } else {
1479       SIMIX_simcall_handle(&self->simcall, 0);
1480     }
1481     return (sg_size_t) self->simcall.result.sgsz;
1482   }
1483
1484 inline static smx_file_t simcall_BODY_file_open(const char* fullpath, sg_host_t host) {
1485     smx_process_t self = SIMIX_process_self();
1486
1487     /* Go to that function to follow the code flow through the simcall barrier */
1488     if (0) simcall_HANDLER_file_open(&self->simcall, fullpath, host);
1489     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1490
1491     self->simcall.call = SIMCALL_FILE_OPEN;
1492     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1493     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1494     self->simcall.args[0].cc = (const char*) fullpath;
1495     self->simcall.args[1].dp = (void*) host;
1496     if (self != simix_global->maestro_process) {
1497       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1498                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1499       SIMIX_process_yield(self);
1500     } else {
1501       SIMIX_simcall_handle(&self->simcall, 0);
1502     }
1503     return (smx_file_t) self->simcall.result.dp;
1504   }
1505
1506 inline static int simcall_BODY_file_close(smx_file_t fd, sg_host_t host) {
1507     smx_process_t self = SIMIX_process_self();
1508
1509     /* Go to that function to follow the code flow through the simcall barrier */
1510     if (0) simcall_HANDLER_file_close(&self->simcall, fd, host);
1511     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1512
1513     self->simcall.call = SIMCALL_FILE_CLOSE;
1514     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1515     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1516     self->simcall.args[0].dp = (void*) fd;
1517     self->simcall.args[1].dp = (void*) host;
1518     if (self != simix_global->maestro_process) {
1519       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1520                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1521       SIMIX_process_yield(self);
1522     } else {
1523       SIMIX_simcall_handle(&self->simcall, 0);
1524     }
1525     return (int) self->simcall.result.i;
1526   }
1527
1528 inline static int simcall_BODY_file_unlink(smx_file_t fd, sg_host_t host) {
1529     smx_process_t self = SIMIX_process_self();
1530
1531     /* Go to that function to follow the code flow through the simcall barrier */
1532     if (0) SIMIX_file_unlink(fd, host);
1533     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1534
1535     self->simcall.call = SIMCALL_FILE_UNLINK;
1536     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1537     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1538     self->simcall.args[0].dp = (void*) fd;
1539     self->simcall.args[1].dp = (void*) host;
1540     if (self != simix_global->maestro_process) {
1541       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1542                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1543       SIMIX_process_yield(self);
1544     } else {
1545       SIMIX_simcall_handle(&self->simcall, 0);
1546     }
1547     return (int) self->simcall.result.i;
1548   }
1549
1550 inline static sg_size_t simcall_BODY_file_get_size(smx_file_t fd) {
1551     smx_process_t self = SIMIX_process_self();
1552
1553     /* Go to that function to follow the code flow through the simcall barrier */
1554     if (0) simcall_HANDLER_file_get_size(&self->simcall, fd);
1555     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1556
1557     self->simcall.call = SIMCALL_FILE_GET_SIZE;
1558     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1559     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1560     self->simcall.args[0].dp = (void*) fd;
1561     if (self != simix_global->maestro_process) {
1562       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1563                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1564       SIMIX_process_yield(self);
1565     } else {
1566       SIMIX_simcall_handle(&self->simcall, 0);
1567     }
1568     return (sg_size_t) self->simcall.result.sgsz;
1569   }
1570
1571 inline static sg_size_t simcall_BODY_file_tell(smx_file_t fd) {
1572     smx_process_t self = SIMIX_process_self();
1573
1574     /* Go to that function to follow the code flow through the simcall barrier */
1575     if (0) simcall_HANDLER_file_tell(&self->simcall, fd);
1576     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1577
1578     self->simcall.call = SIMCALL_FILE_TELL;
1579     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1580     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1581     self->simcall.args[0].dp = (void*) fd;
1582     if (self != simix_global->maestro_process) {
1583       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1584                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1585       SIMIX_process_yield(self);
1586     } else {
1587       SIMIX_simcall_handle(&self->simcall, 0);
1588     }
1589     return (sg_size_t) self->simcall.result.sgsz;
1590   }
1591
1592 inline static int simcall_BODY_file_seek(smx_file_t fd, sg_offset_t offset, int origin) {
1593     smx_process_t self = SIMIX_process_self();
1594
1595     /* Go to that function to follow the code flow through the simcall barrier */
1596     if (0) simcall_HANDLER_file_seek(&self->simcall, fd, offset, origin);
1597     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1598
1599     self->simcall.call = SIMCALL_FILE_SEEK;
1600     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1601     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1602     self->simcall.args[0].dp = (void*) fd;
1603     self->simcall.args[1].sgoff = (sg_offset_t) offset;
1604     self->simcall.args[2].i = (int) origin;
1605     if (self != simix_global->maestro_process) {
1606       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1607                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1608       SIMIX_process_yield(self);
1609     } else {
1610       SIMIX_simcall_handle(&self->simcall, 0);
1611     }
1612     return (int) self->simcall.result.i;
1613   }
1614
1615 inline static xbt_dynar_t simcall_BODY_file_get_info(smx_file_t fd) {
1616     smx_process_t self = SIMIX_process_self();
1617
1618     /* Go to that function to follow the code flow through the simcall barrier */
1619     if (0) simcall_HANDLER_file_get_info(&self->simcall, fd);
1620     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1621
1622     self->simcall.call = SIMCALL_FILE_GET_INFO;
1623     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1624     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1625     self->simcall.args[0].dp = (void*) fd;
1626     if (self != simix_global->maestro_process) {
1627       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1628                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1629       SIMIX_process_yield(self);
1630     } else {
1631       SIMIX_simcall_handle(&self->simcall, 0);
1632     }
1633     return (xbt_dynar_t) self->simcall.result.dp;
1634   }
1635
1636 inline static int simcall_BODY_file_move(smx_file_t fd, const char* fullpath) {
1637     smx_process_t self = SIMIX_process_self();
1638
1639     /* Go to that function to follow the code flow through the simcall barrier */
1640     if (0) simcall_HANDLER_file_move(&self->simcall, fd, fullpath);
1641     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1642
1643     self->simcall.call = SIMCALL_FILE_MOVE;
1644     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1645     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1646     self->simcall.args[0].dp = (void*) fd;
1647     self->simcall.args[1].cc = (const char*) fullpath;
1648     if (self != simix_global->maestro_process) {
1649       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1650                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1651       SIMIX_process_yield(self);
1652     } else {
1653       SIMIX_simcall_handle(&self->simcall, 0);
1654     }
1655     return (int) self->simcall.result.i;
1656   }
1657
1658 inline static sg_size_t simcall_BODY_storage_get_free_size(smx_storage_t storage) {
1659     smx_process_t self = SIMIX_process_self();
1660
1661     /* Go to that function to follow the code flow through the simcall barrier */
1662     if (0) simcall_HANDLER_storage_get_free_size(&self->simcall, storage);
1663     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1664
1665     self->simcall.call = SIMCALL_STORAGE_GET_FREE_SIZE;
1666     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1667     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1668     self->simcall.args[0].dp = (void*) storage;
1669     if (self != simix_global->maestro_process) {
1670       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1671                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1672       SIMIX_process_yield(self);
1673     } else {
1674       SIMIX_simcall_handle(&self->simcall, 0);
1675     }
1676     return (sg_size_t) self->simcall.result.sgsz;
1677   }
1678
1679 inline static sg_size_t simcall_BODY_storage_get_used_size(smx_storage_t name) {
1680     smx_process_t self = SIMIX_process_self();
1681
1682     /* Go to that function to follow the code flow through the simcall barrier */
1683     if (0) simcall_HANDLER_storage_get_used_size(&self->simcall, name);
1684     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1685
1686     self->simcall.call = SIMCALL_STORAGE_GET_USED_SIZE;
1687     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1688     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1689     self->simcall.args[0].dp = (void*) name;
1690     if (self != simix_global->maestro_process) {
1691       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1692                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1693       SIMIX_process_yield(self);
1694     } else {
1695       SIMIX_simcall_handle(&self->simcall, 0);
1696     }
1697     return (sg_size_t) self->simcall.result.sgsz;
1698   }
1699
1700 inline static xbt_dict_t simcall_BODY_storage_get_properties(smx_storage_t storage) {
1701     smx_process_t self = SIMIX_process_self();
1702
1703     /* Go to that function to follow the code flow through the simcall barrier */
1704     if (0) SIMIX_storage_get_properties(storage);
1705     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1706
1707     self->simcall.call = SIMCALL_STORAGE_GET_PROPERTIES;
1708     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1709     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1710     self->simcall.args[0].dp = (void*) storage;
1711     if (self != simix_global->maestro_process) {
1712       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1713                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1714       SIMIX_process_yield(self);
1715     } else {
1716       SIMIX_simcall_handle(&self->simcall, 0);
1717     }
1718     return (xbt_dict_t) self->simcall.result.dp;
1719   }
1720
1721 inline static xbt_dict_t simcall_BODY_storage_get_content(smx_storage_t storage) {
1722     smx_process_t self = SIMIX_process_self();
1723
1724     /* Go to that function to follow the code flow through the simcall barrier */
1725     if (0) SIMIX_storage_get_content(storage);
1726     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1727
1728     self->simcall.call = SIMCALL_STORAGE_GET_CONTENT;
1729     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1730     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1731     self->simcall.args[0].dp = (void*) storage;
1732     if (self != simix_global->maestro_process) {
1733       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1734                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1735       SIMIX_process_yield(self);
1736     } else {
1737       SIMIX_simcall_handle(&self->simcall, 0);
1738     }
1739     return (xbt_dict_t) self->simcall.result.dp;
1740   }
1741
1742 inline static xbt_dict_t simcall_BODY_asr_get_properties(const char* name) {
1743     smx_process_t self = SIMIX_process_self();
1744
1745     /* Go to that function to follow the code flow through the simcall barrier */
1746     if (0) simcall_HANDLER_asr_get_properties(&self->simcall, name);
1747     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1748
1749     self->simcall.call = SIMCALL_ASR_GET_PROPERTIES;
1750     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1751     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1752     self->simcall.args[0].cc = (const char*) name;
1753     if (self != simix_global->maestro_process) {
1754       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1755                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1756       SIMIX_process_yield(self);
1757     } else {
1758       SIMIX_simcall_handle(&self->simcall, 0);
1759     }
1760     return (xbt_dict_t) self->simcall.result.dp;
1761   }
1762
1763 inline static int simcall_BODY_mc_random(int min, int max) {
1764     smx_process_t self = SIMIX_process_self();
1765
1766     /* Go to that function to follow the code flow through the simcall barrier */
1767     if (0) simcall_HANDLER_mc_random(&self->simcall, min, max);
1768     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1769
1770     self->simcall.call = SIMCALL_MC_RANDOM;
1771     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1772     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1773     self->simcall.args[0].i = (int) min;
1774     self->simcall.args[1].i = (int) max;
1775     if (self != simix_global->maestro_process) {
1776       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1777                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1778       SIMIX_process_yield(self);
1779     } else {
1780       SIMIX_simcall_handle(&self->simcall, 0);
1781     }
1782     return (int) self->simcall.result.i;
1783   }
1784
1785 inline static void simcall_BODY_set_category(smx_synchro_t synchro, const char* category) {
1786     smx_process_t self = SIMIX_process_self();
1787
1788     /* Go to that function to follow the code flow through the simcall barrier */
1789     if (0) SIMIX_set_category(synchro, category);
1790     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1791
1792     self->simcall.call = SIMCALL_SET_CATEGORY;
1793     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1794     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1795     self->simcall.args[0].dp = (void*) synchro;
1796     self->simcall.args[1].cc = (const char*) category;
1797     if (self != simix_global->maestro_process) {
1798       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1799                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1800       SIMIX_process_yield(self);
1801     } else {
1802       SIMIX_simcall_handle(&self->simcall, 0);
1803     }
1804
1805   }
1806
1807 inline static void simcall_BODY_run_kernel(void* code) {
1808     smx_process_t self = SIMIX_process_self();
1809
1810     /* Go to that function to follow the code flow through the simcall barrier */
1811     if (0) SIMIX_run_kernel(code);
1812     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1813
1814     self->simcall.call = SIMCALL_RUN_KERNEL;
1815     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1816     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1817     self->simcall.args[0].dp = (void*) code;
1818     if (self != simix_global->maestro_process) {
1819       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1820                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1821       SIMIX_process_yield(self);
1822     } else {
1823       SIMIX_simcall_handle(&self->simcall, 0);
1824     }
1825
1826   }