src/simix/popping_bodies.c

   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 "mc/mc_interface.h"
  18 #include "xbt/ex.h"
  19
  20 inline static smx_host_t simcall_BODY_host_get_by_name(const char* name) {
  21     smx_process_t self = SIMIX_process_self();
  22
  23     /* Go to that function to follow the code flow through the simcall barrier */
  24     if (0) SIMIX_host_get_by_name(name);
  25     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
  26
  27     self->simcall.call = SIMCALL_HOST_GET_BY_NAME;
  28     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
  29     memset(self->simcall.args, 0, sizeof(self->simcall.args));
  30     self->simcall.args[0].cc = (const char*) name;
  31     if (self != simix_global->maestro_process) {
  32       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
  33                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
  34       SIMIX_process_yield(self);
  35     } else {
  36       SIMIX_simcall_handle(&self->simcall, 0);
  37     }
  38     return self->simcall.result.dp;
  39   }
  40
  41 inline static const char* simcall_BODY_host_get_name(smx_host_t host) {
  42     smx_process_t self = SIMIX_process_self();
  43
  44     /* Go to that function to follow the code flow through the simcall barrier */
  45     if (0) SIMIX_host_get_name(host);
  46     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
  47
  48     self->simcall.call = SIMCALL_HOST_GET_NAME;
  49     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
  50     memset(self->simcall.args, 0, sizeof(self->simcall.args));
  51     self->simcall.args[0].dp = (void*) host;
  52     if (self != simix_global->maestro_process) {
  53       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
  54                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
  55       SIMIX_process_yield(self);
  56     } else {
  57       SIMIX_simcall_handle(&self->simcall, 0);
  58     }
  59     return self->simcall.result.cc;
  60   }
  61
  62 inline static void simcall_BODY_host_on(smx_host_t host) {
  63     smx_process_t self = SIMIX_process_self();
  64
  65     /* Go to that function to follow the code flow through the simcall barrier */
  66     if (0) SIMIX_host_on(host);
  67     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
  68
  69     self->simcall.call = SIMCALL_HOST_ON;
  70     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
  71     memset(self->simcall.args, 0, sizeof(self->simcall.args));
  72     self->simcall.args[0].dp = (void*) host;
  73     if (self != simix_global->maestro_process) {
  74       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
  75                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
  76       SIMIX_process_yield(self);
  77     } else {
  78       SIMIX_simcall_handle(&self->simcall, 0);
  79     }
  80
  81   }
  82
  83 inline static void simcall_BODY_host_off(smx_host_t host) {
  84     smx_process_t self = SIMIX_process_self();
  85
  86     /* Go to that function to follow the code flow through the simcall barrier */
  87     if (0) simcall_HANDLER_host_off(&self->simcall, host);
  88     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
  89
  90     self->simcall.call = SIMCALL_HOST_OFF;
  91     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
  92     memset(self->simcall.args, 0, sizeof(self->simcall.args));
  93     self->simcall.args[0].dp = (void*) host;
  94     if (self != simix_global->maestro_process) {
  95       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
  96                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
  97       SIMIX_process_yield(self);
  98     } else {
  99       SIMIX_simcall_handle(&self->simcall, 0);
 100     }
 101
 102   }
 103
 104 inline static xbt_dict_t simcall_BODY_host_get_properties(smx_host_t host) {
 105     smx_process_t self = SIMIX_process_self();
 106
 107     /* Go to that function to follow the code flow through the simcall barrier */
 108     if (0) SIMIX_host_get_properties(host);
 109     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 110
 111     self->simcall.call = SIMCALL_HOST_GET_PROPERTIES;
 112     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 113     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 114     self->simcall.args[0].dp = (void*) host;
 115     if (self != simix_global->maestro_process) {
 116       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 117                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 118       SIMIX_process_yield(self);
 119     } else {
 120       SIMIX_simcall_handle(&self->simcall, 0);
 121     }
 122     return self->simcall.result.dp;
 123   }
 124
 125 inline static int simcall_BODY_host_get_core(smx_host_t host) {
 126     smx_process_t self = SIMIX_process_self();
 127
 128     /* Go to that function to follow the code flow through the simcall barrier */
 129     if (0) SIMIX_host_get_core(host);
 130     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 131
 132     self->simcall.call = SIMCALL_HOST_GET_CORE;
 133     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 134     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 135     self->simcall.args[0].dp = (void*) host;
 136     if (self != simix_global->maestro_process) {
 137       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 138                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 139       SIMIX_process_yield(self);
 140     } else {
 141       SIMIX_simcall_handle(&self->simcall, 0);
 142     }
 143     return self->simcall.result.i;
 144   }
 145
 146 inline static xbt_swag_t simcall_BODY_host_get_process_list(smx_host_t host) {
 147     smx_process_t self = SIMIX_process_self();
 148
 149     /* Go to that function to follow the code flow through the simcall barrier */
 150     if (0) SIMIX_host_get_process_list(host);
 151     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 152
 153     self->simcall.call = SIMCALL_HOST_GET_PROCESS_LIST;
 154     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 155     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 156     self->simcall.args[0].dp = (void*) host;
 157     if (self != simix_global->maestro_process) {
 158       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 159                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 160       SIMIX_process_yield(self);
 161     } else {
 162       SIMIX_simcall_handle(&self->simcall, 0);
 163     }
 164     return self->simcall.result.dp;
 165   }
 166
 167 inline static double simcall_BODY_host_get_speed(smx_host_t host) {
 168     smx_process_t self = SIMIX_process_self();
 169
 170     /* Go to that function to follow the code flow through the simcall barrier */
 171     if (0) SIMIX_host_get_speed(host);
 172     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 173
 174     self->simcall.call = SIMCALL_HOST_GET_SPEED;
 175     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 176     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 177     self->simcall.args[0].dp = (void*) host;
 178     if (self != simix_global->maestro_process) {
 179       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 180                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 181       SIMIX_process_yield(self);
 182     } else {
 183       SIMIX_simcall_handle(&self->simcall, 0);
 184     }
 185     return self->simcall.result.d;
 186   }
 187
 188 inline static double simcall_BODY_host_get_available_speed(smx_host_t host) {
 189     smx_process_t self = SIMIX_process_self();
 190
 191     /* Go to that function to follow the code flow through the simcall barrier */
 192     if (0) SIMIX_host_get_available_speed(host);
 193     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 194
 195     self->simcall.call = SIMCALL_HOST_GET_AVAILABLE_SPEED;
 196     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 197     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 198     self->simcall.args[0].dp = (void*) host;
 199     if (self != simix_global->maestro_process) {
 200       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 201                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 202       SIMIX_process_yield(self);
 203     } else {
 204       SIMIX_simcall_handle(&self->simcall, 0);
 205     }
 206     return self->simcall.result.d;
 207   }
 208
 209 inline static int simcall_BODY_host_get_state(smx_host_t host) {
 210     smx_process_t self = SIMIX_process_self();
 211
 212     /* Go to that function to follow the code flow through the simcall barrier */
 213     if (0) SIMIX_host_get_state(host);
 214     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 215
 216     self->simcall.call = SIMCALL_HOST_GET_STATE;
 217     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 218     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 219     self->simcall.args[0].dp = (void*) host;
 220     if (self != simix_global->maestro_process) {
 221       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 222                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 223       SIMIX_process_yield(self);
 224     } else {
 225       SIMIX_simcall_handle(&self->simcall, 0);
 226     }
 227     return self->simcall.result.i;
 228   }
 229
 230 inline static double simcall_BODY_host_get_current_power_peak(smx_host_t host) {
 231     smx_process_t self = SIMIX_process_self();
 232
 233     /* Go to that function to follow the code flow through the simcall barrier */
 234     if (0) SIMIX_host_get_current_power_peak(host);
 235     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 236
 237     self->simcall.call = SIMCALL_HOST_GET_CURRENT_POWER_PEAK;
 238     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 239     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 240     self->simcall.args[0].dp = (void*) host;
 241     if (self != simix_global->maestro_process) {
 242       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 243                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 244       SIMIX_process_yield(self);
 245     } else {
 246       SIMIX_simcall_handle(&self->simcall, 0);
 247     }
 248     return self->simcall.result.d;
 249   }
 250
 251 inline static double simcall_BODY_host_get_power_peak_at(smx_host_t host, int pstate_index) {
 252     smx_process_t self = SIMIX_process_self();
 253
 254     /* Go to that function to follow the code flow through the simcall barrier */
 255     if (0) SIMIX_host_get_power_peak_at(host, pstate_index);
 256     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 257
 258     self->simcall.call = SIMCALL_HOST_GET_POWER_PEAK_AT;
 259     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 260     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 261     self->simcall.args[0].dp = (void*) host;
 262     self->simcall.args[1].i = (int) pstate_index;
 263     if (self != simix_global->maestro_process) {
 264       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 265                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 266       SIMIX_process_yield(self);
 267     } else {
 268       SIMIX_simcall_handle(&self->simcall, 0);
 269     }
 270     return self->simcall.result.d;
 271   }
 272
 273 inline static int simcall_BODY_host_get_nb_pstates(smx_host_t host) {
 274     smx_process_t self = SIMIX_process_self();
 275
 276     /* Go to that function to follow the code flow through the simcall barrier */
 277     if (0) SIMIX_host_get_nb_pstates(host);
 278     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 279
 280     self->simcall.call = SIMCALL_HOST_GET_NB_PSTATES;
 281     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 282     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 283     self->simcall.args[0].dp = (void*) host;
 284     if (self != simix_global->maestro_process) {
 285       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 286                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 287       SIMIX_process_yield(self);
 288     } else {
 289       SIMIX_simcall_handle(&self->simcall, 0);
 290     }
 291     return self->simcall.result.i;
 292   }
 293
 294 inline static void simcall_BODY_host_set_power_peak_at(smx_host_t host, int pstate_index) {
 295     smx_process_t self = SIMIX_process_self();
 296
 297     /* Go to that function to follow the code flow through the simcall barrier */
 298     if (0) SIMIX_host_set_power_peak_at(host, pstate_index);
 299     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 300
 301     self->simcall.call = SIMCALL_HOST_SET_POWER_PEAK_AT;
 302     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 303     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 304     self->simcall.args[0].dp = (void*) host;
 305     self->simcall.args[1].i = (int) pstate_index;
 306     if (self != simix_global->maestro_process) {
 307       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 308                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 309       SIMIX_process_yield(self);
 310     } else {
 311       SIMIX_simcall_handle(&self->simcall, 0);
 312     }
 313
 314   }
 315
 316 inline static double simcall_BODY_host_get_consumed_energy(smx_host_t host) {
 317     smx_process_t self = SIMIX_process_self();
 318
 319     /* Go to that function to follow the code flow through the simcall barrier */
 320     if (0) SIMIX_host_get_consumed_energy(host);
 321     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 322
 323     self->simcall.call = SIMCALL_HOST_GET_CONSUMED_ENERGY;
 324     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 325     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 326     self->simcall.args[0].dp = (void*) host;
 327     if (self != simix_global->maestro_process) {
 328       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 329                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 330       SIMIX_process_yield(self);
 331     } else {
 332       SIMIX_simcall_handle(&self->simcall, 0);
 333     }
 334     return self->simcall.result.d;
 335   }
 336
 337 inline static smx_synchro_t simcall_BODY_host_execute(const char* name, smx_host_t host, double flops_amount, double priority, double bound, unsigned long affinity_mask) {
 338     smx_process_t self = SIMIX_process_self();
 339
 340     /* Go to that function to follow the code flow through the simcall barrier */
 341     if (0) SIMIX_host_execute(name, host, flops_amount, priority, bound, affinity_mask);
 342     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 343
 344     self->simcall.call = SIMCALL_HOST_EXECUTE;
 345     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 346     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 347     self->simcall.args[0].cc = (const char*) name;
 348     self->simcall.args[1].dp = (void*) host;
 349     self->simcall.args[2].d = (double) flops_amount;
 350     self->simcall.args[3].d = (double) priority;
 351     self->simcall.args[4].d = (double) bound;
 352     self->simcall.args[5].ul = (unsigned long) affinity_mask;
 353     if (self != simix_global->maestro_process) {
 354       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 355                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 356       SIMIX_process_yield(self);
 357     } else {
 358       SIMIX_simcall_handle(&self->simcall, 0);
 359     }
 360     return self->simcall.result.dp;
 361   }
 362
 363 inline static smx_synchro_t simcall_BODY_host_parallel_execute(const char* name, int host_nb, smx_host_t* host_list, double* flops_amount, double* bytes_amount, double amount, double rate) {
 364     smx_process_t self = SIMIX_process_self();
 365
 366     /* Go to that function to follow the code flow through the simcall barrier */
 367     if (0) SIMIX_host_parallel_execute(name, host_nb, host_list, flops_amount, bytes_amount, amount, rate);
 368     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 369
 370     self->simcall.call = SIMCALL_HOST_PARALLEL_EXECUTE;
 371     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 372     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 373     self->simcall.args[0].cc = (const char*) name;
 374     self->simcall.args[1].i = (int) host_nb;
 375     self->simcall.args[2].dp = (void*) host_list;
 376     self->simcall.args[3].dp = (void*) flops_amount;
 377     self->simcall.args[4].dp = (void*) bytes_amount;
 378     self->simcall.args[5].d = (double) amount;
 379     self->simcall.args[6].d = (double) rate;
 380     if (self != simix_global->maestro_process) {
 381       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 382                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 383       SIMIX_process_yield(self);
 384     } else {
 385       SIMIX_simcall_handle(&self->simcall, 0);
 386     }
 387     return self->simcall.result.dp;
 388   }
 389
 390 inline static void simcall_BODY_host_execution_destroy(smx_synchro_t execution) {
 391     smx_process_t self = SIMIX_process_self();
 392
 393     /* Go to that function to follow the code flow through the simcall barrier */
 394     if (0) SIMIX_host_execution_destroy(execution);
 395     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 396
 397     self->simcall.call = SIMCALL_HOST_EXECUTION_DESTROY;
 398     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 399     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 400     self->simcall.args[0].dp = (void*) execution;
 401     if (self != simix_global->maestro_process) {
 402       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 403                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 404       SIMIX_process_yield(self);
 405     } else {
 406       SIMIX_simcall_handle(&self->simcall, 0);
 407     }
 408
 409   }
 410
 411 inline static void simcall_BODY_host_execution_cancel(smx_synchro_t execution) {
 412     smx_process_t self = SIMIX_process_self();
 413
 414     /* Go to that function to follow the code flow through the simcall barrier */
 415     if (0) SIMIX_host_execution_cancel(execution);
 416     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 417
 418     self->simcall.call = SIMCALL_HOST_EXECUTION_CANCEL;
 419     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 420     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 421     self->simcall.args[0].dp = (void*) execution;
 422     if (self != simix_global->maestro_process) {
 423       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 424                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 425       SIMIX_process_yield(self);
 426     } else {
 427       SIMIX_simcall_handle(&self->simcall, 0);
 428     }
 429
 430   }
 431
 432 inline static double simcall_BODY_host_execution_get_remains(smx_synchro_t execution) {
 433     smx_process_t self = SIMIX_process_self();
 434
 435     /* Go to that function to follow the code flow through the simcall barrier */
 436     if (0) SIMIX_host_execution_get_remains(execution);
 437     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 438
 439     self->simcall.call = SIMCALL_HOST_EXECUTION_GET_REMAINS;
 440     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 441     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 442     self->simcall.args[0].dp = (void*) execution;
 443     if (self != simix_global->maestro_process) {
 444       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 445                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 446       SIMIX_process_yield(self);
 447     } else {
 448       SIMIX_simcall_handle(&self->simcall, 0);
 449     }
 450     return self->simcall.result.d;
 451   }
 452
 453 inline static e_smx_state_t simcall_BODY_host_execution_get_state(smx_synchro_t execution) {
 454     smx_process_t self = SIMIX_process_self();
 455
 456     /* Go to that function to follow the code flow through the simcall barrier */
 457     if (0) SIMIX_host_execution_get_state(execution);
 458     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 459
 460     self->simcall.call = SIMCALL_HOST_EXECUTION_GET_STATE;
 461     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 462     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 463     self->simcall.args[0].dp = (void*) execution;
 464     if (self != simix_global->maestro_process) {
 465       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 466                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 467       SIMIX_process_yield(self);
 468     } else {
 469       SIMIX_simcall_handle(&self->simcall, 0);
 470     }
 471     return self->simcall.result.i;
 472   }
 473
 474 inline static void simcall_BODY_host_execution_set_priority(smx_synchro_t execution, double priority) {
 475     smx_process_t self = SIMIX_process_self();
 476
 477     /* Go to that function to follow the code flow through the simcall barrier */
 478     if (0) SIMIX_host_execution_set_priority(execution, priority);
 479     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 480
 481     self->simcall.call = SIMCALL_HOST_EXECUTION_SET_PRIORITY;
 482     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 483     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 484     self->simcall.args[0].dp = (void*) execution;
 485     self->simcall.args[1].d = (double) priority;
 486     if (self != simix_global->maestro_process) {
 487       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 488                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 489       SIMIX_process_yield(self);
 490     } else {
 491       SIMIX_simcall_handle(&self->simcall, 0);
 492     }
 493
 494   }
 495
 496 inline static void simcall_BODY_host_execution_set_bound(smx_synchro_t execution, double bound) {
 497     smx_process_t self = SIMIX_process_self();
 498
 499     /* Go to that function to follow the code flow through the simcall barrier */
 500     if (0) SIMIX_host_execution_set_bound(execution, bound);
 501     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 502
 503     self->simcall.call = SIMCALL_HOST_EXECUTION_SET_BOUND;
 504     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 505     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 506     self->simcall.args[0].dp = (void*) execution;
 507     self->simcall.args[1].d = (double) bound;
 508     if (self != simix_global->maestro_process) {
 509       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 510                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 511       SIMIX_process_yield(self);
 512     } else {
 513       SIMIX_simcall_handle(&self->simcall, 0);
 514     }
 515
 516   }
 517
 518 inline static void simcall_BODY_host_execution_set_affinity(smx_synchro_t execution, smx_host_t ws, unsigned long mask) {
 519     smx_process_t self = SIMIX_process_self();
 520
 521     /* Go to that function to follow the code flow through the simcall barrier */
 522     if (0) SIMIX_host_execution_set_affinity(execution, ws, mask);
 523     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 524
 525     self->simcall.call = SIMCALL_HOST_EXECUTION_SET_AFFINITY;
 526     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 527     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 528     self->simcall.args[0].dp = (void*) execution;
 529     self->simcall.args[1].dp = (void*) ws;
 530     self->simcall.args[2].ul = (unsigned long) mask;
 531     if (self != simix_global->maestro_process) {
 532       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 533                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 534       SIMIX_process_yield(self);
 535     } else {
 536       SIMIX_simcall_handle(&self->simcall, 0);
 537     }
 538
 539   }
 540
 541 inline static int simcall_BODY_host_execution_wait(smx_synchro_t execution) {
 542     smx_process_t self = SIMIX_process_self();
 543
 544     /* Go to that function to follow the code flow through the simcall barrier */
 545     if (0) simcall_HANDLER_host_execution_wait(&self->simcall, execution);
 546     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 547
 548     self->simcall.call = SIMCALL_HOST_EXECUTION_WAIT;
 549     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 550     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 551     self->simcall.args[0].dp = (void*) execution;
 552     if (self != simix_global->maestro_process) {
 553       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 554                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 555       SIMIX_process_yield(self);
 556     } else {
 557       SIMIX_simcall_handle(&self->simcall, 0);
 558     }
 559     return self->simcall.result.i;
 560   }
 561
 562 inline static xbt_dict_t simcall_BODY_host_get_mounted_storage_list(smx_host_t host) {
 563     smx_process_t self = SIMIX_process_self();
 564
 565     /* Go to that function to follow the code flow through the simcall barrier */
 566     if (0) SIMIX_host_get_mounted_storage_list(host);
 567     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 568
 569     self->simcall.call = SIMCALL_HOST_GET_MOUNTED_STORAGE_LIST;
 570     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 571     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 572     self->simcall.args[0].dp = (void*) host;
 573     if (self != simix_global->maestro_process) {
 574       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 575                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 576       SIMIX_process_yield(self);
 577     } else {
 578       SIMIX_simcall_handle(&self->simcall, 0);
 579     }
 580     return self->simcall.result.dp;
 581   }
 582
 583 inline static xbt_dynar_t simcall_BODY_host_get_attached_storage_list(smx_host_t host) {
 584     smx_process_t self = SIMIX_process_self();
 585
 586     /* Go to that function to follow the code flow through the simcall barrier */
 587     if (0) SIMIX_host_get_attached_storage_list(host);
 588     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 589
 590     self->simcall.call = SIMCALL_HOST_GET_ATTACHED_STORAGE_LIST;
 591     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 592     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 593     self->simcall.args[0].dp = (void*) host;
 594     if (self != simix_global->maestro_process) {
 595       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 596                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 597       SIMIX_process_yield(self);
 598     } else {
 599       SIMIX_simcall_handle(&self->simcall, 0);
 600     }
 601     return self->simcall.result.dp;
 602   }
 603
 604 inline static void simcall_BODY_host_get_params(smx_host_t ind_vm, ws_params_t params) {
 605     smx_process_t self = SIMIX_process_self();
 606
 607     /* Go to that function to follow the code flow through the simcall barrier */
 608     if (0) SIMIX_host_get_params(ind_vm, params);
 609     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 610
 611     self->simcall.call = SIMCALL_HOST_GET_PARAMS;
 612     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 613     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 614     self->simcall.args[0].dp = (void*) ind_vm;
 615     self->simcall.args[1].dp = (void*) params;
 616     if (self != simix_global->maestro_process) {
 617       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 618                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 619       SIMIX_process_yield(self);
 620     } else {
 621       SIMIX_simcall_handle(&self->simcall, 0);
 622     }
 623
 624   }
 625
 626 inline static void simcall_BODY_host_set_params(smx_host_t ind_vm, ws_params_t params) {
 627     smx_process_t self = SIMIX_process_self();
 628
 629     /* Go to that function to follow the code flow through the simcall barrier */
 630     if (0) SIMIX_host_set_params(ind_vm, params);
 631     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 632
 633     self->simcall.call = SIMCALL_HOST_SET_PARAMS;
 634     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 635     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 636     self->simcall.args[0].dp = (void*) ind_vm;
 637     self->simcall.args[1].dp = (void*) params;
 638     if (self != simix_global->maestro_process) {
 639       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 640                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 641       SIMIX_process_yield(self);
 642     } else {
 643       SIMIX_simcall_handle(&self->simcall, 0);
 644     }
 645
 646   }
 647
 648 inline static smx_host_t simcall_BODY_vm_create(const char* name, smx_host_t ind_pm) {
 649     smx_process_t self = SIMIX_process_self();
 650
 651     /* Go to that function to follow the code flow through the simcall barrier */
 652     if (0) SIMIX_vm_create(name, ind_pm);
 653     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 654
 655     self->simcall.call = SIMCALL_VM_CREATE;
 656     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 657     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 658     self->simcall.args[0].cc = (const char*) name;
 659     self->simcall.args[1].dp = (void*) ind_pm;
 660     if (self != simix_global->maestro_process) {
 661       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 662                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 663       SIMIX_process_yield(self);
 664     } else {
 665       SIMIX_simcall_handle(&self->simcall, 0);
 666     }
 667     return self->simcall.result.dp;
 668   }
 669
 670 inline static void simcall_BODY_vm_start(smx_host_t ind_vm) {
 671     smx_process_t self = SIMIX_process_self();
 672
 673     /* Go to that function to follow the code flow through the simcall barrier */
 674     if (0) SIMIX_vm_start(ind_vm);
 675     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 676
 677     self->simcall.call = SIMCALL_VM_START;
 678     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 679     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 680     self->simcall.args[0].dp = (void*) ind_vm;
 681     if (self != simix_global->maestro_process) {
 682       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 683                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 684       SIMIX_process_yield(self);
 685     } else {
 686       SIMIX_simcall_handle(&self->simcall, 0);
 687     }
 688
 689   }
 690
 691 inline static int simcall_BODY_vm_get_state(smx_host_t ind_vm) {
 692     smx_process_t self = SIMIX_process_self();
 693
 694     /* Go to that function to follow the code flow through the simcall barrier */
 695     if (0) SIMIX_vm_get_state(ind_vm);
 696     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 697
 698     self->simcall.call = SIMCALL_VM_GET_STATE;
 699     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 700     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 701     self->simcall.args[0].dp = (void*) ind_vm;
 702     if (self != simix_global->maestro_process) {
 703       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 704                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 705       SIMIX_process_yield(self);
 706     } else {
 707       SIMIX_simcall_handle(&self->simcall, 0);
 708     }
 709     return self->simcall.result.i;
 710   }
 711
 712 inline static void simcall_BODY_vm_migrate(smx_host_t ind_vm, smx_host_t ind_dst_pm) {
 713     smx_process_t self = SIMIX_process_self();
 714
 715     /* Go to that function to follow the code flow through the simcall barrier */
 716     if (0) SIMIX_vm_migrate(ind_vm, ind_dst_pm);
 717     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 718
 719     self->simcall.call = SIMCALL_VM_MIGRATE;
 720     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 721     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 722     self->simcall.args[0].dp = (void*) ind_vm;
 723     self->simcall.args[1].dp = (void*) ind_dst_pm;
 724     if (self != simix_global->maestro_process) {
 725       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 726                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 727       SIMIX_process_yield(self);
 728     } else {
 729       SIMIX_simcall_handle(&self->simcall, 0);
 730     }
 731
 732   }
 733
 734 inline static void* simcall_BODY_vm_get_pm(smx_host_t ind_vm) {
 735     smx_process_t self = SIMIX_process_self();
 736
 737     /* Go to that function to follow the code flow through the simcall barrier */
 738     if (0) SIMIX_vm_get_pm(ind_vm);
 739     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 740
 741     self->simcall.call = SIMCALL_VM_GET_PM;
 742     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 743     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 744     self->simcall.args[0].dp = (void*) ind_vm;
 745     if (self != simix_global->maestro_process) {
 746       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 747                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 748       SIMIX_process_yield(self);
 749     } else {
 750       SIMIX_simcall_handle(&self->simcall, 0);
 751     }
 752     return self->simcall.result.dp;
 753   }
 754
 755 inline static void simcall_BODY_vm_set_bound(smx_host_t ind_vm, double bound) {
 756     smx_process_t self = SIMIX_process_self();
 757
 758     /* Go to that function to follow the code flow through the simcall barrier */
 759     if (0) SIMIX_vm_set_bound(ind_vm, bound);
 760     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 761
 762     self->simcall.call = SIMCALL_VM_SET_BOUND;
 763     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 764     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 765     self->simcall.args[0].dp = (void*) ind_vm;
 766     self->simcall.args[1].d = (double) bound;
 767     if (self != simix_global->maestro_process) {
 768       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 769                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 770       SIMIX_process_yield(self);
 771     } else {
 772       SIMIX_simcall_handle(&self->simcall, 0);
 773     }
 774
 775   }
 776
 777 inline static void simcall_BODY_vm_set_affinity(smx_host_t ind_vm, smx_host_t ind_pm, unsigned long mask) {
 778     smx_process_t self = SIMIX_process_self();
 779
 780     /* Go to that function to follow the code flow through the simcall barrier */
 781     if (0) SIMIX_vm_set_affinity(ind_vm, ind_pm, mask);
 782     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 783
 784     self->simcall.call = SIMCALL_VM_SET_AFFINITY;
 785     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 786     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 787     self->simcall.args[0].dp = (void*) ind_vm;
 788     self->simcall.args[1].dp = (void*) ind_pm;
 789     self->simcall.args[2].ul = (unsigned long) mask;
 790     if (self != simix_global->maestro_process) {
 791       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 792                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 793       SIMIX_process_yield(self);
 794     } else {
 795       SIMIX_simcall_handle(&self->simcall, 0);
 796     }
 797
 798   }
 799
 800 inline static void simcall_BODY_vm_destroy(smx_host_t ind_vm) {
 801     smx_process_t self = SIMIX_process_self();
 802
 803     /* Go to that function to follow the code flow through the simcall barrier */
 804     if (0) SIMIX_vm_destroy(ind_vm);
 805     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 806
 807     self->simcall.call = SIMCALL_VM_DESTROY;
 808     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 809     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 810     self->simcall.args[0].dp = (void*) ind_vm;
 811     if (self != simix_global->maestro_process) {
 812       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 813                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 814       SIMIX_process_yield(self);
 815     } else {
 816       SIMIX_simcall_handle(&self->simcall, 0);
 817     }
 818
 819   }
 820
 821 inline static void simcall_BODY_vm_suspend(smx_host_t ind_vm) {
 822     smx_process_t self = SIMIX_process_self();
 823
 824     /* Go to that function to follow the code flow through the simcall barrier */
 825     if (0) simcall_HANDLER_vm_suspend(&self->simcall, ind_vm);
 826     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 827
 828     self->simcall.call = SIMCALL_VM_SUSPEND;
 829     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 830     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 831     self->simcall.args[0].dp = (void*) ind_vm;
 832     if (self != simix_global->maestro_process) {
 833       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 834                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 835       SIMIX_process_yield(self);
 836     } else {
 837       SIMIX_simcall_handle(&self->simcall, 0);
 838     }
 839
 840   }
 841
 842 inline static void simcall_BODY_vm_resume(smx_host_t ind_vm) {
 843     smx_process_t self = SIMIX_process_self();
 844
 845     /* Go to that function to follow the code flow through the simcall barrier */
 846     if (0) simcall_HANDLER_vm_resume(&self->simcall, ind_vm);
 847     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 848
 849     self->simcall.call = SIMCALL_VM_RESUME;
 850     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 851     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 852     self->simcall.args[0].dp = (void*) ind_vm;
 853     if (self != simix_global->maestro_process) {
 854       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 855                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 856       SIMIX_process_yield(self);
 857     } else {
 858       SIMIX_simcall_handle(&self->simcall, 0);
 859     }
 860
 861   }
 862
 863 inline static void simcall_BODY_vm_shutdown(smx_host_t ind_vm) {
 864     smx_process_t self = SIMIX_process_self();
 865
 866     /* Go to that function to follow the code flow through the simcall barrier */
 867     if (0) simcall_HANDLER_vm_shutdown(&self->simcall, ind_vm);
 868     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 869
 870     self->simcall.call = SIMCALL_VM_SHUTDOWN;
 871     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 872     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 873     self->simcall.args[0].dp = (void*) ind_vm;
 874     if (self != simix_global->maestro_process) {
 875       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 876                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 877       SIMIX_process_yield(self);
 878     } else {
 879       SIMIX_simcall_handle(&self->simcall, 0);
 880     }
 881
 882   }
 883
 884 inline static void simcall_BODY_vm_save(smx_host_t ind_vm) {
 885     smx_process_t self = SIMIX_process_self();
 886
 887     /* Go to that function to follow the code flow through the simcall barrier */
 888     if (0) simcall_HANDLER_vm_save(&self->simcall, ind_vm);
 889     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 890
 891     self->simcall.call = SIMCALL_VM_SAVE;
 892     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 893     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 894     self->simcall.args[0].dp = (void*) ind_vm;
 895     if (self != simix_global->maestro_process) {
 896       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 897                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 898       SIMIX_process_yield(self);
 899     } else {
 900       SIMIX_simcall_handle(&self->simcall, 0);
 901     }
 902
 903   }
 904
 905 inline static void simcall_BODY_vm_restore(smx_host_t ind_vm) {
 906     smx_process_t self = SIMIX_process_self();
 907
 908     /* Go to that function to follow the code flow through the simcall barrier */
 909     if (0) simcall_HANDLER_vm_restore(&self->simcall, ind_vm);
 910     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 911
 912     self->simcall.call = SIMCALL_VM_RESTORE;
 913     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 914     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 915     self->simcall.args[0].dp = (void*) ind_vm;
 916     if (self != simix_global->maestro_process) {
 917       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 918                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 919       SIMIX_process_yield(self);
 920     } else {
 921       SIMIX_simcall_handle(&self->simcall, 0);
 922     }
 923
 924   }
 925
 926 inline static void simcall_BODY_vm_migratefrom_resumeto(smx_host_t vm, smx_host_t src_pm, smx_host_t dst_pm) {
 927     smx_process_t self = SIMIX_process_self();
 928
 929     /* Go to that function to follow the code flow through the simcall barrier */
 930     if (0) SIMIX_vm_migratefrom_resumeto(vm, src_pm, dst_pm);
 931     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 932
 933     self->simcall.call = SIMCALL_VM_MIGRATEFROM_RESUMETO;
 934     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 935     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 936     self->simcall.args[0].dp = (void*) vm;
 937     self->simcall.args[1].dp = (void*) src_pm;
 938     self->simcall.args[2].dp = (void*) dst_pm;
 939     if (self != simix_global->maestro_process) {
 940       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 941                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 942       SIMIX_process_yield(self);
 943     } else {
 944       SIMIX_simcall_handle(&self->simcall, 0);
 945     }
 946
 947   }
 948
 949 inline static void simcall_BODY_process_create(smx_process_t* process, 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) {
 950     smx_process_t self = SIMIX_process_self();
 951
 952     /* Go to that function to follow the code flow through the simcall barrier */
 953     if (0) simcall_HANDLER_process_create(&self->simcall, process, name, code, data, hostname, kill_time, argc, argv, properties, auto_restart);
 954     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 955
 956     self->simcall.call = SIMCALL_PROCESS_CREATE;
 957     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 958     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 959     self->simcall.args[0].dp = (void*) process;
 960     self->simcall.args[1].cc = (const char*) name;
 961     self->simcall.args[2].fp = (FPtr) code;
 962     self->simcall.args[3].dp = (void*) data;
 963     self->simcall.args[4].cc = (const char*) hostname;
 964     self->simcall.args[5].d = (double) kill_time;
 965     self->simcall.args[6].i = (int) argc;
 966     self->simcall.args[7].dp = (void*) argv;
 967     self->simcall.args[8].dp = (void*) properties;
 968     self->simcall.args[9].i = (int) auto_restart;
 969     if (self != simix_global->maestro_process) {
 970       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 971                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 972       SIMIX_process_yield(self);
 973     } else {
 974       SIMIX_simcall_handle(&self->simcall, 0);
 975     }
 976
 977   }
 978
 979 inline static void simcall_BODY_process_kill(smx_process_t process) {
 980     smx_process_t self = SIMIX_process_self();
 981
 982     /* Go to that function to follow the code flow through the simcall barrier */
 983     if (0) simcall_HANDLER_process_kill(&self->simcall, process);
 984     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
 985
 986     self->simcall.call = SIMCALL_PROCESS_KILL;
 987     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 988     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 989     self->simcall.args[0].dp = (void*) process;
 990     if (self != simix_global->maestro_process) {
 991       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 992                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 993       SIMIX_process_yield(self);
 994     } else {
 995       SIMIX_simcall_handle(&self->simcall, 0);
 996     }
 997
 998   }
 999
