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 void simcall_BODY_execution_set_priority(smx_synchro_t execution, double priority) {
 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_set_priority(execution, priority);
 445     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 446
 447     self->simcall.call = SIMCALL_EXECUTION_SET_PRIORITY;
 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     self->simcall.args[1].d = (double) priority;
 452     if (self != simix_global->maestro_process) {
 453       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 454                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 455       SIMIX_process_yield(self);
 456     } else {
 457       SIMIX_simcall_handle(&self->simcall, 0);
 458     }
 459
 460   }
 461
 462 inline static void simcall_BODY_execution_set_bound(smx_synchro_t execution, double bound) {
 463     smx_process_t self = SIMIX_process_self();
 464
 465     /* Go to that function to follow the code flow through the simcall barrier */
 466     if (0) SIMIX_execution_set_bound(execution, bound);
 467     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 468
 469     self->simcall.call = SIMCALL_EXECUTION_SET_BOUND;
 470     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 471     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 472     self->simcall.args[0].dp = (void*) execution;
 473     self->simcall.args[1].d = (double) bound;
 474     if (self != simix_global->maestro_process) {
 475       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 476                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 477       SIMIX_process_yield(self);
 478     } else {
 479       SIMIX_simcall_handle(&self->simcall, 0);
 480     }
 481
 482   }
 483
 484 inline static void simcall_BODY_execution_set_affinity(smx_synchro_t execution, sg_host_t ws, unsigned long mask) {
 485     smx_process_t self = SIMIX_process_self();
 486
 487     /* Go to that function to follow the code flow through the simcall barrier */
 488     if (0) SIMIX_execution_set_affinity(execution, ws, mask);
 489     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 490
 491     self->simcall.call = SIMCALL_EXECUTION_SET_AFFINITY;
 492     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 493     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 494     self->simcall.args[0].dp = (void*) execution;
 495     self->simcall.args[1].dp = (void*) ws;
 496     self->simcall.args[2].ul = (unsigned long) mask;
 497     if (self != simix_global->maestro_process) {
 498       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 499                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 500       SIMIX_process_yield(self);
 501     } else {
 502       SIMIX_simcall_handle(&self->simcall, 0);
 503     }
 504
 505   }
 506
 507 inline static int simcall_BODY_execution_wait(smx_synchro_t execution) {
 508     smx_process_t self = SIMIX_process_self();
 509
 510     /* Go to that function to follow the code flow through the simcall barrier */
 511     if (0) simcall_HANDLER_execution_wait(&self->simcall, execution);
 512     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 513
 514     self->simcall.call = SIMCALL_EXECUTION_WAIT;
 515     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 516     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 517     self->simcall.args[0].dp = (void*) execution;
 518     if (self != simix_global->maestro_process) {
 519       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 520                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 521       SIMIX_process_yield(self);
 522     } else {
 523       SIMIX_simcall_handle(&self->simcall, 0);
 524     }
 525     return (int) self->simcall.result.i;
 526   }
 527
 528 inline static void simcall_BODY_process_on_exit(smx_process_t process, int_f_pvoid_pvoid_t fun, void* data) {
 529     smx_process_t self = SIMIX_process_self();
 530
 531     /* Go to that function to follow the code flow through the simcall barrier */
 532     if (0) SIMIX_process_on_exit(process, fun, data);
 533     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 534
 535     self->simcall.call = SIMCALL_PROCESS_ON_EXIT;
 536     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 537     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 538     self->simcall.args[0].dp = (void*) process;
 539     self->simcall.args[1].fp = (FPtr) fun;
 540     self->simcall.args[2].dp = (void*) data;
 541     if (self != simix_global->maestro_process) {
 542       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 543                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 544       SIMIX_process_yield(self);
 545     } else {
 546       SIMIX_simcall_handle(&self->simcall, 0);
 547     }
 548
 549   }
 550
 551 inline static void simcall_BODY_process_auto_restart_set(smx_process_t process, int auto_restart) {
 552     smx_process_t self = SIMIX_process_self();
 553
 554     /* Go to that function to follow the code flow through the simcall barrier */
 555     if (0) SIMIX_process_auto_restart_set(process, auto_restart);
 556     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 557
 558     self->simcall.call = SIMCALL_PROCESS_AUTO_RESTART_SET;
 559     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 560     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 561     self->simcall.args[0].dp = (void*) process;
 562     self->simcall.args[1].i = (int) auto_restart;
 563     if (self != simix_global->maestro_process) {
 564       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 565                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 566       SIMIX_process_yield(self);
 567     } else {
 568       SIMIX_simcall_handle(&self->simcall, 0);
 569     }
 570
 571   }
 572
 573 inline static smx_process_t simcall_BODY_process_restart(smx_process_t process) {
 574     smx_process_t self = SIMIX_process_self();
 575
 576     /* Go to that function to follow the code flow through the simcall barrier */
 577     if (0) simcall_HANDLER_process_restart(&self->simcall, process);
 578     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 579
 580     self->simcall.call = SIMCALL_PROCESS_RESTART;
 581     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 582     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 583     self->simcall.args[0].dp = (void*) process;
 584     if (self != simix_global->maestro_process) {
 585       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 586                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 587       SIMIX_process_yield(self);
 588     } else {
 589       SIMIX_simcall_handle(&self->simcall, 0);
 590     }
 591     return (smx_process_t) self->simcall.result.dp;
 592   }
 593
 594 inline static smx_mailbox_t simcall_BODY_mbox_create(const char* name) {
 595     smx_process_t self = SIMIX_process_self();
 596
 597     /* Go to that function to follow the code flow through the simcall barrier */
 598     if (0) SIMIX_mbox_create(name);
 599     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 600
 601     self->simcall.call = SIMCALL_MBOX_CREATE;
 602     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 603     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 604     self->simcall.args[0].cc = (const char*) name;
 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     return (smx_mailbox_t) self->simcall.result.dp;
 613   }
 614
 615 inline static smx_synchro_t simcall_BODY_mbox_get_head(smx_mailbox_t mbox) {
 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) SIMIX_mbox_get_head(mbox);
 620     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 621
 622     self->simcall.call = SIMCALL_MBOX_GET_HEAD;
 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*) mbox;
 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_synchro_t) self->simcall.result.dp;
 634   }
 635
 636 inline static void simcall_BODY_mbox_set_receiver(smx_mailbox_t mbox, smx_process_t receiver) {
 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_set_receiver(mbox, receiver);
 641     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 642
 643     self->simcall.call = SIMCALL_MBOX_SET_RECEIVER;
 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].dp = (void*) mbox;
 647     self->simcall.args[1].dp = (void*) receiver;
 648     if (self != simix_global->maestro_process) {
 649       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 650                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 651       SIMIX_process_yield(self);
 652     } else {
 653       SIMIX_simcall_handle(&self->simcall, 0);
 654     }
 655
 656   }
 657
 658 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) {
 659     smx_process_t self = SIMIX_process_self();
 660
 661     /* Go to that function to follow the code flow through the simcall barrier */
 662     if (0) simcall_HANDLER_comm_iprobe(&self->simcall, mbox, type, src, tag, match_fun, data);
 663     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 664
 665     self->simcall.call = SIMCALL_COMM_IPROBE;
 666     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 667     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 668     self->simcall.args[0].dp = (void*) mbox;
 669     self->simcall.args[1].i = (int) type;
 670     self->simcall.args[2].i = (int) src;
 671     self->simcall.args[3].i = (int) tag;
 672     self->simcall.args[4].fp = (FPtr) match_fun;
 673     self->simcall.args[5].dp = (void*) data;
 674     if (self != simix_global->maestro_process) {
 675       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 676                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 677       SIMIX_process_yield(self);
 678     } else {
 679       SIMIX_simcall_handle(&self->simcall, 0);
 680     }
 681     return (smx_synchro_t) self->simcall.result.dp;
 682   }
 683
 684 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) {
 685     smx_process_t self = SIMIX_process_self();
 686
 687     /* Go to that function to follow the code flow through the simcall barrier */
 688     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);
 689     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 690
 691     self->simcall.call = SIMCALL_COMM_SEND;
 692     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 693     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 694     self->simcall.args[0].dp = (void*) sender;
 695     self->simcall.args[1].dp = (void*) mbox;
 696     self->simcall.args[2].d = (double) task_size;
 697     self->simcall.args[3].d = (double) rate;
 698     self->simcall.args[4].dp = (void*) src_buff;
 699     self->simcall.args[5].sz = (size_t) src_buff_size;
 700     self->simcall.args[6].fp = (FPtr) match_fun;
 701     self->simcall.args[7].fp = (FPtr) copy_data_fun;
 702     self->simcall.args[8].dp = (void*) data;
 703     self->simcall.args[9].d = (double) timeout;
 704     if (self != simix_global->maestro_process) {
 705       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 706                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 707       SIMIX_process_yield(self);
 708     } else {
 709       SIMIX_simcall_handle(&self->simcall, 0);
 710     }
 711
 712   }
 713
 714 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) {
 715     smx_process_t self = SIMIX_process_self();
 716
 717     /* Go to that function to follow the code flow through the simcall barrier */
 718     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);
 719     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 720
 721     self->simcall.call = SIMCALL_COMM_ISEND;
 722     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 723     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 724     self->simcall.args[0].dp = (void*) sender;
 725     self->simcall.args[1].dp = (void*) mbox;
 726     self->simcall.args[2].d = (double) task_size;
 727     self->simcall.args[3].d = (double) rate;
 728     self->simcall.args[4].dp = (void*) src_buff;
 729     self->simcall.args[5].sz = (size_t) src_buff_size;
 730     self->simcall.args[6].fp = (FPtr) match_fun;
 731     self->simcall.args[7].fp = (FPtr) clean_fun;
 732     self->simcall.args[8].fp = (FPtr) copy_data_fun;
 733     self->simcall.args[9].dp = (void*) data;
 734     self->simcall.args[10].i = (int) detached;
 735     if (self != simix_global->maestro_process) {
 736       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 737                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 738       SIMIX_process_yield(self);
 739     } else {
 740       SIMIX_simcall_handle(&self->simcall, 0);
 741     }
 742     return (smx_synchro_t) self->simcall.result.dp;
 743   }
 744
 745 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) {
 746     smx_process_t self = SIMIX_process_self();
 747
 748     /* Go to that function to follow the code flow through the simcall barrier */
 749     if (0) simcall_HANDLER_comm_recv(&self->simcall, receiver, mbox, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, timeout, rate);
 750     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 751
 752     self->simcall.call = SIMCALL_COMM_RECV;
 753     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 754     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 755     self->simcall.args[0].dp = (void*) receiver;
 756     self->simcall.args[1].dp = (void*) mbox;
 757     self->simcall.args[2].dp = (void*) dst_buff;
 758     self->simcall.args[3].dp = (void*) dst_buff_size;
 759     self->simcall.args[4].fp = (FPtr) match_fun;
 760     self->simcall.args[5].fp = (FPtr) copy_data_fun;
 761     self->simcall.args[6].dp = (void*) data;
 762     self->simcall.args[7].d = (double) timeout;
 763     self->simcall.args[8].d = (double) rate;
 764     if (self != simix_global->maestro_process) {
 765       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 766                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 767       SIMIX_process_yield(self);
 768     } else {
 769       SIMIX_simcall_handle(&self->simcall, 0);
 770     }
 771
 772   }
 773
 774 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) {
 775     smx_process_t self = SIMIX_process_self();
 776
 777     /* Go to that function to follow the code flow through the simcall barrier */
 778     if (0) simcall_HANDLER_comm_irecv(&self->simcall, receiver, mbox, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, rate);
 779     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 780
 781     self->simcall.call = SIMCALL_COMM_IRECV;
 782     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 783     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 784     self->simcall.args[0].dp = (void*) receiver;
 785     self->simcall.args[1].dp = (void*) mbox;
 786     self->simcall.args[2].dp = (void*) dst_buff;
 787     self->simcall.args[3].dp = (void*) dst_buff_size;
 788     self->simcall.args[4].fp = (FPtr) match_fun;
 789     self->simcall.args[5].fp = (FPtr) copy_data_fun;
 790     self->simcall.args[6].dp = (void*) data;
 791     self->simcall.args[7].d = (double) rate;
 792     if (self != simix_global->maestro_process) {
 793       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 794                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 795       SIMIX_process_yield(self);
 796     } else {
 797       SIMIX_simcall_handle(&self->simcall, 0);
 798     }
 799     return (smx_synchro_t) self->simcall.result.dp;
 800   }
 801
 802 inline static int simcall_BODY_comm_waitany(xbt_dynar_t comms) {
 803     smx_process_t self = SIMIX_process_self();
 804
 805     /* Go to that function to follow the code flow through the simcall barrier */
 806     if (0) simcall_HANDLER_comm_waitany(&self->simcall, comms);
 807     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 808
 809     self->simcall.call = SIMCALL_COMM_WAITANY;
 810     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 811     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 812     self->simcall.args[0].dp = (void*) comms;
 813     if (self != simix_global->maestro_process) {
 814       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 815                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 816       SIMIX_process_yield(self);
 817     } else {
 818       SIMIX_simcall_handle(&self->simcall, 0);
 819     }
 820     return (int) self->simcall.result.i;
 821   }
 822
 823 inline static void simcall_BODY_comm_wait(smx_synchro_t comm, double timeout) {
 824     smx_process_t self = SIMIX_process_self();
 825
 826     /* Go to that function to follow the code flow through the simcall barrier */
 827     if (0) simcall_HANDLER_comm_wait(&self->simcall, comm, timeout);
 828     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 829
 830     self->simcall.call = SIMCALL_COMM_WAIT;
 831     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 832     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 833     self->simcall.args[0].dp = (void*) comm;
 834     self->simcall.args[1].d = (double) timeout;
 835     if (self != simix_global->maestro_process) {
 836       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 837                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 838       SIMIX_process_yield(self);
 839     } else {
 840       SIMIX_simcall_handle(&self->simcall, 0);
 841     }
 842
 843   }
 844
 845 inline static int simcall_BODY_comm_test(smx_synchro_t comm) {
 846     smx_process_t self = SIMIX_process_self();
 847
 848     /* Go to that function to follow the code flow through the simcall barrier */
 849     if (0) simcall_HANDLER_comm_test(&self->simcall, comm);
 850     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 851
 852     self->simcall.call = SIMCALL_COMM_TEST;
 853     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 854     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 855     self->simcall.args[0].dp = (void*) comm;
 856     if (self != simix_global->maestro_process) {
 857       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 858                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 859       SIMIX_process_yield(self);
 860     } else {
 861       SIMIX_simcall_handle(&self->simcall, 0);
 862     }
 863     return (int) self->simcall.result.i;
 864   }
 865
 866 inline static int simcall_BODY_comm_testany(xbt_dynar_t comms) {
 867     smx_process_t self = SIMIX_process_self();
 868
 869     /* Go to that function to follow the code flow through the simcall barrier */
 870     if (0) simcall_HANDLER_comm_testany(&self->simcall, comms);
 871     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 872
 873     self->simcall.call = SIMCALL_COMM_TESTANY;
 874     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 875     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 876     self->simcall.args[0].dp = (void*) comms;
 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 (int) self->simcall.result.i;
 885   }
 886
 887 inline static void* simcall_BODY_comm_get_src_data(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_get_src_data(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_GET_SRC_DATA;
 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     return (void*) self->simcall.result.dp;
 906   }
 907
 908 inline static void* simcall_BODY_comm_get_dst_data(smx_synchro_t comm) {
 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) SIMIX_comm_get_dst_data(comm);
 913     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 914
 915     self->simcall.call = SIMCALL_COMM_GET_DST_DATA;
 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*) comm;
 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 (void*) self->simcall.result.dp;
 927   }
 928
 929 inline static smx_process_t simcall_BODY_comm_get_src_proc(smx_synchro_t comm) {
 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) SIMIX_comm_get_src_proc(comm);
 934     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 935
 936     self->simcall.call = SIMCALL_COMM_GET_SRC_PROC;
 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     if (self != simix_global->maestro_process) {
 941       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 942                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 943       SIMIX_process_yield(self);
 944     } else {
 945       SIMIX_simcall_handle(&self->simcall, 0);
 946     }
 947     return (smx_process_t) self->simcall.result.dp;
 948   }
 949
 950 inline static smx_process_t simcall_BODY_comm_get_dst_proc(smx_synchro_t comm) {
 951     smx_process_t self = SIMIX_process_self();
 952
 953     /* Go to that function to follow the code flow through the simcall barrier */
 954     if (0) SIMIX_comm_get_dst_proc(comm);
 955     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 956
 957     self->simcall.call = SIMCALL_COMM_GET_DST_PROC;
 958     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 959     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 960     self->simcall.args[0].dp = (void*) comm;
 961     if (self != simix_global->maestro_process) {
 962       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 963                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 964       SIMIX_process_yield(self);
 965     } else {
 966       SIMIX_simcall_handle(&self->simcall, 0);
 967     }
 968     return (smx_process_t) self->simcall.result.dp;
 969   }
 970
 971 inline static smx_mutex_t simcall_BODY_mutex_init() {
 972     smx_process_t self = SIMIX_process_self();
 973
 974     /* Go to that function to follow the code flow through the simcall barrier */
 975     if (0) simcall_HANDLER_mutex_init(&self->simcall);
 976     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 977
 978     self->simcall.call = SIMCALL_MUTEX_INIT;
 979     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 980     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 981
 982     if (self != simix_global->maestro_process) {
 983       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 984                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 985       SIMIX_process_yield(self);
 986     } else {
 987       SIMIX_simcall_handle(&self->simcall, 0);
 988     }
 989     return (smx_mutex_t) self->simcall.result.dp;
 990   }
 991
 992 inline static void simcall_BODY_mutex_lock(smx_mutex_t mutex) {
 993     smx_process_t self = SIMIX_process_self();
 994
 995     /* Go to that function to follow the code flow through the simcall barrier */
 996     if (0) simcall_HANDLER_mutex_lock(&self->simcall, mutex);
 997     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 998
 999     self->simcall.call = SIMCALL_MUTEX_LOCK;
1000     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1001     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1002     self->simcall.args[0].dp = (void*) mutex;
1003     if (self != simix_global->maestro_process) {
1004       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1005                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1006       SIMIX_process_yield(self);
1007     } else {
1008       SIMIX_simcall_handle(&self->simcall, 0);
1009     }
1010
1011   }
1012
1013 inline static int simcall_BODY_mutex_trylock(smx_mutex_t mutex) {
1014     smx_process_t self = SIMIX_process_self();
1015
1016     /* Go to that function to follow the code flow through the simcall barrier */
1017     if (0) simcall_HANDLER_mutex_trylock(&self->simcall, mutex);
1018     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1019
1020     self->simcall.call = SIMCALL_MUTEX_TRYLOCK;
1021     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1022     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1023     self->simcall.args[0].dp = (void*) mutex;
1024     if (self != simix_global->maestro_process) {
1025       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1026                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1027       SIMIX_process_yield(self);
1028     } else {
1029       SIMIX_simcall_handle(&self->simcall, 0);
1030     }
1031     return (int) self->simcall.result.i;
1032   }
1033
1034 inline static void simcall_BODY_mutex_unlock(smx_mutex_t mutex) {
1035     smx_process_t self = SIMIX_process_self();
1036
1037     /* Go to that function to follow the code flow through the simcall barrier */
1038     if (0) simcall_HANDLER_mutex_unlock(&self->simcall, mutex);
1039     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1040
1041     self->simcall.call = SIMCALL_MUTEX_UNLOCK;
1042     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1043     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1044     self->simcall.args[0].dp = (void*) mutex;
1045     if (self != simix_global->maestro_process) {
1046       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1047                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1048       SIMIX_process_yield(self);
1049     } else {
1050       SIMIX_simcall_handle(&self->simcall, 0);
1051     }
1052
1053   }
1054
1055 inline static smx_cond_t simcall_BODY_cond_init() {
1056     smx_process_t self = SIMIX_process_self();
1057
1058     /* Go to that function to follow the code flow through the simcall barrier */
1059     if (0) SIMIX_cond_init();
1060     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1061
1062     self->simcall.call = SIMCALL_COND_INIT;
1063     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1064     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1065
1066     if (self != simix_global->maestro_process) {
1067       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1068                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1069       SIMIX_process_yield(self);
1070     } else {
1071       SIMIX_simcall_handle(&self->simcall, 0);
1072     }
1073     return (smx_cond_t) self->simcall.result.dp;
1074   }
1075
1076 inline static void simcall_BODY_cond_signal(smx_cond_t cond) {
1077     smx_process_t self = SIMIX_process_self();
1078
1079     /* Go to that function to follow the code flow through the simcall barrier */
1080     if (0) SIMIX_cond_signal(cond);
1081     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1082
1083     self->simcall.call = SIMCALL_COND_SIGNAL;
1084     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1085     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1086     self->simcall.args[0].dp = (void*) cond;
1087     if (self != simix_global->maestro_process) {
1088       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1089                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1090       SIMIX_process_yield(self);
1091     } else {
1092       SIMIX_simcall_handle(&self->simcall, 0);
1093     }
1094
1095   }
1096
1097 inline static void simcall_BODY_cond_wait(smx_cond_t cond, smx_mutex_t mutex) {
1098     smx_process_t self = SIMIX_process_self();
1099
1100     /* Go to that function to follow the code flow through the simcall barrier */
1101     if (0) simcall_HANDLER_cond_wait(&self->simcall, cond, mutex);
1102     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1103
1104     self->simcall.call = SIMCALL_COND_WAIT;
1105     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1106     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1107     self->simcall.args[0].dp = (void*) cond;
1108     self->simcall.args[1].dp = (void*) mutex;
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
1117   }
1118
1119 inline static void simcall_BODY_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double timeout) {
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_cond_wait_timeout(&self->simcall, cond, mutex, timeout);
1124     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1125
1126     self->simcall.call = SIMCALL_COND_WAIT_TIMEOUT;
1127     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1128     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1129     self->simcall.args[0].dp = (void*) cond;
1130     self->simcall.args[1].dp = (void*) mutex;
1131     self->simcall.args[2].d = (double) timeout;
1132     if (self != simix_global->maestro_process) {
1133       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1134                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1135       SIMIX_process_yield(self);
1136     } else {
1137       SIMIX_simcall_handle(&self->simcall, 0);
1138     }
1139
1140   }
1141
1142 inline static void simcall_BODY_cond_broadcast(smx_cond_t cond) {
1143     smx_process_t self = SIMIX_process_self();
1144
1145     /* Go to that function to follow the code flow through the simcall barrier */
1146     if (0) SIMIX_cond_broadcast(cond);
1147     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1148
1149     self->simcall.call = SIMCALL_COND_BROADCAST;
1150     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1151     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1152     self->simcall.args[0].dp = (void*) cond;
1153     if (self != simix_global->maestro_process) {
1154       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1155                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1156       SIMIX_process_yield(self);
1157     } else {
1158       SIMIX_simcall_handle(&self->simcall, 0);
1159     }
1160
1161   }
1162
1163 inline static smx_sem_t simcall_BODY_sem_init(unsigned int capacity) {
1164     smx_process_t self = SIMIX_process_self();
1165
1166     /* Go to that function to follow the code flow through the simcall barrier */
1167     if (0) SIMIX_sem_init(capacity);
1168     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1169
1170     self->simcall.call = SIMCALL_SEM_INIT;
1171     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1172     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1173     self->simcall.args[0].ui = (unsigned int) capacity;
1174     if (self != simix_global->maestro_process) {
1175       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1176                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1177       SIMIX_process_yield(self);
1178     } else {
1179       SIMIX_simcall_handle(&self->simcall, 0);
1180     }
1181     return (smx_sem_t) self->simcall.result.dp;
1182   }
1183
1184 inline static void simcall_BODY_sem_release(smx_sem_t sem) {
1185     smx_process_t self = SIMIX_process_self();
1186
1187     /* Go to that function to follow the code flow through the simcall barrier */
1188     if (0) simcall_HANDLER_sem_release(&self->simcall, sem);
1189     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1190
1191     self->simcall.call = SIMCALL_SEM_RELEASE;
1192     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1193     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1194     self->simcall.args[0].dp = (void*) sem;
1195     if (self != simix_global->maestro_process) {
1196       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1197                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1198       SIMIX_process_yield(self);
1199     } else {
1200       SIMIX_simcall_handle(&self->simcall, 0);
1201     }
1202
1203   }
1204
1205 inline static int simcall_BODY_sem_would_block(smx_sem_t sem) {
1206     smx_process_t self = SIMIX_process_self();
1207
1208     /* Go to that function to follow the code flow through the simcall barrier */
1209     if (0) simcall_HANDLER_sem_would_block(&self->simcall, sem);
1210     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1211
1212     self->simcall.call = SIMCALL_SEM_WOULD_BLOCK;
1213     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1214     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1215     self->simcall.args[0].dp = (void*) sem;
1216     if (self != simix_global->maestro_process) {
1217       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1218                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1219       SIMIX_process_yield(self);
1220     } else {
1221       SIMIX_simcall_handle(&self->simcall, 0);
1222     }
1223     return (int) self->simcall.result.i;
1224   }
1225
1226 inline static void simcall_BODY_sem_acquire(smx_sem_t sem) {
1227     smx_process_t self = SIMIX_process_self();
1228
1229     /* Go to that function to follow the code flow through the simcall barrier */
1230     if (0) simcall_HANDLER_sem_acquire(&self->simcall, sem);
1231     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1232
1233     self->simcall.call = SIMCALL_SEM_ACQUIRE;
1234     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1235     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1236     self->simcall.args[0].dp = (void*) sem;
1237     if (self != simix_global->maestro_process) {
1238       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1239                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1240       SIMIX_process_yield(self);
1241     } else {
1242       SIMIX_simcall_handle(&self->simcall, 0);
1243     }
1244
1245   }
1246
1247 inline static void simcall_BODY_sem_acquire_timeout(smx_sem_t sem, double timeout) {
1248     smx_process_t self = SIMIX_process_self();
1249
1250     /* Go to that function to follow the code flow through the simcall barrier */
1251     if (0) simcall_HANDLER_sem_acquire_timeout(&self->simcall, sem, timeout);
1252     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1253
1254     self->simcall.call = SIMCALL_SEM_ACQUIRE_TIMEOUT;
1255     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1256     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1257     self->simcall.args[0].dp = (void*) sem;
1258     self->simcall.args[1].d = (double) timeout;
1259     if (self != simix_global->maestro_process) {
1260       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1261                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1262       SIMIX_process_yield(self);
1263     } else {
1264       SIMIX_simcall_handle(&self->simcall, 0);
1265     }
1266
1267   }
1268
1269 inline static int simcall_BODY_sem_get_capacity(smx_sem_t sem) {
1270     smx_process_t self = SIMIX_process_self();
1271
1272     /* Go to that function to follow the code flow through the simcall barrier */
1273     if (0) simcall_HANDLER_sem_get_capacity(&self->simcall, sem);
1274     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1275
1276     self->simcall.call = SIMCALL_SEM_GET_CAPACITY;
1277     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1278     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1279     self->simcall.args[0].dp = (void*) sem;
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     return (int) self->simcall.result.i;
1288   }
1289
1290 inline static sg_size_t simcall_BODY_file_read(smx_file_t fd, sg_size_t size, sg_host_t host) {
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) simcall_HANDLER_file_read(&self->simcall, fd, size, host);
1295     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1296
1297     self->simcall.call = SIMCALL_FILE_READ;
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*) fd;
1301     self->simcall.args[1].sgsz = (sg_size_t) size;
1302     self->simcall.args[2].dp = (void*) host;
1303     if (self != simix_global->maestro_process) {
1304       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1305                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1306       SIMIX_process_yield(self);
1307     } else {
1308       SIMIX_simcall_handle(&self->simcall, 0);
1309     }
1310     return (sg_size_t) self->simcall.result.sgsz;
1311   }
1312
1313 inline static sg_size_t simcall_BODY_file_write(smx_file_t fd, sg_size_t size, sg_host_t host) {
1314     smx_process_t self = SIMIX_process_self();
1315
1316     /* Go to that function to follow the code flow through the simcall barrier */
1317     if (0) simcall_HANDLER_file_write(&self->simcall, fd, size, host);
1318     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1319
1320     self->simcall.call = SIMCALL_FILE_WRITE;
1321     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1322     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1323     self->simcall.args[0].dp = (void*) fd;
1324     self->simcall.args[1].sgsz = (sg_size_t) size;
1325     self->simcall.args[2].dp = (void*) host;
1326     if (self != simix_global->maestro_process) {
1327       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1328                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1329       SIMIX_process_yield(self);
1330     } else {
1331       SIMIX_simcall_handle(&self->simcall, 0);
1332     }
1333     return (sg_size_t) self->simcall.result.sgsz;
1334   }
1335
1336 inline static smx_file_t simcall_BODY_file_open(const char* fullpath, sg_host_t host) {
1337     smx_process_t self = SIMIX_process_self();
1338
1339     /* Go to that function to follow the code flow through the simcall barrier */
1340     if (0) simcall_HANDLER_file_open(&self->simcall, fullpath, host);
1341     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1342
1343     self->simcall.call = SIMCALL_FILE_OPEN;
1344     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1345     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1346     self->simcall.args[0].cc = (const char*) fullpath;
1347     self->simcall.args[1].dp = (void*) host;
1348     if (self != simix_global->maestro_process) {
1349       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1350                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1351       SIMIX_process_yield(self);
1352     } else {
1353       SIMIX_simcall_handle(&self->simcall, 0);
1354     }
1355     return (smx_file_t) self->simcall.result.dp;
1356   }
1357
1358 inline static int simcall_BODY_file_close(smx_file_t fd, sg_host_t host) {
1359     smx_process_t self = SIMIX_process_self();
1360
1361     /* Go to that function to follow the code flow through the simcall barrier */
1362     if (0) simcall_HANDLER_file_close(&self->simcall, fd, host);
1363     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1364
1365     self->simcall.call = SIMCALL_FILE_CLOSE;
1366     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1367     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1368     self->simcall.args[0].dp = (void*) fd;
1369     self->simcall.args[1].dp = (void*) host;
1370     if (self != simix_global->maestro_process) {
1371       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1372                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1373       SIMIX_process_yield(self);
1374     } else {
1375       SIMIX_simcall_handle(&self->simcall, 0);
1376     }
1377     return (int) self->simcall.result.i;
1378   }
1379
1380 inline static int simcall_BODY_file_unlink(smx_file_t fd, sg_host_t host) {
1381     smx_process_t self = SIMIX_process_self();
1382
1383     /* Go to that function to follow the code flow through the simcall barrier */
1384     if (0) SIMIX_file_unlink(fd, host);
1385     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1386
1387     self->simcall.call = SIMCALL_FILE_UNLINK;
1388     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1389     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1390     self->simcall.args[0].dp = (void*) fd;
1391     self->simcall.args[1].dp = (void*) host;
1392     if (self != simix_global->maestro_process) {
1393       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1394                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1395       SIMIX_process_yield(self);
1396     } else {
1397       SIMIX_simcall_handle(&self->simcall, 0);
1398     }
1399     return (int) self->simcall.result.i;
1400   }
1401
1402 inline static sg_size_t simcall_BODY_file_get_size(smx_file_t fd) {
1403     smx_process_t self = SIMIX_process_self();
1404
1405     /* Go to that function to follow the code flow through the simcall barrier */
1406     if (0) simcall_HANDLER_file_get_size(&self->simcall, fd);
1407     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1408
1409     self->simcall.call = SIMCALL_FILE_GET_SIZE;
1410     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1411     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1412     self->simcall.args[0].dp = (void*) fd;
1413     if (self != simix_global->maestro_process) {
1414       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1415                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1416       SIMIX_process_yield(self);
1417     } else {
1418       SIMIX_simcall_handle(&self->simcall, 0);
1419     }
1420     return (sg_size_t) self->simcall.result.sgsz;
1421   }
1422
1423 inline static sg_size_t simcall_BODY_file_tell(smx_file_t fd) {
1424     smx_process_t self = SIMIX_process_self();
1425
1426     /* Go to that function to follow the code flow through the simcall barrier */
1427     if (0) simcall_HANDLER_file_tell(&self->simcall, fd);
1428     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1429
1430     self->simcall.call = SIMCALL_FILE_TELL;
1431     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1432     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1433     self->simcall.args[0].dp = (void*) fd;
1434     if (self != simix_global->maestro_process) {
1435       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1436                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1437       SIMIX_process_yield(self);
1438     } else {
1439       SIMIX_simcall_handle(&self->simcall, 0);
1440     }
1441     return (sg_size_t) self->simcall.result.sgsz;
1442   }
1443
1444 inline static int simcall_BODY_file_seek(smx_file_t fd, sg_offset_t offset, int origin) {
1445     smx_process_t self = SIMIX_process_self();
1446
1447     /* Go to that function to follow the code flow through the simcall barrier */
1448     if (0) simcall_HANDLER_file_seek(&self->simcall, fd, offset, origin);
1449     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1450
1451     self->simcall.call = SIMCALL_FILE_SEEK;
1452     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1453     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1454     self->simcall.args[0].dp = (void*) fd;
1455     self->simcall.args[1].sgoff = (sg_offset_t) offset;
1456     self->simcall.args[2].i = (int) origin;
1457     if (self != simix_global->maestro_process) {
1458       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1459                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1460       SIMIX_process_yield(self);
1461     } else {
1462       SIMIX_simcall_handle(&self->simcall, 0);
1463     }
1464     return (int) self->simcall.result.i;
1465   }
1466
1467 inline static xbt_dynar_t simcall_BODY_file_get_info(smx_file_t fd) {
1468     smx_process_t self = SIMIX_process_self();
1469
1470     /* Go to that function to follow the code flow through the simcall barrier */
1471     if (0) simcall_HANDLER_file_get_info(&self->simcall, fd);
1472     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1473
1474     self->simcall.call = SIMCALL_FILE_GET_INFO;
1475     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1476     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1477     self->simcall.args[0].dp = (void*) fd;
1478     if (self != simix_global->maestro_process) {
1479       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1480                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1481       SIMIX_process_yield(self);
1482     } else {
1483       SIMIX_simcall_handle(&self->simcall, 0);
1484     }
1485     return (xbt_dynar_t) self->simcall.result.dp;
1486   }
1487
1488 inline static int simcall_BODY_file_move(smx_file_t fd, const char* fullpath) {
1489     smx_process_t self = SIMIX_process_self();
1490
1491     /* Go to that function to follow the code flow through the simcall barrier */
1492     if (0) simcall_HANDLER_file_move(&self->simcall, fd, fullpath);
1493     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1494
1495     self->simcall.call = SIMCALL_FILE_MOVE;
1496     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1497     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1498     self->simcall.args[0].dp = (void*) fd;
1499     self->simcall.args[1].cc = (const char*) fullpath;
1500     if (self != simix_global->maestro_process) {
1501       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1502                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1503       SIMIX_process_yield(self);
1504     } else {
1505       SIMIX_simcall_handle(&self->simcall, 0);
1506     }
1507     return (int) self->simcall.result.i;
1508   }
1509
1510 inline static sg_size_t simcall_BODY_storage_get_free_size(smx_storage_t storage) {
1511     smx_process_t self = SIMIX_process_self();
1512
1513     /* Go to that function to follow the code flow through the simcall barrier */
1514     if (0) simcall_HANDLER_storage_get_free_size(&self->simcall, storage);
1515     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1516
1517     self->simcall.call = SIMCALL_STORAGE_GET_FREE_SIZE;
1518     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1519     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1520     self->simcall.args[0].dp = (void*) storage;
1521     if (self != simix_global->maestro_process) {
1522       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1523                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1524       SIMIX_process_yield(self);
1525     } else {
1526       SIMIX_simcall_handle(&self->simcall, 0);
1527     }
1528     return (sg_size_t) self->simcall.result.sgsz;
1529   }
1530
1531 inline static sg_size_t simcall_BODY_storage_get_used_size(smx_storage_t name) {
1532     smx_process_t self = SIMIX_process_self();
1533
1534     /* Go to that function to follow the code flow through the simcall barrier */
1535     if (0) simcall_HANDLER_storage_get_used_size(&self->simcall, name);
1536     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1537
1538     self->simcall.call = SIMCALL_STORAGE_GET_USED_SIZE;
1539     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1540     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1541     self->simcall.args[0].dp = (void*) name;
1542     if (self != simix_global->maestro_process) {
1543       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1544                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1545       SIMIX_process_yield(self);
1546     } else {
1547       SIMIX_simcall_handle(&self->simcall, 0);
1548     }
1549     return (sg_size_t) self->simcall.result.sgsz;
1550   }
1551
1552 inline static xbt_dict_t simcall_BODY_storage_get_properties(smx_storage_t storage) {
1553     smx_process_t self = SIMIX_process_self();
1554
1555     /* Go to that function to follow the code flow through the simcall barrier */
1556     if (0) SIMIX_storage_get_properties(storage);
1557     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1558
1559     self->simcall.call = SIMCALL_STORAGE_GET_PROPERTIES;
1560     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1561     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1562     self->simcall.args[0].dp = (void*) storage;
1563     if (self != simix_global->maestro_process) {
1564       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1565                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1566       SIMIX_process_yield(self);
1567     } else {
1568       SIMIX_simcall_handle(&self->simcall, 0);
1569     }
1570     return (xbt_dict_t) self->simcall.result.dp;
1571   }
1572
1573 inline static xbt_dict_t simcall_BODY_storage_get_content(smx_storage_t storage) {
1574     smx_process_t self = SIMIX_process_self();
1575
1576     /* Go to that function to follow the code flow through the simcall barrier */
1577     if (0) SIMIX_storage_get_content(storage);
1578     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1579
1580     self->simcall.call = SIMCALL_STORAGE_GET_CONTENT;
1581     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1582     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1583     self->simcall.args[0].dp = (void*) storage;
1584     if (self != simix_global->maestro_process) {
1585       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1586                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1587       SIMIX_process_yield(self);
1588     } else {
1589       SIMIX_simcall_handle(&self->simcall, 0);
1590     }
1591     return (xbt_dict_t) self->simcall.result.dp;
1592   }
1593
1594 inline static xbt_dict_t simcall_BODY_asr_get_properties(const char* name) {
1595     smx_process_t self = SIMIX_process_self();
1596
1597     /* Go to that function to follow the code flow through the simcall barrier */
1598     if (0) simcall_HANDLER_asr_get_properties(&self->simcall, name);
1599     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1600
1601     self->simcall.call = SIMCALL_ASR_GET_PROPERTIES;
1602     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1603     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1604     self->simcall.args[0].cc = (const char*) name;
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 (xbt_dict_t) self->simcall.result.dp;
1613   }
1614
1615 inline static int simcall_BODY_mc_random(int min, int max) {
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_mc_random(&self->simcall, min, max);
1620     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1621
1622     self->simcall.call = SIMCALL_MC_RANDOM;
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].i = (int) min;
1626     self->simcall.args[1].i = (int) max;
1627     if (self != simix_global->maestro_process) {
1628       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1629                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1630       SIMIX_process_yield(self);
1631     } else {
1632       SIMIX_simcall_handle(&self->simcall, 0);
1633     }
1634     return (int) self->simcall.result.i;
1635   }
1636
1637 inline static void simcall_BODY_set_category(smx_synchro_t synchro, const char* category) {
1638     smx_process_t self = SIMIX_process_self();
1639
1640     /* Go to that function to follow the code flow through the simcall barrier */
1641     if (0) SIMIX_set_category(synchro, category);
1642     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1643
1644     self->simcall.call = SIMCALL_SET_CATEGORY;
1645     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1646     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1647     self->simcall.args[0].dp = (void*) synchro;
1648     self->simcall.args[1].cc = (const char*) category;
1649     if (self != simix_global->maestro_process) {
1650       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1651                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1652       SIMIX_process_yield(self);
1653     } else {
1654       SIMIX_simcall_handle(&self->simcall, 0);
1655     }
1656
1657   }
1658
1659 inline static void simcall_BODY_run_kernel(void* code) {
1660     smx_process_t self = SIMIX_process_self();
1661
1662     /* Go to that function to follow the code flow through the simcall barrier */
1663     if (0) SIMIX_run_kernel(code);
1664     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1665
1666     self->simcall.call = SIMCALL_RUN_KERNEL;
1667     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1668     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1669     self->simcall.args[0].dp = (void*) code;
1670     if (self != simix_global->maestro_process) {
1671       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1672                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1673       SIMIX_process_yield(self);
1674     } else {
1675       SIMIX_simcall_handle(&self->simcall, 0);
1676     }
1677
1678   }