1000 inline static void simcall_BODY_process_killall(int reset_pid) {
1001     smx_process_t self = SIMIX_process_self();
1002
1003     /* Go to that function to follow the code flow through the simcall barrier */
1004     if (0) simcall_HANDLER_process_killall(&self->simcall, reset_pid);
1005     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1006
1007     self->simcall.call = SIMCALL_PROCESS_KILLALL;
1008     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1009     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1010     self->simcall.args[0].i = (int) reset_pid;
1011     if (self != simix_global->maestro_process) {
1012       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1013                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1014       SIMIX_process_yield(self);
1015     } else {
1016       SIMIX_simcall_handle(&self->simcall, 0);
1017     }
1018
1019   }
1020
1021 inline static void simcall_BODY_process_cleanup(smx_process_t process) {
1022     smx_process_t self = SIMIX_process_self();
1023
1024     /* Go to that function to follow the code flow through the simcall barrier */
1025     if (0) SIMIX_process_cleanup(process);
1026     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1027
1028     self->simcall.call = SIMCALL_PROCESS_CLEANUP;
1029     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1030     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1031     self->simcall.args[0].dp = (void*) process;
1032     if (self != simix_global->maestro_process) {
1033       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1034                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1035       SIMIX_process_yield(self);
1036     } else {
1037       SIMIX_simcall_handle(&self->simcall, 0);
1038     }
1039
1040   }
1041
1042 inline static void simcall_BODY_process_change_host(smx_process_t process, smx_host_t dest) {
1043     smx_process_t self = SIMIX_process_self();
1044
1045     /* Go to that function to follow the code flow through the simcall barrier */
1046     if (0) simcall_HANDLER_process_change_host(&self->simcall, process, dest);
1047     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1048
1049     self->simcall.call = SIMCALL_PROCESS_CHANGE_HOST;
1050     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1051     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1052     self->simcall.args[0].dp = (void*) process;
1053     self->simcall.args[1].dp = (void*) dest;
1054     if (self != simix_global->maestro_process) {
1055       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1056                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1057       SIMIX_process_yield(self);
1058     } else {
1059       SIMIX_simcall_handle(&self->simcall, 0);
1060     }
1061
1062   }
1063
1064 inline static void simcall_BODY_process_suspend(smx_process_t process) {
1065     smx_process_t self = SIMIX_process_self();
1066
1067     /* Go to that function to follow the code flow through the simcall barrier */
1068     if (0) simcall_HANDLER_process_suspend(&self->simcall, process);
1069     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1070
1071     self->simcall.call = SIMCALL_PROCESS_SUSPEND;
1072     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1073     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1074     self->simcall.args[0].dp = (void*) process;
1075     if (self != simix_global->maestro_process) {
1076       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1077                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1078       SIMIX_process_yield(self);
1079     } else {
1080       SIMIX_simcall_handle(&self->simcall, 0);
1081     }
1082
1083   }
1084
1085 inline static void simcall_BODY_process_resume(smx_process_t process) {
1086     smx_process_t self = SIMIX_process_self();
1087
1088     /* Go to that function to follow the code flow through the simcall barrier */
1089     if (0) simcall_HANDLER_process_resume(&self->simcall, process);
1090     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1091
1092     self->simcall.call = SIMCALL_PROCESS_RESUME;
1093     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1094     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1095     self->simcall.args[0].dp = (void*) process;
1096     if (self != simix_global->maestro_process) {
1097       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1098                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1099       SIMIX_process_yield(self);
1100     } else {
1101       SIMIX_simcall_handle(&self->simcall, 0);
1102     }
1103
1104   }
1105
1106 inline static int simcall_BODY_process_count() {
1107     smx_process_t self = SIMIX_process_self();
1108
1109     /* Go to that function to follow the code flow through the simcall barrier */
1110     if (0) SIMIX_process_count();
1111     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1112
1113     self->simcall.call = SIMCALL_PROCESS_COUNT;
1114     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1115     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1116
1117     if (self != simix_global->maestro_process) {
1118       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1119                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1120       SIMIX_process_yield(self);
1121     } else {
1122       SIMIX_simcall_handle(&self->simcall, 0);
1123     }
1124     return self->simcall.result.i;
1125   }
1126
1127 inline static int simcall_BODY_process_get_PID(smx_process_t process) {
1128     smx_process_t self = SIMIX_process_self();
1129
1130     /* Go to that function to follow the code flow through the simcall barrier */
1131     if (0) SIMIX_process_get_PID(process);
1132     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1133
1134     self->simcall.call = SIMCALL_PROCESS_GET_PID;
1135     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1136     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1137     self->simcall.args[0].dp = (void*) process;
1138     if (self != simix_global->maestro_process) {
1139       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1140                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1141       SIMIX_process_yield(self);
1142     } else {
1143       SIMIX_simcall_handle(&self->simcall, 0);
1144     }
1145     return self->simcall.result.i;
1146   }
1147
1148 inline static int simcall_BODY_process_get_PPID(smx_process_t process) {
1149     smx_process_t self = SIMIX_process_self();
1150
1151     /* Go to that function to follow the code flow through the simcall barrier */
1152     if (0) SIMIX_process_get_PPID(process);
1153     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1154
1155     self->simcall.call = SIMCALL_PROCESS_GET_PPID;
1156     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1157     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1158     self->simcall.args[0].dp = (void*) process;
1159     if (self != simix_global->maestro_process) {
1160       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1161                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1162       SIMIX_process_yield(self);
1163     } else {
1164       SIMIX_simcall_handle(&self->simcall, 0);
1165     }
1166     return self->simcall.result.i;
1167   }
1168
1169 inline static void* simcall_BODY_process_get_data(smx_process_t process) {
1170     smx_process_t self = SIMIX_process_self();
1171
1172     /* Go to that function to follow the code flow through the simcall barrier */
1173     if (0) SIMIX_process_get_data(process);
1174     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1175
1176     self->simcall.call = SIMCALL_PROCESS_GET_DATA;
1177     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1178     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1179     self->simcall.args[0].dp = (void*) process;
1180     if (self != simix_global->maestro_process) {
1181       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1182                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1183       SIMIX_process_yield(self);
1184     } else {
1185       SIMIX_simcall_handle(&self->simcall, 0);
1186     }
1187     return self->simcall.result.dp;
1188   }
1189
1190 inline static void simcall_BODY_process_set_data(smx_process_t process, void* data) {
1191     smx_process_t self = SIMIX_process_self();
1192
1193     /* Go to that function to follow the code flow through the simcall barrier */
1194     if (0) SIMIX_process_set_data(process, data);
1195     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1196
1197     self->simcall.call = SIMCALL_PROCESS_SET_DATA;
1198     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1199     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1200     self->simcall.args[0].dp = (void*) process;
1201     self->simcall.args[1].dp = (void*) data;
1202     if (self != simix_global->maestro_process) {
1203       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1204                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1205       SIMIX_process_yield(self);
1206     } else {
1207       SIMIX_simcall_handle(&self->simcall, 0);
1208     }
1209
1210   }
1211
1212 inline static smx_host_t simcall_BODY_process_get_host(smx_process_t process) {
1213     smx_process_t self = SIMIX_process_self();
1214
1215     /* Go to that function to follow the code flow through the simcall barrier */
1216     if (0) SIMIX_process_get_host(process);
1217     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1218
1219     self->simcall.call = SIMCALL_PROCESS_GET_HOST;
1220     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1221     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1222     self->simcall.args[0].dp = (void*) process;
1223     if (self != simix_global->maestro_process) {
1224       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1225                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1226       SIMIX_process_yield(self);
1227     } else {
1228       SIMIX_simcall_handle(&self->simcall, 0);
1229     }
1230     return self->simcall.result.dp;
1231   }
1232
1233 inline static const char* simcall_BODY_process_get_name(smx_process_t process) {
1234     smx_process_t self = SIMIX_process_self();
1235
1236     /* Go to that function to follow the code flow through the simcall barrier */
1237     if (0) SIMIX_process_get_name(process);
1238     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1239
1240     self->simcall.call = SIMCALL_PROCESS_GET_NAME;
1241     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1242     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1243     self->simcall.args[0].dp = (void*) process;
1244     if (self != simix_global->maestro_process) {
1245       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1246                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1247       SIMIX_process_yield(self);
1248     } else {
1249       SIMIX_simcall_handle(&self->simcall, 0);
1250     }
1251     return self->simcall.result.cc;
1252   }
1253
1254 inline static int simcall_BODY_process_is_suspended(smx_process_t process) {
1255     smx_process_t self = SIMIX_process_self();
1256
1257     /* Go to that function to follow the code flow through the simcall barrier */
1258     if (0) SIMIX_process_is_suspended(process);
1259     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1260
1261     self->simcall.call = SIMCALL_PROCESS_IS_SUSPENDED;
1262     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1263     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1264     self->simcall.args[0].dp = (void*) process;
1265     if (self != simix_global->maestro_process) {
1266       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1267                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1268       SIMIX_process_yield(self);
1269     } else {
1270       SIMIX_simcall_handle(&self->simcall, 0);
1271     }
1272     return self->simcall.result.i;
1273   }
1274
1275 inline static xbt_dict_t simcall_BODY_process_get_properties(smx_process_t process) {
1276     smx_process_t self = SIMIX_process_self();
1277
1278     /* Go to that function to follow the code flow through the simcall barrier */
1279     if (0) SIMIX_process_get_properties(process);
1280     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1281
1282     self->simcall.call = SIMCALL_PROCESS_GET_PROPERTIES;
1283     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1284     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1285     self->simcall.args[0].dp = (void*) process;
1286     if (self != simix_global->maestro_process) {
1287       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1288                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1289       SIMIX_process_yield(self);
1290     } else {
1291       SIMIX_simcall_handle(&self->simcall, 0);
1292     }
1293     return self->simcall.result.dp;
1294   }
1295
1296 inline static int simcall_BODY_process_join(smx_process_t process, double timeout) {
1297     smx_process_t self = SIMIX_process_self();
1298
1299     /* Go to that function to follow the code flow through the simcall barrier */
1300     if (0) simcall_HANDLER_process_join(&self->simcall, process, timeout);
1301     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1302
1303     self->simcall.call = SIMCALL_PROCESS_JOIN;
1304     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1305     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1306     self->simcall.args[0].dp = (void*) process;
1307     self->simcall.args[1].d = (double) timeout;
1308     if (self != simix_global->maestro_process) {
1309       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1310                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1311       SIMIX_process_yield(self);
1312     } else {
1313       SIMIX_simcall_handle(&self->simcall, 0);
1314     }
1315     return self->simcall.result.i;
1316   }
1317
1318 inline static int simcall_BODY_process_sleep(double duration) {
1319     smx_process_t self = SIMIX_process_self();
1320
1321     /* Go to that function to follow the code flow through the simcall barrier */
1322     if (0) simcall_HANDLER_process_sleep(&self->simcall, duration);
1323     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1324
1325     self->simcall.call = SIMCALL_PROCESS_SLEEP;
1326     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1327     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1328     self->simcall.args[0].d = (double) duration;
1329     if (self != simix_global->maestro_process) {
1330       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1331                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1332       SIMIX_process_yield(self);
1333     } else {
1334       SIMIX_simcall_handle(&self->simcall, 0);
1335     }
1336     return self->simcall.result.i;
1337   }
1338
1339 inline static void simcall_BODY_process_on_exit(smx_process_t process, int_f_pvoid_pvoid_t fun, void* data) {
1340     smx_process_t self = SIMIX_process_self();
1341
1342     /* Go to that function to follow the code flow through the simcall barrier */
1343     if (0) SIMIX_process_on_exit(process, fun, data);
1344     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1345
1346     self->simcall.call = SIMCALL_PROCESS_ON_EXIT;
1347     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1348     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1349     self->simcall.args[0].dp = (void*) process;
1350     self->simcall.args[1].fp = (FPtr) fun;
1351     self->simcall.args[2].dp = (void*) data;
1352     if (self != simix_global->maestro_process) {
1353       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1354                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1355       SIMIX_process_yield(self);
1356     } else {
1357       SIMIX_simcall_handle(&self->simcall, 0);
1358     }
1359
1360   }
1361
1362 inline static void simcall_BODY_process_auto_restart_set(smx_process_t process, int auto_restart) {
1363     smx_process_t self = SIMIX_process_self();
1364
1365     /* Go to that function to follow the code flow through the simcall barrier */
1366     if (0) SIMIX_process_auto_restart_set(process, auto_restart);
1367     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1368
1369     self->simcall.call = SIMCALL_PROCESS_AUTO_RESTART_SET;
1370     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1371     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1372     self->simcall.args[0].dp = (void*) process;
1373     self->simcall.args[1].i = (int) auto_restart;
1374     if (self != simix_global->maestro_process) {
1375       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1376                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1377       SIMIX_process_yield(self);
1378     } else {
1379       SIMIX_simcall_handle(&self->simcall, 0);
1380     }
1381
1382   }
1383
1384 inline static smx_process_t simcall_BODY_process_restart(smx_process_t process) {
1385     smx_process_t self = SIMIX_process_self();
1386
1387     /* Go to that function to follow the code flow through the simcall barrier */
1388     if (0) simcall_HANDLER_process_restart(&self->simcall, process);
1389     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1390
1391     self->simcall.call = SIMCALL_PROCESS_RESTART;
1392     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1393     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1394     self->simcall.args[0].dp = (void*) process;
1395     if (self != simix_global->maestro_process) {
1396       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1397                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1398       SIMIX_process_yield(self);
1399     } else {
1400       SIMIX_simcall_handle(&self->simcall, 0);
1401     }
1402     return self->simcall.result.dp;
1403   }
1404
1405 inline static smx_rdv_t simcall_BODY_rdv_create(const char* name) {
1406     smx_process_t self = SIMIX_process_self();
1407
1408     /* Go to that function to follow the code flow through the simcall barrier */
1409     if (0) SIMIX_rdv_create(name);
1410     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1411
1412     self->simcall.call = SIMCALL_RDV_CREATE;
1413     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1414     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1415     self->simcall.args[0].cc = (const char*) name;
1416     if (self != simix_global->maestro_process) {
1417       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1418                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1419       SIMIX_process_yield(self);
1420     } else {
1421       SIMIX_simcall_handle(&self->simcall, 0);
1422     }
1423     return self->simcall.result.dp;
1424   }
1425
1426 inline static void simcall_BODY_rdv_destroy(smx_rdv_t rdv) {
1427     smx_process_t self = SIMIX_process_self();
1428
1429     /* Go to that function to follow the code flow through the simcall barrier */
1430     if (0) SIMIX_rdv_destroy(rdv);
1431     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1432
1433     self->simcall.call = SIMCALL_RDV_DESTROY;
1434     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1435     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1436     self->simcall.args[0].dp = (void*) rdv;
1437     if (self != simix_global->maestro_process) {
1438       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1439                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1440       SIMIX_process_yield(self);
1441     } else {
1442       SIMIX_simcall_handle(&self->simcall, 0);
1443     }
1444
1445   }
1446
1447 inline static unsigned int simcall_BODY_rdv_comm_count_by_host(smx_rdv_t rdv, smx_host_t host) {
1448     smx_process_t self = SIMIX_process_self();
1449
1450     /* Go to that function to follow the code flow through the simcall barrier */
1451     if (0) SIMIX_rdv_comm_count_by_host(rdv, host);
1452     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1453
1454     self->simcall.call = SIMCALL_RDV_COMM_COUNT_BY_HOST;
1455     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1456     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1457     self->simcall.args[0].dp = (void*) rdv;
1458     self->simcall.args[1].dp = (void*) host;
1459     if (self != simix_global->maestro_process) {
1460       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1461                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1462       SIMIX_process_yield(self);
1463     } else {
1464       SIMIX_simcall_handle(&self->simcall, 0);
1465     }
1466     return self->simcall.result.ui;
1467   }
1468
1469 inline static smx_synchro_t simcall_BODY_rdv_get_head(smx_rdv_t rdv) {
1470     smx_process_t self = SIMIX_process_self();
1471
1472     /* Go to that function to follow the code flow through the simcall barrier */
1473     if (0) SIMIX_rdv_get_head(rdv);
1474     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1475
1476     self->simcall.call = SIMCALL_RDV_GET_HEAD;
1477     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1478     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1479     self->simcall.args[0].dp = (void*) rdv;
1480     if (self != simix_global->maestro_process) {
1481       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1482                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1483       SIMIX_process_yield(self);
1484     } else {
1485       SIMIX_simcall_handle(&self->simcall, 0);
1486     }
1487     return self->simcall.result.dp;
1488   }
1489
1490 inline static void simcall_BODY_rdv_set_receiver(smx_rdv_t rdv, smx_process_t receiver) {
1491     smx_process_t self = SIMIX_process_self();
1492
1493     /* Go to that function to follow the code flow through the simcall barrier */
1494     if (0) SIMIX_rdv_set_receiver(rdv, receiver);
1495     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1496
1497     self->simcall.call = SIMCALL_RDV_SET_RECEIVER;
1498     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1499     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1500     self->simcall.args[0].dp = (void*) rdv;
1501     self->simcall.args[1].dp = (void*) receiver;
1502     if (self != simix_global->maestro_process) {
1503       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1504                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1505       SIMIX_process_yield(self);
1506     } else {
1507       SIMIX_simcall_handle(&self->simcall, 0);
1508     }
1509
1510   }
1511
1512 inline static smx_process_t simcall_BODY_rdv_get_receiver(smx_rdv_t rdv) {
1513     smx_process_t self = SIMIX_process_self();
1514
1515     /* Go to that function to follow the code flow through the simcall barrier */
1516     if (0) SIMIX_rdv_get_receiver(rdv);
1517     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1518
1519     self->simcall.call = SIMCALL_RDV_GET_RECEIVER;
1520     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1521     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1522     self->simcall.args[0].dp = (void*) rdv;
1523     if (self != simix_global->maestro_process) {
1524       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1525                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1526       SIMIX_process_yield(self);
1527     } else {
1528       SIMIX_simcall_handle(&self->simcall, 0);
1529     }
1530     return self->simcall.result.dp;
1531   }
1532
1533 inline static smx_synchro_t simcall_BODY_comm_iprobe(smx_rdv_t rdv, int type, int src, int tag, simix_match_func_t match_fun, void* data) {
1534     smx_process_t self = SIMIX_process_self();
1535
1536     /* Go to that function to follow the code flow through the simcall barrier */
1537     if (0) simcall_HANDLER_comm_iprobe(&self->simcall, rdv, type, src, tag, match_fun, data);
1538     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1539
1540     self->simcall.call = SIMCALL_COMM_IPROBE;
1541     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1542     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1543     self->simcall.args[0].dp = (void*) rdv;
1544     self->simcall.args[1].i = (int) type;
1545     self->simcall.args[2].i = (int) src;
1546     self->simcall.args[3].i = (int) tag;
1547     self->simcall.args[4].fp = (FPtr) match_fun;
1548     self->simcall.args[5].dp = (void*) data;
1549     if (self != simix_global->maestro_process) {
1550       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1551                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1552       SIMIX_process_yield(self);
1553     } else {
1554       SIMIX_simcall_handle(&self->simcall, 0);
1555     }
1556     return self->simcall.result.dp;
1557   }
1558
1559 inline static void simcall_BODY_comm_send(smx_process_t src, smx_rdv_t rdv, 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) {
1560     smx_process_t self = SIMIX_process_self();
1561
1562     /* Go to that function to follow the code flow through the simcall barrier */
1563     if (0) simcall_HANDLER_comm_send(&self->simcall, src, rdv, task_size, rate, src_buff, src_buff_size, match_fun, copy_data_fun, data, timeout);
1564     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1565
1566     self->simcall.call = SIMCALL_COMM_SEND;
1567     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1568     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1569     self->simcall.args[0].dp = (void*) src;
1570     self->simcall.args[1].dp = (void*) rdv;
1571     self->simcall.args[2].d = (double) task_size;
1572     self->simcall.args[3].d = (double) rate;
1573     self->simcall.args[4].dp = (void*) src_buff;
1574     self->simcall.args[5].sz = (size_t) src_buff_size;
1575     self->simcall.args[6].fp = (FPtr) match_fun;
1576     self->simcall.args[7].fp = (FPtr) copy_data_fun;
1577     self->simcall.args[8].dp = (void*) data;
1578     self->simcall.args[9].d = (double) timeout;
1579     if (self != simix_global->maestro_process) {
1580       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1581                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1582       SIMIX_process_yield(self);
1583     } else {
1584       SIMIX_simcall_handle(&self->simcall, 0);
1585     }
1586
1587   }
1588
1589 inline static smx_synchro_t simcall_BODY_comm_isend(smx_process_t src, smx_rdv_t rdv, 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) {
1590     smx_process_t self = SIMIX_process_self();
1591
1592     /* Go to that function to follow the code flow through the simcall barrier */
1593     if (0) simcall_HANDLER_comm_isend(&self->simcall, src, rdv, task_size, rate, src_buff, src_buff_size, match_fun, clean_fun, copy_data_fun, data, detached);
1594     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1595
1596     self->simcall.call = SIMCALL_COMM_ISEND;
1597     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1598     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1599     self->simcall.args[0].dp = (void*) src;
1600     self->simcall.args[1].dp = (void*) rdv;
1601     self->simcall.args[2].d = (double) task_size;
1602     self->simcall.args[3].d = (double) rate;
1603     self->simcall.args[4].dp = (void*) src_buff;
1604     self->simcall.args[5].sz = (size_t) src_buff_size;
1605     self->simcall.args[6].fp = (FPtr) match_fun;
1606     self->simcall.args[7].fp = (FPtr) clean_fun;
1607     self->simcall.args[8].fp = (FPtr) copy_data_fun;
1608     self->simcall.args[9].dp = (void*) data;
1609     self->simcall.args[10].i = (int) detached;
1610     if (self != simix_global->maestro_process) {
1611       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1612                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1613       SIMIX_process_yield(self);
1614     } else {
1615       SIMIX_simcall_handle(&self->simcall, 0);
1616     }
1617     return self->simcall.result.dp;
1618   }
1619
1620 inline static void simcall_BODY_comm_recv(smx_rdv_t rdv, 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) {
1621     smx_process_t self = SIMIX_process_self();
1622
1623     /* Go to that function to follow the code flow through the simcall barrier */
1624     if (0) simcall_HANDLER_comm_recv(&self->simcall, rdv, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, timeout, rate);
1625     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1626
1627     self->simcall.call = SIMCALL_COMM_RECV;
1628     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1629     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1630     self->simcall.args[0].dp = (void*) rdv;
1631     self->simcall.args[1].dp = (void*) dst_buff;
1632     self->simcall.args[2].dp = (void*) dst_buff_size;
1633     self->simcall.args[3].fp = (FPtr) match_fun;
1634     self->simcall.args[4].fp = (FPtr) copy_data_fun;
1635     self->simcall.args[5].dp = (void*) data;
1636     self->simcall.args[6].d = (double) timeout;
1637     self->simcall.args[7].d = (double) rate;
1638     if (self != simix_global->maestro_process) {
1639       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1640                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1641       SIMIX_process_yield(self);
1642     } else {
1643       SIMIX_simcall_handle(&self->simcall, 0);
1644     }
1645
1646   }
1647
1648 inline static smx_synchro_t simcall_BODY_comm_irecv(smx_rdv_t rdv, 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) {
1649     smx_process_t self = SIMIX_process_self();
1650
1651     /* Go to that function to follow the code flow through the simcall barrier */
1652     if (0) simcall_HANDLER_comm_irecv(&self->simcall, rdv, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, rate);
1653     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1654
1655     self->simcall.call = SIMCALL_COMM_IRECV;
1656     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1657     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1658     self->simcall.args[0].dp = (void*) rdv;
1659     self->simcall.args[1].dp = (void*) dst_buff;
1660     self->simcall.args[2].dp = (void*) dst_buff_size;
1661     self->simcall.args[3].fp = (FPtr) match_fun;
1662     self->simcall.args[4].fp = (FPtr) copy_data_fun;
1663     self->simcall.args[5].dp = (void*) data;
1664     self->simcall.args[6].d = (double) rate;
1665     if (self != simix_global->maestro_process) {
1666       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1667                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1668       SIMIX_process_yield(self);
1669     } else {
1670       SIMIX_simcall_handle(&self->simcall, 0);
1671     }
1672     return self->simcall.result.dp;
1673   }
1674
1675 inline static void simcall_BODY_comm_cancel(smx_synchro_t comm) {
1676     smx_process_t self = SIMIX_process_self();
1677
1678     /* Go to that function to follow the code flow through the simcall barrier */
1679     if (0) SIMIX_comm_cancel(comm);
1680     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1681
1682     self->simcall.call = SIMCALL_COMM_CANCEL;
1683     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1684     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1685     self->simcall.args[0].dp = (void*) comm;
1686     if (self != simix_global->maestro_process) {
1687       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1688                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1689       SIMIX_process_yield(self);
1690     } else {
1691       SIMIX_simcall_handle(&self->simcall, 0);
1692     }
1693
1694   }
1695
1696 inline static int simcall_BODY_comm_waitany(xbt_dynar_t comms) {
1697     smx_process_t self = SIMIX_process_self();
1698
1699     /* Go to that function to follow the code flow through the simcall barrier */
1700     if (0) simcall_HANDLER_comm_waitany(&self->simcall, comms);
1701     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1702
1703     self->simcall.call = SIMCALL_COMM_WAITANY;
1704     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1705     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1706     self->simcall.args[0].dp = (void*) comms;
1707     if (self != simix_global->maestro_process) {
1708       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1709                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1710       SIMIX_process_yield(self);
1711     } else {
1712       SIMIX_simcall_handle(&self->simcall, 0);
1713     }
1714     return self->simcall.result.i;
1715   }
1716
1717 inline static void simcall_BODY_comm_wait(smx_synchro_t comm, double timeout) {
1718     smx_process_t self = SIMIX_process_self();
1719
1720     /* Go to that function to follow the code flow through the simcall barrier */
1721     if (0) simcall_HANDLER_comm_wait(&self->simcall, comm, timeout);
1722     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1723
1724     self->simcall.call = SIMCALL_COMM_WAIT;
1725     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1726     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1727     self->simcall.args[0].dp = (void*) comm;
1728     self->simcall.args[1].d = (double) timeout;
1729     if (self != simix_global->maestro_process) {
1730       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1731                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1732       SIMIX_process_yield(self);
1733     } else {
1734       SIMIX_simcall_handle(&self->simcall, 0);
1735     }
1736
1737   }
1738
1739 inline static int simcall_BODY_comm_test(smx_synchro_t comm) {
1740     smx_process_t self = SIMIX_process_self();
1741
1742     /* Go to that function to follow the code flow through the simcall barrier */
1743     if (0) simcall_HANDLER_comm_test(&self->simcall, comm);
1744     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1745
1746     self->simcall.call = SIMCALL_COMM_TEST;
1747     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1748     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1749     self->simcall.args[0].dp = (void*) comm;
1750     if (self != simix_global->maestro_process) {
1751       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1752                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1753       SIMIX_process_yield(self);
1754     } else {
1755       SIMIX_simcall_handle(&self->simcall, 0);
1756     }
1757     return self->simcall.result.i;
1758   }
1759
1760 inline static int simcall_BODY_comm_testany(xbt_dynar_t comms) {
1761     smx_process_t self = SIMIX_process_self();
1762
1763     /* Go to that function to follow the code flow through the simcall barrier */
1764     if (0) simcall_HANDLER_comm_testany(&self->simcall, comms);
1765     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1766
1767     self->simcall.call = SIMCALL_COMM_TESTANY;
1768     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1769     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1770     self->simcall.args[0].dp = (void*) comms;
1771     if (self != simix_global->maestro_process) {
1772       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1773                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1774       SIMIX_process_yield(self);
1775     } else {
1776       SIMIX_simcall_handle(&self->simcall, 0);
1777     }
1778     return self->simcall.result.i;
1779   }
1780
1781 inline static double simcall_BODY_comm_get_remains(smx_synchro_t comm) {
1782     smx_process_t self = SIMIX_process_self();
1783
1784     /* Go to that function to follow the code flow through the simcall barrier */
1785     if (0) SIMIX_comm_get_remains(comm);
1786     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1787
1788     self->simcall.call = SIMCALL_COMM_GET_REMAINS;
1789     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1790     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1791     self->simcall.args[0].dp = (void*) comm;
1792     if (self != simix_global->maestro_process) {
1793       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1794                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1795       SIMIX_process_yield(self);
1796     } else {
1797       SIMIX_simcall_handle(&self->simcall, 0);
1798     }
1799     return self->simcall.result.d;
1800   }
1801
1802 inline static e_smx_state_t simcall_BODY_comm_get_state(smx_synchro_t comm) {
1803     smx_process_t self = SIMIX_process_self();
1804
1805     /* Go to that function to follow the code flow through the simcall barrier */
1806     if (0) SIMIX_comm_get_state(comm);
1807     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1808
1809     self->simcall.call = SIMCALL_COMM_GET_STATE;
1810     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1811     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1812     self->simcall.args[0].dp = (void*) comm;
1813     if (self != simix_global->maestro_process) {
1814       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1815                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1816       SIMIX_process_yield(self);
1817     } else {
1818       SIMIX_simcall_handle(&self->simcall, 0);
1819     }
1820     return self->simcall.result.i;
1821   }
1822
1823 inline static void* simcall_BODY_comm_get_src_data(smx_synchro_t comm) {
1824     smx_process_t self = SIMIX_process_self();
1825
1826     /* Go to that function to follow the code flow through the simcall barrier */
1827     if (0) SIMIX_comm_get_src_data(comm);
1828     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1829
1830     self->simcall.call = SIMCALL_COMM_GET_SRC_DATA;
1831     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1832     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1833     self->simcall.args[0].dp = (void*) comm;
1834     if (self != simix_global->maestro_process) {
1835       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1836                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1837       SIMIX_process_yield(self);
1838     } else {
1839       SIMIX_simcall_handle(&self->simcall, 0);
1840     }
1841     return self->simcall.result.dp;
1842   }
1843
1844 inline static void* simcall_BODY_comm_get_dst_data(smx_synchro_t comm) {
1845     smx_process_t self = SIMIX_process_self();
1846
1847     /* Go to that function to follow the code flow through the simcall barrier */
1848     if (0) SIMIX_comm_get_dst_data(comm);
1849     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1850
1851     self->simcall.call = SIMCALL_COMM_GET_DST_DATA;
1852     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1853     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1854     self->simcall.args[0].dp = (void*) comm;
1855     if (self != simix_global->maestro_process) {
1856       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1857                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1858       SIMIX_process_yield(self);
1859     } else {
1860       SIMIX_simcall_handle(&self->simcall, 0);
1861     }
1862     return self->simcall.result.dp;
1863   }
1864
1865 inline static smx_process_t simcall_BODY_comm_get_src_proc(smx_synchro_t comm) {
1866     smx_process_t self = SIMIX_process_self();
1867
1868     /* Go to that function to follow the code flow through the simcall barrier */
1869     if (0) SIMIX_comm_get_src_proc(comm);
1870     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1871
1872     self->simcall.call = SIMCALL_COMM_GET_SRC_PROC;
1873     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1874     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1875     self->simcall.args[0].dp = (void*) comm;
1876     if (self != simix_global->maestro_process) {
1877       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1878                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1879       SIMIX_process_yield(self);
1880     } else {
1881       SIMIX_simcall_handle(&self->simcall, 0);
1882     }
1883     return self->simcall.result.dp;
1884   }
1885
1886 inline static smx_process_t simcall_BODY_comm_get_dst_proc(smx_synchro_t comm) {
1887     smx_process_t self = SIMIX_process_self();
1888
1889     /* Go to that function to follow the code flow through the simcall barrier */
1890     if (0) SIMIX_comm_get_dst_proc(comm);
1891     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1892
1893     self->simcall.call = SIMCALL_COMM_GET_DST_PROC;
1894     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1895     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1896     self->simcall.args[0].dp = (void*) comm;
1897     if (self != simix_global->maestro_process) {
1898       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1899                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1900       SIMIX_process_yield(self);
1901     } else {
1902       SIMIX_simcall_handle(&self->simcall, 0);
1903     }
1904     return self->simcall.result.dp;
1905   }
1906
1907 inline static smx_mutex_t simcall_BODY_mutex_init() {
1908     smx_process_t self = SIMIX_process_self();
1909
1910     /* Go to that function to follow the code flow through the simcall barrier */
1911     if (0) simcall_HANDLER_mutex_init(&self->simcall);
1912     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1913
1914     self->simcall.call = SIMCALL_MUTEX_INIT;
1915     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1916     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1917
1918     if (self != simix_global->maestro_process) {
1919       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1920                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1921       SIMIX_process_yield(self);
1922     } else {
1923       SIMIX_simcall_handle(&self->simcall, 0);
1924     }
1925     return self->simcall.result.dp;
1926   }
1927
1928 inline static void simcall_BODY_mutex_destroy(smx_mutex_t mutex) {
1929     smx_process_t self = SIMIX_process_self();
1930
1931     /* Go to that function to follow the code flow through the simcall barrier */
1932     if (0) SIMIX_mutex_destroy(mutex);
1933     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1934
1935     self->simcall.call = SIMCALL_MUTEX_DESTROY;
1936     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1937     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1938     self->simcall.args[0].dp = (void*) mutex;
1939     if (self != simix_global->maestro_process) {
1940       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1941                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1942       SIMIX_process_yield(self);
1943     } else {
1944       SIMIX_simcall_handle(&self->simcall, 0);
1945     }
1946
1947   }
1948
1949 inline static void simcall_BODY_mutex_lock(smx_mutex_t mutex) {
1950     smx_process_t self = SIMIX_process_self();
1951
1952     /* Go to that function to follow the code flow through the simcall barrier */
1953     if (0) simcall_HANDLER_mutex_lock(&self->simcall, mutex);
1954     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1955
1956     self->simcall.call = SIMCALL_MUTEX_LOCK;
1957     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1958     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1959     self->simcall.args[0].dp = (void*) mutex;
1960     if (self != simix_global->maestro_process) {
1961       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1962                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1963       SIMIX_process_yield(self);
1964     } else {
1965       SIMIX_simcall_handle(&self->simcall, 0);
1966     }
1967
1968   }
1969
1970 inline static int simcall_BODY_mutex_trylock(smx_mutex_t mutex) {
1971     smx_process_t self = SIMIX_process_self();
1972
1973     /* Go to that function to follow the code flow through the simcall barrier */
1974     if (0) simcall_HANDLER_mutex_trylock(&self->simcall, mutex);
1975     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1976
1977     self->simcall.call = SIMCALL_MUTEX_TRYLOCK;
1978     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1979     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1980     self->simcall.args[0].dp = (void*) mutex;
1981     if (self != simix_global->maestro_process) {
1982       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1983                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1984       SIMIX_process_yield(self);
1985     } else {
1986       SIMIX_simcall_handle(&self->simcall, 0);
1987     }
1988     return self->simcall.result.i;
1989   }
1990
1991 inline static void simcall_BODY_mutex_unlock(smx_mutex_t mutex) {
1992     smx_process_t self = SIMIX_process_self();
1993
1994     /* Go to that function to follow the code flow through the simcall barrier */
1995     if (0) simcall_HANDLER_mutex_unlock(&self->simcall, mutex);
1996     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1997
1998     self->simcall.call = SIMCALL_MUTEX_UNLOCK;
1999     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2000     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2001     self->simcall.args[0].dp = (void*) mutex;
2002     if (self != simix_global->maestro_process) {
2003       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2004                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2005       SIMIX_process_yield(self);
2006     } else {
2007       SIMIX_simcall_handle(&self->simcall, 0);
2008     }
2009
2010   }
2011
2012 inline static smx_cond_t simcall_BODY_cond_init() {
2013     smx_process_t self = SIMIX_process_self();
2014
2015     /* Go to that function to follow the code flow through the simcall barrier */
2016     if (0) SIMIX_cond_init();
2017     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2018
2019     self->simcall.call = SIMCALL_COND_INIT;
2020     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2021     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2022
2023     if (self != simix_global->maestro_process) {
2024       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2025                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2026       SIMIX_process_yield(self);
2027     } else {
2028       SIMIX_simcall_handle(&self->simcall, 0);
2029     }
2030     return self->simcall.result.dp;
2031   }
2032
2033 inline static void simcall_BODY_cond_destroy(smx_cond_t cond) {
2034     smx_process_t self = SIMIX_process_self();
2035
2036     /* Go to that function to follow the code flow through the simcall barrier */
2037     if (0) SIMIX_cond_destroy(cond);
2038     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2039
2040     self->simcall.call = SIMCALL_COND_DESTROY;
2041     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2042     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2043     self->simcall.args[0].dp = (void*) cond;
2044     if (self != simix_global->maestro_process) {
2045       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2046                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2047       SIMIX_process_yield(self);
2048     } else {
2049       SIMIX_simcall_handle(&self->simcall, 0);
2050     }
2051
2052   }
2053
2054 inline static void simcall_BODY_cond_signal(smx_cond_t cond) {
2055     smx_process_t self = SIMIX_process_self();
2056
2057     /* Go to that function to follow the code flow through the simcall barrier */
2058     if (0) SIMIX_cond_signal(cond);
2059     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2060
2061     self->simcall.call = SIMCALL_COND_SIGNAL;
2062     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2063     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2064     self->simcall.args[0].dp = (void*) cond;
2065     if (self != simix_global->maestro_process) {
2066       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2067                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2068       SIMIX_process_yield(self);
2069     } else {
2070       SIMIX_simcall_handle(&self->simcall, 0);
2071     }
2072
2073   }
2074
2075 inline static void simcall_BODY_cond_wait(smx_cond_t cond, smx_mutex_t mutex) {
2076     smx_process_t self = SIMIX_process_self();
2077
2078     /* Go to that function to follow the code flow through the simcall barrier */
2079     if (0) simcall_HANDLER_cond_wait(&self->simcall, cond, mutex);
2080     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2081
2082     self->simcall.call = SIMCALL_COND_WAIT;
2083     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2084     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2085     self->simcall.args[0].dp = (void*) cond;
2086     self->simcall.args[1].dp = (void*) mutex;
2087     if (self != simix_global->maestro_process) {
2088       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2089                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2090       SIMIX_process_yield(self);
2091     } else {
2092       SIMIX_simcall_handle(&self->simcall, 0);
2093     }
2094
2095   }
2096
2097 inline static void simcall_BODY_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double timeout) {
2098     smx_process_t self = SIMIX_process_self();
2099
2100     /* Go to that function to follow the code flow through the simcall barrier */
2101     if (0) simcall_HANDLER_cond_wait_timeout(&self->simcall, cond, mutex, timeout);
2102     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2103
2104     self->simcall.call = SIMCALL_COND_WAIT_TIMEOUT;
2105     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2106     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2107     self->simcall.args[0].dp = (void*) cond;
2108     self->simcall.args[1].dp = (void*) mutex;
2109     self->simcall.args[2].d = (double) timeout;
2110     if (self != simix_global->maestro_process) {
2111       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2112                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2113       SIMIX_process_yield(self);
2114     } else {
2115       SIMIX_simcall_handle(&self->simcall, 0);
2116     }
2117
2118   }
2119
2120 inline static void simcall_BODY_cond_broadcast(smx_cond_t cond) {
2121     smx_process_t self = SIMIX_process_self();
2122
2123     /* Go to that function to follow the code flow through the simcall barrier */
2124     if (0) SIMIX_cond_broadcast(cond);
2125     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2126
2127     self->simcall.call = SIMCALL_COND_BROADCAST;
2128     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2129     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2130     self->simcall.args[0].dp = (void*) cond;
2131     if (self != simix_global->maestro_process) {
2132       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2133                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2134       SIMIX_process_yield(self);
2135     } else {
2136       SIMIX_simcall_handle(&self->simcall, 0);
2137     }
2138
2139   }
2140
2141 inline static smx_sem_t simcall_BODY_sem_init(unsigned int capacity) {
2142     smx_process_t self = SIMIX_process_self();
2143
2144     /* Go to that function to follow the code flow through the simcall barrier */
2145     if (0) SIMIX_sem_init(capacity);
2146     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2147
2148     self->simcall.call = SIMCALL_SEM_INIT;
2149     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2150     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2151     self->simcall.args[0].ui = (unsigned int) capacity;
2152     if (self != simix_global->maestro_process) {
2153       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2154                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2155       SIMIX_process_yield(self);
2156     } else {
2157       SIMIX_simcall_handle(&self->simcall, 0);
2158     }
2159     return self->simcall.result.dp;
2160   }
2161
2162 inline static void simcall_BODY_sem_destroy(smx_sem_t sem) {
2163     smx_process_t self = SIMIX_process_self();
2164
2165     /* Go to that function to follow the code flow through the simcall barrier */
2166     if (0) SIMIX_sem_destroy(sem);
2167     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2168
2169     self->simcall.call = SIMCALL_SEM_DESTROY;
2170     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2171     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2172     self->simcall.args[0].dp = (void*) sem;
2173     if (self != simix_global->maestro_process) {
2174       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2175                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2176       SIMIX_process_yield(self);
2177     } else {
2178       SIMIX_simcall_handle(&self->simcall, 0);
2179     }
2180
2181   }
2182
2183 inline static void simcall_BODY_sem_release(smx_sem_t sem) {
2184     smx_process_t self = SIMIX_process_self();
2185
2186     /* Go to that function to follow the code flow through the simcall barrier */
2187     if (0) simcall_HANDLER_sem_release(&self->simcall, sem);
2188     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2189
2190     self->simcall.call = SIMCALL_SEM_RELEASE;
2191     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2192     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2193     self->simcall.args[0].dp = (void*) sem;
2194     if (self != simix_global->maestro_process) {
2195       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2196                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2197       SIMIX_process_yield(self);
2198     } else {
2199       SIMIX_simcall_handle(&self->simcall, 0);
2200     }
2201
2202   }
2203
2204 inline static int simcall_BODY_sem_would_block(smx_sem_t sem) {
2205     smx_process_t self = SIMIX_process_self();
2206
2207     /* Go to that function to follow the code flow through the simcall barrier */
2208     if (0) simcall_HANDLER_sem_would_block(&self->simcall, sem);
2209     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2210
2211     self->simcall.call = SIMCALL_SEM_WOULD_BLOCK;
2212     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2213     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2214     self->simcall.args[0].dp = (void*) sem;
2215     if (self != simix_global->maestro_process) {
2216       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2217                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2218       SIMIX_process_yield(self);
2219     } else {
2220       SIMIX_simcall_handle(&self->simcall, 0);
2221     }
2222     return self->simcall.result.i;
2223   }
2224
2225 inline static void simcall_BODY_sem_acquire(smx_sem_t sem) {
2226     smx_process_t self = SIMIX_process_self();
2227
2228     /* Go to that function to follow the code flow through the simcall barrier */
2229     if (0) simcall_HANDLER_sem_acquire(&self->simcall, sem);
2230     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2231
2232     self->simcall.call = SIMCALL_SEM_ACQUIRE;
2233     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2234     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2235     self->simcall.args[0].dp = (void*) sem;
2236     if (self != simix_global->maestro_process) {
2237       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2238                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2239       SIMIX_process_yield(self);
2240     } else {
2241       SIMIX_simcall_handle(&self->simcall, 0);
2242     }
2243
2244   }
2245
2246 inline static void simcall_BODY_sem_acquire_timeout(smx_sem_t sem, double timeout) {
2247     smx_process_t self = SIMIX_process_self();
2248
2249     /* Go to that function to follow the code flow through the simcall barrier */
2250     if (0) simcall_HANDLER_sem_acquire_timeout(&self->simcall, sem, timeout);
2251     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2252
2253     self->simcall.call = SIMCALL_SEM_ACQUIRE_TIMEOUT;
2254     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2255     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2256     self->simcall.args[0].dp = (void*) sem;
2257     self->simcall.args[1].d = (double) timeout;
2258     if (self != simix_global->maestro_process) {
2259       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2260                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2261       SIMIX_process_yield(self);
2262     } else {
2263       SIMIX_simcall_handle(&self->simcall, 0);
2264     }
2265
2266   }
2267
2268 inline static int simcall_BODY_sem_get_capacity(smx_sem_t sem) {
2269     smx_process_t self = SIMIX_process_self();
2270
2271     /* Go to that function to follow the code flow through the simcall barrier */
2272     if (0) simcall_HANDLER_sem_get_capacity(&self->simcall, sem);
2273     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2274
2275     self->simcall.call = SIMCALL_SEM_GET_CAPACITY;
2276     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2277     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2278     self->simcall.args[0].dp = (void*) sem;
2279     if (self != simix_global->maestro_process) {
2280       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2281                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2282       SIMIX_process_yield(self);
2283     } else {
2284       SIMIX_simcall_handle(&self->simcall, 0);
2285     }
2286     return self->simcall.result.i;
2287   }
2288
2289 inline static sg_size_t simcall_BODY_file_read(smx_file_t fd, sg_size_t size, smx_host_t host) {
2290     smx_process_t self = SIMIX_process_self();
2291
2292     /* Go to that function to follow the code flow through the simcall barrier */
2293     if (0) simcall_HANDLER_file_read(&self->simcall, fd, size, host);
2294     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2295
2296     self->simcall.call = SIMCALL_FILE_READ;
2297     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2298     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2299     self->simcall.args[0].dp = (void*) fd;
2300     self->simcall.args[1].sgsz = (sg_size_t) size;
2301     self->simcall.args[2].dp = (void*) host;
2302     if (self != simix_global->maestro_process) {
2303       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2304                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2305       SIMIX_process_yield(self);
2306     } else {
2307       SIMIX_simcall_handle(&self->simcall, 0);
2308     }
2309     return self->simcall.result.sgsz;
2310   }
2311
2312 inline static sg_size_t simcall_BODY_file_write(smx_file_t fd, sg_size_t size, smx_host_t host) {
2313     smx_process_t self = SIMIX_process_self();
2314
2315     /* Go to that function to follow the code flow through the simcall barrier */
2316     if (0) simcall_HANDLER_file_write(&self->simcall, fd, size, host);
2317     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2318
2319     self->simcall.call = SIMCALL_FILE_WRITE;
2320     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2321     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2322     self->simcall.args[0].dp = (void*) fd;
2323     self->simcall.args[1].sgsz = (sg_size_t) size;
2324     self->simcall.args[2].dp = (void*) host;
2325     if (self != simix_global->maestro_process) {
2326       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2327                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2328       SIMIX_process_yield(self);
2329     } else {
2330       SIMIX_simcall_handle(&self->simcall, 0);
2331     }
2332     return self->simcall.result.sgsz;
2333   }
2334
2335 inline static smx_file_t simcall_BODY_file_open(const char* fullpath, smx_host_t host) {
2336     smx_process_t self = SIMIX_process_self();
2337
2338     /* Go to that function to follow the code flow through the simcall barrier */
2339     if (0) simcall_HANDLER_file_open(&self->simcall, fullpath, host);
2340     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2341
2342     self->simcall.call = SIMCALL_FILE_OPEN;
2343     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2344     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2345     self->simcall.args[0].cc = (const char*) fullpath;
2346     self->simcall.args[1].dp = (void*) host;
2347     if (self != simix_global->maestro_process) {
2348       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2349                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2350       SIMIX_process_yield(self);
2351     } else {
2352       SIMIX_simcall_handle(&self->simcall, 0);
2353     }
2354     return self->simcall.result.dp;
2355   }
2356
2357 inline static int simcall_BODY_file_close(smx_file_t fd, smx_host_t host) {
2358     smx_process_t self = SIMIX_process_self();
2359
2360     /* Go to that function to follow the code flow through the simcall barrier */
2361     if (0) simcall_HANDLER_file_close(&self->simcall, fd, host);
2362     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2363
2364     self->simcall.call = SIMCALL_FILE_CLOSE;
2365     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2366     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2367     self->simcall.args[0].dp = (void*) fd;
2368     self->simcall.args[1].dp = (void*) host;
2369     if (self != simix_global->maestro_process) {
2370       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2371                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2372       SIMIX_process_yield(self);
2373     } else {
2374       SIMIX_simcall_handle(&self->simcall, 0);
2375     }
2376     return self->simcall.result.i;
2377   }
2378
2379 inline static int simcall_BODY_file_unlink(smx_file_t fd, smx_host_t host) {
2380     smx_process_t self = SIMIX_process_self();
2381
2382     /* Go to that function to follow the code flow through the simcall barrier */
2383     if (0) SIMIX_file_unlink(fd, host);
2384     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2385
2386     self->simcall.call = SIMCALL_FILE_UNLINK;
2387     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2388     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2389     self->simcall.args[0].dp = (void*) fd;
2390     self->simcall.args[1].dp = (void*) host;
2391     if (self != simix_global->maestro_process) {
2392       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2393                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2394       SIMIX_process_yield(self);
2395     } else {
2396       SIMIX_simcall_handle(&self->simcall, 0);
2397     }
2398     return self->simcall.result.i;
2399   }
2400
2401 inline static sg_size_t simcall_BODY_file_get_size(smx_file_t fd) {
2402     smx_process_t self = SIMIX_process_self();
2403
2404     /* Go to that function to follow the code flow through the simcall barrier */
2405     if (0) simcall_HANDLER_file_get_size(&self->simcall, fd);
2406     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2407
2408     self->simcall.call = SIMCALL_FILE_GET_SIZE;
2409     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2410     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2411     self->simcall.args[0].dp = (void*) fd;
2412     if (self != simix_global->maestro_process) {
2413       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2414                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2415       SIMIX_process_yield(self);
2416     } else {
2417       SIMIX_simcall_handle(&self->simcall, 0);
2418     }
2419     return self->simcall.result.sgsz;
2420   }
2421
2422 inline static sg_size_t simcall_BODY_file_tell(smx_file_t fd) {
2423     smx_process_t self = SIMIX_process_self();
2424
2425     /* Go to that function to follow the code flow through the simcall barrier */
2426     if (0) simcall_HANDLER_file_tell(&self->simcall, fd);
2427     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2428
2429     self->simcall.call = SIMCALL_FILE_TELL;
2430     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2431     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2432     self->simcall.args[0].dp = (void*) fd;
2433     if (self != simix_global->maestro_process) {
2434       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2435                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2436       SIMIX_process_yield(self);
2437     } else {
2438       SIMIX_simcall_handle(&self->simcall, 0);
2439     }
2440     return self->simcall.result.sgsz;
2441   }
2442
2443 inline static int simcall_BODY_file_seek(smx_file_t fd, sg_offset_t offset, int origin) {
2444     smx_process_t self = SIMIX_process_self();
2445
2446     /* Go to that function to follow the code flow through the simcall barrier */
2447     if (0) simcall_HANDLER_file_seek(&self->simcall, fd, offset, origin);
2448     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2449
2450     self->simcall.call = SIMCALL_FILE_SEEK;
2451     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2452     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2453     self->simcall.args[0].dp = (void*) fd;
2454     self->simcall.args[1].sgoff = (sg_offset_t) offset;
2455     self->simcall.args[2].i = (int) origin;
2456     if (self != simix_global->maestro_process) {
2457       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2458                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2459       SIMIX_process_yield(self);
2460     } else {
2461       SIMIX_simcall_handle(&self->simcall, 0);
2462     }
2463     return self->simcall.result.i;
2464   }
2465
2466 inline static xbt_dynar_t simcall_BODY_file_get_info(smx_file_t fd) {
2467     smx_process_t self = SIMIX_process_self();
2468
2469     /* Go to that function to follow the code flow through the simcall barrier */
2470     if (0) simcall_HANDLER_file_get_info(&self->simcall, fd);
2471     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2472
2473     self->simcall.call = SIMCALL_FILE_GET_INFO;
2474     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2475     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2476     self->simcall.args[0].dp = (void*) fd;
2477     if (self != simix_global->maestro_process) {
2478       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2479                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2480       SIMIX_process_yield(self);
2481     } else {
2482       SIMIX_simcall_handle(&self->simcall, 0);
2483     }
2484     return self->simcall.result.dp;
2485   }
2486
2487 inline static int simcall_BODY_file_move(smx_file_t fd, const char* fullpath) {
2488     smx_process_t self = SIMIX_process_self();
2489
2490     /* Go to that function to follow the code flow through the simcall barrier */
2491     if (0) simcall_HANDLER_file_move(&self->simcall, fd, fullpath);
2492     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2493
2494     self->simcall.call = SIMCALL_FILE_MOVE;
2495     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2496     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2497     self->simcall.args[0].dp = (void*) fd;
2498     self->simcall.args[1].cc = (const char*) fullpath;
2499     if (self != simix_global->maestro_process) {
2500       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2501                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2502       SIMIX_process_yield(self);
2503     } else {
2504       SIMIX_simcall_handle(&self->simcall, 0);
2505     }
2506     return self->simcall.result.i;
2507   }
2508
2509 inline static sg_size_t simcall_BODY_storage_get_free_size(smx_storage_t storage) {
2510     smx_process_t self = SIMIX_process_self();
2511
2512     /* Go to that function to follow the code flow through the simcall barrier */
2513     if (0) simcall_HANDLER_storage_get_free_size(&self->simcall, storage);
2514     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2515
2516     self->simcall.call = SIMCALL_STORAGE_GET_FREE_SIZE;
2517     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2518     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2519     self->simcall.args[0].dp = (void*) storage;
2520     if (self != simix_global->maestro_process) {
2521       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2522                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2523       SIMIX_process_yield(self);
2524     } else {
2525       SIMIX_simcall_handle(&self->simcall, 0);
2526     }
2527     return self->simcall.result.sgsz;
2528   }
2529
2530 inline static sg_size_t simcall_BODY_storage_get_used_size(smx_storage_t name) {
2531     smx_process_t self = SIMIX_process_self();
2532
2533     /* Go to that function to follow the code flow through the simcall barrier */
2534     if (0) simcall_HANDLER_storage_get_used_size(&self->simcall, name);
2535     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2536
2537     self->simcall.call = SIMCALL_STORAGE_GET_USED_SIZE;
2538     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2539     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2540     self->simcall.args[0].dp = (void*) name;
2541     if (self != simix_global->maestro_process) {
2542       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2543                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2544       SIMIX_process_yield(self);
2545     } else {
2546       SIMIX_simcall_handle(&self->simcall, 0);
2547     }
2548     return self->simcall.result.sgsz;
2549   }
2550
2551 inline static xbt_dict_t simcall_BODY_storage_get_properties(smx_storage_t storage) {
2552     smx_process_t self = SIMIX_process_self();
2553
2554     /* Go to that function to follow the code flow through the simcall barrier */
2555     if (0) SIMIX_storage_get_properties(storage);
2556     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2557
2558     self->simcall.call = SIMCALL_STORAGE_GET_PROPERTIES;
2559     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2560     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2561     self->simcall.args[0].dp = (void*) storage;
2562     if (self != simix_global->maestro_process) {
2563       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2564                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2565       SIMIX_process_yield(self);
2566     } else {
2567       SIMIX_simcall_handle(&self->simcall, 0);
2568     }
2569     return self->simcall.result.dp;
2570   }
2571
2572 inline static xbt_dict_t simcall_BODY_storage_get_content(smx_storage_t storage) {
2573     smx_process_t self = SIMIX_process_self();
2574
2575     /* Go to that function to follow the code flow through the simcall barrier */
2576     if (0) SIMIX_storage_get_content(storage);
2577     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2578
2579     self->simcall.call = SIMCALL_STORAGE_GET_CONTENT;
2580     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2581     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2582     self->simcall.args[0].dp = (void*) storage;
2583     if (self != simix_global->maestro_process) {
2584       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2585                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2586       SIMIX_process_yield(self);
2587     } else {
2588       SIMIX_simcall_handle(&self->simcall, 0);
2589     }
2590     return self->simcall.result.dp;
2591   }
2592
2593 inline static xbt_dict_t simcall_BODY_asr_get_properties(const char* name) {
2594     smx_process_t self = SIMIX_process_self();
2595
2596     /* Go to that function to follow the code flow through the simcall barrier */
2597     if (0) simcall_HANDLER_asr_get_properties(&self->simcall, name);
2598     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2599
2600     self->simcall.call = SIMCALL_ASR_GET_PROPERTIES;
2601     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2602     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2603     self->simcall.args[0].cc = (const char*) name;
2604     if (self != simix_global->maestro_process) {
2605       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2606                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2607       SIMIX_process_yield(self);
2608     } else {
2609       SIMIX_simcall_handle(&self->simcall, 0);
2610     }
2611     return self->simcall.result.dp;
2612   }
2613
2614 inline static int simcall_BODY_mc_random(int min, int max) {
2615     smx_process_t self = SIMIX_process_self();
2616
2617     /* Go to that function to follow the code flow through the simcall barrier */
2618     if (0) simcall_HANDLER_mc_random(&self->simcall, min, max);
2619     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2620
2621     self->simcall.call = SIMCALL_MC_RANDOM;
2622     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2623     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2624     self->simcall.args[0].i = (int) min;
2625     self->simcall.args[1].i = (int) max;
2626     if (self != simix_global->maestro_process) {
2627       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2628                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2629       SIMIX_process_yield(self);
2630     } else {
2631       SIMIX_simcall_handle(&self->simcall, 0);
2632     }
2633     return self->simcall.result.i;
2634   }
2635
2636 inline static void simcall_BODY_set_category(smx_synchro_t synchro, const char* category) {
2637     smx_process_t self = SIMIX_process_self();
2638
2639     /* Go to that function to follow the code flow through the simcall barrier */
2640     if (0) SIMIX_set_category(synchro, category);
2641     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2642
2643     self->simcall.call = SIMCALL_SET_CATEGORY;
2644     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2645     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2646     self->simcall.args[0].dp = (void*) synchro;
2647     self->simcall.args[1].cc = (const char*) category;
2648     if (self != simix_global->maestro_process) {
2649       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2650                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2651       SIMIX_process_yield(self);
2652     } else {
2653       SIMIX_simcall_handle(&self->simcall, 0);
2654     }
2655
2656   }
2657 #ifdef HAVE_LATENCY_BOUND_TRACKING
2658
2659 inline static int simcall_BODY_comm_is_latency_bounded(smx_synchro_t comm) {
2660     smx_process_t self = SIMIX_process_self();
2661
2662     /* Go to that function to follow the code flow through the simcall barrier */
2663     if (0) SIMIX_comm_is_latency_bounded(comm);
2664     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2665
2666     self->simcall.call = SIMCALL_COMM_IS_LATENCY_BOUNDED;
2667     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2668     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2669     self->simcall.args[0].dp = (void*) comm;
2670     if (self != simix_global->maestro_process) {
2671       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2672                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2673       SIMIX_process_yield(self);
2674     } else {
2675       SIMIX_simcall_handle(&self->simcall, 0);
2676     }
2677     return self->simcall.result.i;
2678   }
2679 #endif
2680
2681 #ifdef HAVE_MC
2682
2683 inline static mc_snapshot_t simcall_BODY_mc_snapshot() {
2684     smx_process_t self = SIMIX_process_self();
2685
2686     /* Go to that function to follow the code flow through the simcall barrier */
2687     if (0) simcall_HANDLER_mc_snapshot(&self->simcall);
2688     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2689
2690     self->simcall.call = SIMCALL_MC_SNAPSHOT;
2691     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2692     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2693
2694     if (self != simix_global->maestro_process) {
2695       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2696                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2697       SIMIX_process_yield(self);
2698     } else {
2699       SIMIX_simcall_handle(&self->simcall, 0);
2700     }
2701     return self->simcall.result.dp;
2702   }
2703
2704 inline static int simcall_BODY_mc_compare_snapshots(mc_snapshot_t s1, mc_snapshot_t s2) {
2705     smx_process_t self = SIMIX_process_self();
2706
2707     /* Go to that function to follow the code flow through the simcall barrier */
2708     if (0) simcall_HANDLER_mc_compare_snapshots(&self->simcall, s1, s2);
2709     /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2710
2711     self->simcall.call = SIMCALL_MC_COMPARE_SNAPSHOTS;
2712     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2713     memset(self->simcall.args, 0, sizeof(self->simcall.args));
2714     self->simcall.args[0].dp = (void*) s1;
2715     self->simcall.args[1].dp = (void*) s2;
2716     if (self != simix_global->maestro_process) {
2717       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2718                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2719       SIMIX_process_yield(self);
2720     } else {
2721       SIMIX_simcall_handle(&self->simcall, 0);
2722     }
2723     return self->simcall.result.i;
2724   }
2725 #endif