src/simix/simcalls_generated_body.c

   1 /*********************************************
   2  * File Generated by src/simix/simcalls.py   *
   3  *                from src/simix/simcalls.in *
   4  * Do not modify this file, add new simcalls *
   5  * in src/simix/simcalls.in                  *
   6  *********************************************/
   7
   8   inline static smx_host_t simcall_BODY_host_get_by_name(const char* name) {
   9     smx_process_t self = SIMIX_process_self();
  10     self->simcall.call = SIMCALL_HOST_GET_BY_NAME;
  11     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
  12     memset(self->simcall.args, 0, sizeof(self->simcall.args));
  13     self->simcall.args[0].cc = (const char*) name;
  14     if (self != simix_global->maestro_process) {
  15       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
  16                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
  17       SIMIX_process_yield(self);
  18     } else {
  19       SIMIX_simcall_pre(&self->simcall, 0);
  20     }
  21     return self->simcall.result.dp;
  22   }
  23   inline static const char* simcall_BODY_host_get_name(smx_host_t host) {
  24     smx_process_t self = SIMIX_process_self();
  25     self->simcall.call = SIMCALL_HOST_GET_NAME;
  26     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
  27     memset(self->simcall.args, 0, sizeof(self->simcall.args));
  28     self->simcall.args[0].dp = (void*) host;
  29     if (self != simix_global->maestro_process) {
  30       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
  31                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
  32       SIMIX_process_yield(self);
  33     } else {
  34       SIMIX_simcall_pre(&self->simcall, 0);
  35     }
  36     return self->simcall.result.cc;
  37   }
  38   inline static void simcall_BODY_host_on(smx_host_t host) {
  39     smx_process_t self = SIMIX_process_self();
  40     self->simcall.call = SIMCALL_HOST_ON;
  41     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
  42     memset(self->simcall.args, 0, sizeof(self->simcall.args));
  43     self->simcall.args[0].dp = (void*) host;
  44     if (self != simix_global->maestro_process) {
  45       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
  46                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
  47       SIMIX_process_yield(self);
  48     } else {
  49       SIMIX_simcall_pre(&self->simcall, 0);
  50     }
  51
  52   }
  53   inline static void simcall_BODY_host_off(smx_host_t host) {
  54     smx_process_t self = SIMIX_process_self();
  55     self->simcall.call = SIMCALL_HOST_OFF;
  56     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
  57     memset(self->simcall.args, 0, sizeof(self->simcall.args));
  58     self->simcall.args[0].dp = (void*) host;
  59     if (self != simix_global->maestro_process) {
  60       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
  61                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
  62       SIMIX_process_yield(self);
  63     } else {
  64       SIMIX_simcall_pre(&self->simcall, 0);
  65     }
  66
  67   }
  68   inline static xbt_dict_t simcall_BODY_host_get_properties(smx_host_t host) {
  69     smx_process_t self = SIMIX_process_self();
  70     self->simcall.call = SIMCALL_HOST_GET_PROPERTIES;
  71     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
  72     memset(self->simcall.args, 0, sizeof(self->simcall.args));
  73     self->simcall.args[0].dp = (void*) host;
  74     if (self != simix_global->maestro_process) {
  75       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
  76                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
  77       SIMIX_process_yield(self);
  78     } else {
  79       SIMIX_simcall_pre(&self->simcall, 0);
  80     }
  81     return self->simcall.result.dp;
  82   }
  83   inline static int simcall_BODY_host_get_core(smx_host_t host) {
  84     smx_process_t self = SIMIX_process_self();
  85     self->simcall.call = SIMCALL_HOST_GET_CORE;
  86     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
  87     memset(self->simcall.args, 0, sizeof(self->simcall.args));
  88     self->simcall.args[0].dp = (void*) host;
  89     if (self != simix_global->maestro_process) {
  90       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
  91                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
  92       SIMIX_process_yield(self);
  93     } else {
  94       SIMIX_simcall_pre(&self->simcall, 0);
  95     }
  96     return self->simcall.result.i;
  97   }
  98   inline static xbt_swag_t simcall_BODY_host_get_process_list(smx_host_t host) {
  99     smx_process_t self = SIMIX_process_self();
 100     self->simcall.call = SIMCALL_HOST_GET_PROCESS_LIST;
 101     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 102     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 103     self->simcall.args[0].dp = (void*) host;
 104     if (self != simix_global->maestro_process) {
 105       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 106                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 107       SIMIX_process_yield(self);
 108     } else {
 109       SIMIX_simcall_pre(&self->simcall, 0);
 110     }
 111     return self->simcall.result.dp;
 112   }
 113   inline static double simcall_BODY_host_get_speed(smx_host_t host) {
 114     smx_process_t self = SIMIX_process_self();
 115     self->simcall.call = SIMCALL_HOST_GET_SPEED;
 116     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 117     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 118     self->simcall.args[0].dp = (void*) host;
 119     if (self != simix_global->maestro_process) {
 120       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 121                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 122       SIMIX_process_yield(self);
 123     } else {
 124       SIMIX_simcall_pre(&self->simcall, 0);
 125     }
 126     return self->simcall.result.d;
 127   }
 128   inline static double simcall_BODY_host_get_available_speed(smx_host_t host) {
 129     smx_process_t self = SIMIX_process_self();
 130     self->simcall.call = SIMCALL_HOST_GET_AVAILABLE_SPEED;
 131     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 132     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 133     self->simcall.args[0].dp = (void*) host;
 134     if (self != simix_global->maestro_process) {
 135       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 136                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 137       SIMIX_process_yield(self);
 138     } else {
 139       SIMIX_simcall_pre(&self->simcall, 0);
 140     }
 141     return self->simcall.result.d;
 142   }
 143   inline static int simcall_BODY_host_get_state(smx_host_t host) {
 144     smx_process_t self = SIMIX_process_self();
 145     self->simcall.call = SIMCALL_HOST_GET_STATE;
 146     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 147     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 148     self->simcall.args[0].dp = (void*) host;
 149     if (self != simix_global->maestro_process) {
 150       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 151                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 152       SIMIX_process_yield(self);
 153     } else {
 154       SIMIX_simcall_pre(&self->simcall, 0);
 155     }
 156     return self->simcall.result.i;
 157   }
 158   inline static double simcall_BODY_host_get_current_power_peak(smx_host_t host) {
 159     smx_process_t self = SIMIX_process_self();
 160     self->simcall.call = SIMCALL_HOST_GET_CURRENT_POWER_PEAK;
 161     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 162     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 163     self->simcall.args[0].dp = (void*) host;
 164     if (self != simix_global->maestro_process) {
 165       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 166                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 167       SIMIX_process_yield(self);
 168     } else {
 169       SIMIX_simcall_pre(&self->simcall, 0);
 170     }
 171     return self->simcall.result.d;
 172   }
 173   inline static double simcall_BODY_host_get_power_peak_at(smx_host_t host, int pstate_index) {
 174     smx_process_t self = SIMIX_process_self();
 175     self->simcall.call = SIMCALL_HOST_GET_POWER_PEAK_AT;
 176     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 177     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 178     self->simcall.args[0].dp = (void*) host;
 179     self->simcall.args[1].i = (int) pstate_index;
 180     if (self != simix_global->maestro_process) {
 181       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 182                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 183       SIMIX_process_yield(self);
 184     } else {
 185       SIMIX_simcall_pre(&self->simcall, 0);
 186     }
 187     return self->simcall.result.d;
 188   }
 189   inline static int simcall_BODY_host_get_nb_pstates(smx_host_t host) {
 190     smx_process_t self = SIMIX_process_self();
 191     self->simcall.call = SIMCALL_HOST_GET_NB_PSTATES;
 192     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 193     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 194     self->simcall.args[0].dp = (void*) host;
 195     if (self != simix_global->maestro_process) {
 196       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 197                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 198       SIMIX_process_yield(self);
 199     } else {
 200       SIMIX_simcall_pre(&self->simcall, 0);
 201     }
 202     return self->simcall.result.i;
 203   }
 204   inline static void simcall_BODY_host_set_power_peak_at(smx_host_t host, int pstate_index) {
 205     smx_process_t self = SIMIX_process_self();
 206     self->simcall.call = SIMCALL_HOST_SET_POWER_PEAK_AT;
 207     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 208     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 209     self->simcall.args[0].dp = (void*) host;
 210     self->simcall.args[1].i = (int) pstate_index;
 211     if (self != simix_global->maestro_process) {
 212       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 213                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 214       SIMIX_process_yield(self);
 215     } else {
 216       SIMIX_simcall_pre(&self->simcall, 0);
 217     }
 218
 219   }
 220   inline static double simcall_BODY_host_get_consumed_energy(smx_host_t host) {
 221     smx_process_t self = SIMIX_process_self();
 222     self->simcall.call = SIMCALL_HOST_GET_CONSUMED_ENERGY;
 223     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 224     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 225     self->simcall.args[0].dp = (void*) host;
 226     if (self != simix_global->maestro_process) {
 227       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 228                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 229       SIMIX_process_yield(self);
 230     } else {
 231       SIMIX_simcall_pre(&self->simcall, 0);
 232     }
 233     return self->simcall.result.d;
 234   }
 235   inline static smx_action_t simcall_BODY_host_execute(const char* name, smx_host_t host, double computation_amount, double priority, double bound, unsigned long affinity_mask) {
 236     smx_process_t self = SIMIX_process_self();
 237     self->simcall.call = SIMCALL_HOST_EXECUTE;
 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].cc = (const char*) name;
 241     self->simcall.args[1].dp = (void*) host;
 242     self->simcall.args[2].d = (double) computation_amount;
 243     self->simcall.args[3].d = (double) priority;
 244     self->simcall.args[4].d = (double) bound;
 245     self->simcall.args[5].ul = (unsigned long) affinity_mask;
 246     if (self != simix_global->maestro_process) {
 247       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 248                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 249       SIMIX_process_yield(self);
 250     } else {
 251       SIMIX_simcall_pre(&self->simcall, 0);
 252     }
 253     return self->simcall.result.dp;
 254   }
 255   inline static smx_action_t simcall_BODY_host_parallel_execute(const char* name, int host_nb, smx_host_t* host_list, double* computation_amount, double* communication_amount, double amount, double rate) {
 256     smx_process_t self = SIMIX_process_self();
 257     self->simcall.call = SIMCALL_HOST_PARALLEL_EXECUTE;
 258     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 259     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 260     self->simcall.args[0].cc = (const char*) name;
 261     self->simcall.args[1].i = (int) host_nb;
 262     self->simcall.args[2].dp = (void*) host_list;
 263     self->simcall.args[3].dp = (void*) computation_amount;
 264     self->simcall.args[4].dp = (void*) communication_amount;
 265     self->simcall.args[5].d = (double) amount;
 266     self->simcall.args[6].d = (double) rate;
 267     if (self != simix_global->maestro_process) {
 268       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 269                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 270       SIMIX_process_yield(self);
 271     } else {
 272       SIMIX_simcall_pre(&self->simcall, 0);
 273     }
 274     return self->simcall.result.dp;
 275   }
 276   inline static void simcall_BODY_host_execution_destroy(smx_action_t execution) {
 277     smx_process_t self = SIMIX_process_self();
 278     self->simcall.call = SIMCALL_HOST_EXECUTION_DESTROY;
 279     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 280     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 281     self->simcall.args[0].dp = (void*) execution;
 282     if (self != simix_global->maestro_process) {
 283       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 284                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 285       SIMIX_process_yield(self);
 286     } else {
 287       SIMIX_simcall_pre(&self->simcall, 0);
 288     }
 289
 290   }
 291   inline static void simcall_BODY_host_execution_cancel(smx_action_t execution) {
 292     smx_process_t self = SIMIX_process_self();
 293     self->simcall.call = SIMCALL_HOST_EXECUTION_CANCEL;
 294     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 295     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 296     self->simcall.args[0].dp = (void*) execution;
 297     if (self != simix_global->maestro_process) {
 298       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 299                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 300       SIMIX_process_yield(self);
 301     } else {
 302       SIMIX_simcall_pre(&self->simcall, 0);
 303     }
 304
 305   }
 306   inline static double simcall_BODY_host_execution_get_remains(smx_action_t execution) {
 307     smx_process_t self = SIMIX_process_self();
 308     self->simcall.call = SIMCALL_HOST_EXECUTION_GET_REMAINS;
 309     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 310     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 311     self->simcall.args[0].dp = (void*) execution;
 312     if (self != simix_global->maestro_process) {
 313       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 314                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 315       SIMIX_process_yield(self);
 316     } else {
 317       SIMIX_simcall_pre(&self->simcall, 0);
 318     }
 319     return self->simcall.result.d;
 320   }
 321   inline static int simcall_BODY_host_execution_get_state(smx_action_t execution) {
 322     smx_process_t self = SIMIX_process_self();
 323     self->simcall.call = SIMCALL_HOST_EXECUTION_GET_STATE;
 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*) execution;
 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_pre(&self->simcall, 0);
 333     }
 334     return self->simcall.result.i;
 335   }
 336   inline static void simcall_BODY_host_execution_set_priority(smx_action_t execution, double priority) {
 337     smx_process_t self = SIMIX_process_self();
 338     self->simcall.call = SIMCALL_HOST_EXECUTION_SET_PRIORITY;
 339     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 340     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 341     self->simcall.args[0].dp = (void*) execution;
 342     self->simcall.args[1].d = (double) priority;
 343     if (self != simix_global->maestro_process) {
 344       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 345                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 346       SIMIX_process_yield(self);
 347     } else {
 348       SIMIX_simcall_pre(&self->simcall, 0);
 349     }
 350
 351   }
 352   inline static void simcall_BODY_host_execution_set_bound(smx_action_t execution, double bound) {
 353     smx_process_t self = SIMIX_process_self();
 354     self->simcall.call = SIMCALL_HOST_EXECUTION_SET_BOUND;
 355     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 356     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 357     self->simcall.args[0].dp = (void*) execution;
 358     self->simcall.args[1].d = (double) bound;
 359     if (self != simix_global->maestro_process) {
 360       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 361                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 362       SIMIX_process_yield(self);
 363     } else {
 364       SIMIX_simcall_pre(&self->simcall, 0);
 365     }
 366
 367   }
 368   inline static void simcall_BODY_host_execution_set_affinity(smx_action_t execution, smx_host_t ws, unsigned long mask) {
 369     smx_process_t self = SIMIX_process_self();
 370     self->simcall.call = SIMCALL_HOST_EXECUTION_SET_AFFINITY;
 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].dp = (void*) execution;
 374     self->simcall.args[1].dp = (void*) ws;
 375     self->simcall.args[2].ul = (unsigned long) mask;
 376     if (self != simix_global->maestro_process) {
 377       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 378                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 379       SIMIX_process_yield(self);
 380     } else {
 381       SIMIX_simcall_pre(&self->simcall, 0);
 382     }
 383
 384   }
 385   inline static int simcall_BODY_host_execution_wait(smx_action_t execution) {
 386     smx_process_t self = SIMIX_process_self();
 387     self->simcall.call = SIMCALL_HOST_EXECUTION_WAIT;
 388     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 389     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 390     self->simcall.args[0].dp = (void*) execution;
 391     if (self != simix_global->maestro_process) {
 392       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 393                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 394       SIMIX_process_yield(self);
 395     } else {
 396       SIMIX_simcall_pre(&self->simcall, 0);
 397     }
 398     return self->simcall.result.i;
 399   }
 400   inline static xbt_dict_t simcall_BODY_host_get_mounted_storage_list(smx_host_t host) {
 401     smx_process_t self = SIMIX_process_self();
 402     self->simcall.call = SIMCALL_HOST_GET_MOUNTED_STORAGE_LIST;
 403     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 404     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 405     self->simcall.args[0].dp = (void*) host;
 406     if (self != simix_global->maestro_process) {
 407       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 408                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 409       SIMIX_process_yield(self);
 410     } else {
 411       SIMIX_simcall_pre(&self->simcall, 0);
 412     }
 413     return self->simcall.result.dp;
 414   }
 415   inline static xbt_dynar_t simcall_BODY_host_get_attached_storage_list(smx_host_t host) {
 416     smx_process_t self = SIMIX_process_self();
 417     self->simcall.call = SIMCALL_HOST_GET_ATTACHED_STORAGE_LIST;
 418     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 419     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 420     self->simcall.args[0].dp = (void*) host;
 421     if (self != simix_global->maestro_process) {
 422       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 423                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 424       SIMIX_process_yield(self);
 425     } else {
 426       SIMIX_simcall_pre(&self->simcall, 0);
 427     }
 428     return self->simcall.result.dp;
 429   }
 430   inline static void simcall_BODY_host_get_params(smx_host_t ind_vm, ws_params_t params) {
 431     smx_process_t self = SIMIX_process_self();
 432     self->simcall.call = SIMCALL_HOST_GET_PARAMS;
 433     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 434     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 435     self->simcall.args[0].dp = (void*) ind_vm;
 436     self->simcall.args[1].dp = (void*) params;
 437     if (self != simix_global->maestro_process) {
 438       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 439                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 440       SIMIX_process_yield(self);
 441     } else {
 442       SIMIX_simcall_pre(&self->simcall, 0);
 443     }
 444
 445   }
 446   inline static void simcall_BODY_host_set_params(smx_host_t ind_vm, ws_params_t params) {
 447     smx_process_t self = SIMIX_process_self();
 448     self->simcall.call = SIMCALL_HOST_SET_PARAMS;
 449     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 450     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 451     self->simcall.args[0].dp = (void*) ind_vm;
 452     self->simcall.args[1].dp = (void*) params;
 453     if (self != simix_global->maestro_process) {
 454       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 455                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 456       SIMIX_process_yield(self);
 457     } else {
 458       SIMIX_simcall_pre(&self->simcall, 0);
 459     }
 460
 461   }
 462   inline static void* simcall_BODY_vm_create(const char* name, smx_host_t ind_pm) {
 463     smx_process_t self = SIMIX_process_self();
 464     self->simcall.call = SIMCALL_VM_CREATE;
 465     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 466     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 467     self->simcall.args[0].cc = (const char*) name;
 468     self->simcall.args[1].dp = (void*) ind_pm;
 469     if (self != simix_global->maestro_process) {
 470       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 471                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 472       SIMIX_process_yield(self);
 473     } else {
 474       SIMIX_simcall_pre(&self->simcall, 0);
 475     }
 476     return self->simcall.result.dp;
 477   }
 478   inline static void simcall_BODY_vm_start(smx_host_t ind_vm) {
 479     smx_process_t self = SIMIX_process_self();
 480     self->simcall.call = SIMCALL_VM_START;
 481     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 482     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 483     self->simcall.args[0].dp = (void*) ind_vm;
 484     if (self != simix_global->maestro_process) {
 485       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 486                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 487       SIMIX_process_yield(self);
 488     } else {
 489       SIMIX_simcall_pre(&self->simcall, 0);
 490     }
 491
 492   }
 493   inline static int simcall_BODY_vm_get_state(smx_host_t ind_vm) {
 494     smx_process_t self = SIMIX_process_self();
 495     self->simcall.call = SIMCALL_VM_GET_STATE;
 496     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 497     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 498     self->simcall.args[0].dp = (void*) ind_vm;
 499     if (self != simix_global->maestro_process) {
 500       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 501                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 502       SIMIX_process_yield(self);
 503     } else {
 504       SIMIX_simcall_pre(&self->simcall, 0);
 505     }
 506     return self->simcall.result.i;
 507   }
 508   inline static void simcall_BODY_vm_migrate(smx_host_t ind_vm, smx_host_t ind_dst_pm) {
 509     smx_process_t self = SIMIX_process_self();
 510     self->simcall.call = SIMCALL_VM_MIGRATE;
 511     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 512     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 513     self->simcall.args[0].dp = (void*) ind_vm;
 514     self->simcall.args[1].dp = (void*) ind_dst_pm;
 515     if (self != simix_global->maestro_process) {
 516       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 517                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 518       SIMIX_process_yield(self);
 519     } else {
 520       SIMIX_simcall_pre(&self->simcall, 0);
 521     }
 522
 523   }
 524   inline static void* simcall_BODY_vm_get_pm(smx_host_t ind_vm) {
 525     smx_process_t self = SIMIX_process_self();
 526     self->simcall.call = SIMCALL_VM_GET_PM;
 527     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 528     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 529     self->simcall.args[0].dp = (void*) ind_vm;
 530     if (self != simix_global->maestro_process) {
 531       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 532                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 533       SIMIX_process_yield(self);
 534     } else {
 535       SIMIX_simcall_pre(&self->simcall, 0);
 536     }
 537     return self->simcall.result.dp;
 538   }
 539   inline static void simcall_BODY_vm_set_bound(smx_host_t ind_vm, double bound) {
 540     smx_process_t self = SIMIX_process_self();
 541     self->simcall.call = SIMCALL_VM_SET_BOUND;
 542     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 543     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 544     self->simcall.args[0].dp = (void*) ind_vm;
 545     self->simcall.args[1].d = (double) bound;
 546     if (self != simix_global->maestro_process) {
 547       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 548                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 549       SIMIX_process_yield(self);
 550     } else {
 551       SIMIX_simcall_pre(&self->simcall, 0);
 552     }
 553
 554   }
 555   inline static void simcall_BODY_vm_set_affinity(smx_host_t ind_vm, smx_host_t ind_pm, unsigned long mask) {
 556     smx_process_t self = SIMIX_process_self();
 557     self->simcall.call = SIMCALL_VM_SET_AFFINITY;
 558     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 559     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 560     self->simcall.args[0].dp = (void*) ind_vm;
 561     self->simcall.args[1].dp = (void*) ind_pm;
 562     self->simcall.args[2].ul = (unsigned long) mask;
 563     if (self != simix_global->maestro_process) {
 564       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 565                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 566       SIMIX_process_yield(self);
 567     } else {
 568       SIMIX_simcall_pre(&self->simcall, 0);
 569     }
 570
 571   }
 572   inline static void simcall_BODY_vm_destroy(smx_host_t ind_vm) {
 573     smx_process_t self = SIMIX_process_self();
 574     self->simcall.call = SIMCALL_VM_DESTROY;
 575     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 576     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 577     self->simcall.args[0].dp = (void*) ind_vm;
 578     if (self != simix_global->maestro_process) {
 579       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 580                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 581       SIMIX_process_yield(self);
 582     } else {
 583       SIMIX_simcall_pre(&self->simcall, 0);
 584     }
 585
 586   }
 587   inline static void simcall_BODY_vm_suspend(smx_host_t ind_vm) {
 588     smx_process_t self = SIMIX_process_self();
 589     self->simcall.call = SIMCALL_VM_SUSPEND;
 590     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 591     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 592     self->simcall.args[0].dp = (void*) ind_vm;
 593     if (self != simix_global->maestro_process) {
 594       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 595                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 596       SIMIX_process_yield(self);
 597     } else {
 598       SIMIX_simcall_pre(&self->simcall, 0);
 599     }
 600
 601   }
 602   inline static void simcall_BODY_vm_resume(smx_host_t ind_vm) {
 603     smx_process_t self = SIMIX_process_self();
 604     self->simcall.call = SIMCALL_VM_RESUME;
 605     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 606     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 607     self->simcall.args[0].dp = (void*) ind_vm;
 608     if (self != simix_global->maestro_process) {
 609       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 610                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 611       SIMIX_process_yield(self);
 612     } else {
 613       SIMIX_simcall_pre(&self->simcall, 0);
 614     }
 615
 616   }
 617   inline static void simcall_BODY_vm_shutdown(smx_host_t ind_vm) {
 618     smx_process_t self = SIMIX_process_self();
 619     self->simcall.call = SIMCALL_VM_SHUTDOWN;
 620     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 621     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 622     self->simcall.args[0].dp = (void*) ind_vm;
 623     if (self != simix_global->maestro_process) {
 624       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 625                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 626       SIMIX_process_yield(self);
 627     } else {
 628       SIMIX_simcall_pre(&self->simcall, 0);
 629     }
 630
 631   }
 632   inline static void simcall_BODY_vm_save(smx_host_t ind_vm) {
 633     smx_process_t self = SIMIX_process_self();
 634     self->simcall.call = SIMCALL_VM_SAVE;
 635     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 636     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 637     self->simcall.args[0].dp = (void*) ind_vm;
 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_pre(&self->simcall, 0);
 644     }
 645
 646   }
 647   inline static void simcall_BODY_vm_restore(smx_host_t ind_vm) {
 648     smx_process_t self = SIMIX_process_self();
 649     self->simcall.call = SIMCALL_VM_RESTORE;
 650     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 651     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 652     self->simcall.args[0].dp = (void*) ind_vm;
 653     if (self != simix_global->maestro_process) {
 654       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 655                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 656       SIMIX_process_yield(self);
 657     } else {
 658       SIMIX_simcall_pre(&self->simcall, 0);
 659     }
 660
 661   }
 662   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) {
 663     smx_process_t self = SIMIX_process_self();
 664     self->simcall.call = SIMCALL_PROCESS_CREATE;
 665     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 666     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 667     self->simcall.args[0].dp = (void*) process;
 668     self->simcall.args[1].cc = (const char*) name;
 669     self->simcall.args[2].fp = (FPtr) code;
 670     self->simcall.args[3].dp = (void*) data;
 671     self->simcall.args[4].cc = (const char*) hostname;
 672     self->simcall.args[5].d = (double) kill_time;
 673     self->simcall.args[6].i = (int) argc;
 674     self->simcall.args[7].dp = (void*) argv;
 675     self->simcall.args[8].dp = (void*) properties;
 676     self->simcall.args[9].i = (int) auto_restart;
 677     if (self != simix_global->maestro_process) {
 678       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 679                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 680       SIMIX_process_yield(self);
 681     } else {
 682       SIMIX_simcall_pre(&self->simcall, 0);
 683     }
 684
 685   }
 686   inline static void simcall_BODY_process_kill(smx_process_t process) {
 687     smx_process_t self = SIMIX_process_self();
 688     self->simcall.call = SIMCALL_PROCESS_KILL;
 689     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 690     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 691     self->simcall.args[0].dp = (void*) process;
 692     if (self != simix_global->maestro_process) {
 693       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 694                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 695       SIMIX_process_yield(self);
 696     } else {
 697       SIMIX_simcall_pre(&self->simcall, 0);
 698     }
 699
 700   }
 701   inline static void simcall_BODY_process_killall(int reset_pid) {
 702     smx_process_t self = SIMIX_process_self();
 703     self->simcall.call = SIMCALL_PROCESS_KILLALL;
 704     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 705     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 706     self->simcall.args[0].i = (int) reset_pid;
 707     if (self != simix_global->maestro_process) {
 708       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 709                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 710       SIMIX_process_yield(self);
 711     } else {
 712       SIMIX_simcall_pre(&self->simcall, 0);
 713     }
 714
 715   }
 716   inline static void simcall_BODY_process_cleanup(smx_process_t process) {
 717     smx_process_t self = SIMIX_process_self();
 718     self->simcall.call = SIMCALL_PROCESS_CLEANUP;
 719     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 720     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 721     self->simcall.args[0].dp = (void*) process;
 722     if (self != simix_global->maestro_process) {
 723       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 724                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 725       SIMIX_process_yield(self);
 726     } else {
 727       SIMIX_simcall_pre(&self->simcall, 0);
 728     }
 729
 730   }
 731   inline static void simcall_BODY_process_change_host(smx_process_t process, smx_host_t dest) {
 732     smx_process_t self = SIMIX_process_self();
 733     self->simcall.call = SIMCALL_PROCESS_CHANGE_HOST;
 734     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 735     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 736     self->simcall.args[0].dp = (void*) process;
 737     self->simcall.args[1].dp = (void*) dest;
 738     if (self != simix_global->maestro_process) {
 739       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 740                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 741       SIMIX_process_yield(self);
 742     } else {
 743       SIMIX_simcall_pre(&self->simcall, 0);
 744     }
 745
 746   }
 747   inline static void simcall_BODY_process_suspend(smx_process_t process) {
 748     smx_process_t self = SIMIX_process_self();
 749     self->simcall.call = SIMCALL_PROCESS_SUSPEND;
 750     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 751     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 752     self->simcall.args[0].dp = (void*) process;
 753     if (self != simix_global->maestro_process) {
 754       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 755                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 756       SIMIX_process_yield(self);
 757     } else {
 758       SIMIX_simcall_pre(&self->simcall, 0);
 759     }
 760
 761   }
 762   inline static void simcall_BODY_process_resume(smx_process_t process) {
 763     smx_process_t self = SIMIX_process_self();
 764     self->simcall.call = SIMCALL_PROCESS_RESUME;
 765     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 766     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 767     self->simcall.args[0].dp = (void*) process;
 768     if (self != simix_global->maestro_process) {
 769       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 770                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 771       SIMIX_process_yield(self);
 772     } else {
 773       SIMIX_simcall_pre(&self->simcall, 0);
 774     }
 775
 776   }
 777   inline static int simcall_BODY_process_count() {
 778     smx_process_t self = SIMIX_process_self();
 779     self->simcall.call = SIMCALL_PROCESS_COUNT;
 780     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 781     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 782
 783     if (self != simix_global->maestro_process) {
 784       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 785                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 786       SIMIX_process_yield(self);
 787     } else {
 788       SIMIX_simcall_pre(&self->simcall, 0);
 789     }
 790     return self->simcall.result.i;
 791   }
 792   inline static int simcall_BODY_process_get_PID(smx_process_t process) {
 793     smx_process_t self = SIMIX_process_self();
 794     self->simcall.call = SIMCALL_PROCESS_GET_PID;
 795     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 796     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 797     self->simcall.args[0].dp = (void*) process;
 798     if (self != simix_global->maestro_process) {
 799       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 800                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 801       SIMIX_process_yield(self);
 802     } else {
 803       SIMIX_simcall_pre(&self->simcall, 0);
 804     }
 805     return self->simcall.result.i;
 806   }
 807   inline static int simcall_BODY_process_get_PPID(smx_process_t process) {
 808     smx_process_t self = SIMIX_process_self();
 809     self->simcall.call = SIMCALL_PROCESS_GET_PPID;
 810     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 811     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 812     self->simcall.args[0].dp = (void*) process;
 813     if (self != simix_global->maestro_process) {
 814       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 815                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 816       SIMIX_process_yield(self);
 817     } else {
 818       SIMIX_simcall_pre(&self->simcall, 0);
 819     }
 820     return self->simcall.result.i;
 821   }
 822   inline static void* simcall_BODY_process_get_data(smx_process_t process) {
 823     smx_process_t self = SIMIX_process_self();
 824     self->simcall.call = SIMCALL_PROCESS_GET_DATA;
 825     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 826     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 827     self->simcall.args[0].dp = (void*) process;
 828     if (self != simix_global->maestro_process) {
 829       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 830                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 831       SIMIX_process_yield(self);
 832     } else {
 833       SIMIX_simcall_pre(&self->simcall, 0);
 834     }
 835     return self->simcall.result.dp;
 836   }
 837   inline static void simcall_BODY_process_set_data(smx_process_t process, void* data) {
 838     smx_process_t self = SIMIX_process_self();
 839     self->simcall.call = SIMCALL_PROCESS_SET_DATA;
 840     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 841     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 842     self->simcall.args[0].dp = (void*) process;
 843     self->simcall.args[1].dp = (void*) data;
 844     if (self != simix_global->maestro_process) {
 845       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 846                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 847       SIMIX_process_yield(self);
 848     } else {
 849       SIMIX_simcall_pre(&self->simcall, 0);
 850     }
 851
 852   }
 853   inline static smx_host_t simcall_BODY_process_get_host(smx_process_t process) {
 854     smx_process_t self = SIMIX_process_self();
 855     self->simcall.call = SIMCALL_PROCESS_GET_HOST;
 856     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 857     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 858     self->simcall.args[0].dp = (void*) process;
 859     if (self != simix_global->maestro_process) {
 860       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 861                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 862       SIMIX_process_yield(self);
 863     } else {
 864       SIMIX_simcall_pre(&self->simcall, 0);
 865     }
 866     return self->simcall.result.dp;
 867   }
 868   inline static const char* simcall_BODY_process_get_name(smx_process_t process) {
 869     smx_process_t self = SIMIX_process_self();
 870     self->simcall.call = SIMCALL_PROCESS_GET_NAME;
 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*) process;
 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_pre(&self->simcall, 0);
 880     }
 881     return self->simcall.result.cc;
 882   }
 883   inline static int simcall_BODY_process_is_suspended(smx_process_t process) {
 884     smx_process_t self = SIMIX_process_self();
 885     self->simcall.call = SIMCALL_PROCESS_IS_SUSPENDED;
 886     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 887     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 888     self->simcall.args[0].dp = (void*) process;
 889     if (self != simix_global->maestro_process) {
 890       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 891                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 892       SIMIX_process_yield(self);
 893     } else {
 894       SIMIX_simcall_pre(&self->simcall, 0);
 895     }
 896     return self->simcall.result.i;
 897   }
 898   inline static xbt_dict_t simcall_BODY_process_get_properties(smx_process_t process) {
 899     smx_process_t self = SIMIX_process_self();
 900     self->simcall.call = SIMCALL_PROCESS_GET_PROPERTIES;
 901     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 902     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 903     self->simcall.args[0].dp = (void*) process;
 904     if (self != simix_global->maestro_process) {
 905       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 906                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 907       SIMIX_process_yield(self);
 908     } else {
 909       SIMIX_simcall_pre(&self->simcall, 0);
 910     }
 911     return self->simcall.result.dp;
 912   }
 913   inline static int simcall_BODY_process_join(smx_process_t process, double timeout) {
 914     smx_process_t self = SIMIX_process_self();
 915     self->simcall.call = SIMCALL_PROCESS_JOIN;
 916     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 917     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 918     self->simcall.args[0].dp = (void*) process;
 919     self->simcall.args[1].d = (double) timeout;
 920     if (self != simix_global->maestro_process) {
 921       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 922                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 923       SIMIX_process_yield(self);
 924     } else {
 925       SIMIX_simcall_pre(&self->simcall, 0);
 926     }
 927     return self->simcall.result.i;
 928   }
 929   inline static int simcall_BODY_process_sleep(double duration) {
 930     smx_process_t self = SIMIX_process_self();
 931     self->simcall.call = SIMCALL_PROCESS_SLEEP;
 932     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 933     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 934     self->simcall.args[0].d = (double) duration;
 935     if (self != simix_global->maestro_process) {
 936       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 937                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 938       SIMIX_process_yield(self);
 939     } else {
 940       SIMIX_simcall_pre(&self->simcall, 0);
 941     }
 942     return self->simcall.result.i;
 943   }
 944   inline static void simcall_BODY_process_on_exit(smx_process_t process, int_f_pvoid_pvoid_t fun, void* data) {
 945     smx_process_t self = SIMIX_process_self();
 946     self->simcall.call = SIMCALL_PROCESS_ON_EXIT;
 947     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 948     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 949     self->simcall.args[0].dp = (void*) process;
 950     self->simcall.args[1].fp = (FPtr) fun;
 951     self->simcall.args[2].dp = (void*) data;
 952     if (self != simix_global->maestro_process) {
 953       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 954                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 955       SIMIX_process_yield(self);
 956     } else {
 957       SIMIX_simcall_pre(&self->simcall, 0);
 958     }
 959
 960   }
 961   inline static void simcall_BODY_process_auto_restart_set(smx_process_t process, int auto_restart) {
 962     smx_process_t self = SIMIX_process_self();
 963     self->simcall.call = SIMCALL_PROCESS_AUTO_RESTART_SET;
 964     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 965     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 966     self->simcall.args[0].dp = (void*) process;
 967     self->simcall.args[1].i = (int) auto_restart;
 968     if (self != simix_global->maestro_process) {
 969       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 970                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 971       SIMIX_process_yield(self);
 972     } else {
 973       SIMIX_simcall_pre(&self->simcall, 0);
 974     }
 975
 976   }
 977   inline static smx_process_t simcall_BODY_process_restart(smx_process_t process) {
 978     smx_process_t self = SIMIX_process_self();
 979     self->simcall.call = SIMCALL_PROCESS_RESTART;
 980     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 981     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 982     self->simcall.args[0].dp = (void*) process;
 983     if (self != simix_global->maestro_process) {
 984       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 985                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 986       SIMIX_process_yield(self);
 987     } else {
 988       SIMIX_simcall_pre(&self->simcall, 0);
 989     }
 990     return self->simcall.result.dp;
 991   }
 992   inline static smx_rdv_t simcall_BODY_rdv_create(const char* name) {
 993     smx_process_t self = SIMIX_process_self();
 994     self->simcall.call = SIMCALL_RDV_CREATE;
 995     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
 996     memset(self->simcall.args, 0, sizeof(self->simcall.args));
 997     self->simcall.args[0].cc = (const char*) name;
 998     if (self != simix_global->maestro_process) {
 999       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1000                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1001       SIMIX_process_yield(self);
1002     } else {
1003       SIMIX_simcall_pre(&self->simcall, 0);
1004     }
1005     return self->simcall.result.dp;
1006   }
1007   inline static void simcall_BODY_rdv_destroy(smx_rdv_t rdv) {
1008     smx_process_t self = SIMIX_process_self();
1009     self->simcall.call = SIMCALL_RDV_DESTROY;
1010     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1011     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1012     self->simcall.args[0].dp = (void*) rdv;
1013     if (self != simix_global->maestro_process) {
1014       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1015                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1016       SIMIX_process_yield(self);
1017     } else {
1018       SIMIX_simcall_pre(&self->simcall, 0);
1019     }
1020
1021   }
1022   inline static unsigned int simcall_BODY_rdv_comm_count_by_host(smx_rdv_t rdv, smx_host_t host) {
1023     smx_process_t self = SIMIX_process_self();
1024     self->simcall.call = SIMCALL_RDV_COMM_COUNT_BY_HOST;
1025     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1026     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1027     self->simcall.args[0].dp = (void*) rdv;
1028     self->simcall.args[1].dp = (void*) host;
1029     if (self != simix_global->maestro_process) {
1030       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1031                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1032       SIMIX_process_yield(self);
1033     } else {
1034       SIMIX_simcall_pre(&self->simcall, 0);
1035     }
1036     return self->simcall.result.ui;
1037   }
1038   inline static smx_action_t simcall_BODY_rdv_get_head(smx_rdv_t rdv) {
1039     smx_process_t self = SIMIX_process_self();
1040     self->simcall.call = SIMCALL_RDV_GET_HEAD;
1041     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1042     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1043     self->simcall.args[0].dp = (void*) rdv;
1044     if (self != simix_global->maestro_process) {
1045       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1046                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1047       SIMIX_process_yield(self);
1048     } else {
1049       SIMIX_simcall_pre(&self->simcall, 0);
1050     }
1051     return self->simcall.result.dp;
1052   }
1053   inline static void simcall_BODY_rdv_set_receiver(smx_rdv_t rdv, smx_process_t receiver) {
1054     smx_process_t self = SIMIX_process_self();
1055     self->simcall.call = SIMCALL_RDV_SET_RECEIVER;
1056     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1057     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1058     self->simcall.args[0].dp = (void*) rdv;
1059     self->simcall.args[1].dp = (void*) receiver;
1060     if (self != simix_global->maestro_process) {
1061       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1062                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1063       SIMIX_process_yield(self);
1064     } else {
1065       SIMIX_simcall_pre(&self->simcall, 0);
1066     }
1067
1068   }
1069   inline static smx_process_t simcall_BODY_rdv_get_receiver(smx_rdv_t rdv) {
1070     smx_process_t self = SIMIX_process_self();
1071     self->simcall.call = SIMCALL_RDV_GET_RECEIVER;
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*) rdv;
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_pre(&self->simcall, 0);
1081     }
1082     return self->simcall.result.dp;
1083   }
1084   inline static smx_action_t simcall_BODY_comm_iprobe(smx_rdv_t rdv, int type, int src, int tag, simix_match_func_t match_fun, void* data) {
1085     smx_process_t self = SIMIX_process_self();
1086     self->simcall.call = SIMCALL_COMM_IPROBE;
1087     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1088     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1089     self->simcall.args[0].dp = (void*) rdv;
1090     self->simcall.args[1].i = (int) type;
1091     self->simcall.args[2].i = (int) src;
1092     self->simcall.args[3].i = (int) tag;
1093     self->simcall.args[4].fp = (FPtr) match_fun;
1094     self->simcall.args[5].dp = (void*) data;
1095     if (self != simix_global->maestro_process) {
1096       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1097                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1098       SIMIX_process_yield(self);
1099     } else {
1100       SIMIX_simcall_pre(&self->simcall, 0);
1101     }
1102     return self->simcall.result.dp;
1103   }
1104   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) {
1105     smx_process_t self = SIMIX_process_self();
1106     self->simcall.call = SIMCALL_COMM_SEND;
1107     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1108     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1109     self->simcall.args[0].dp = (void*) src;
1110     self->simcall.args[1].dp = (void*) rdv;
1111     self->simcall.args[2].d = (double) task_size;
1112     self->simcall.args[3].d = (double) rate;
1113     self->simcall.args[4].dp = (void*) src_buff;
1114     self->simcall.args[5].sz = (size_t) src_buff_size;
1115     self->simcall.args[6].fp = (FPtr) match_fun;
1116     self->simcall.args[7].fp = (FPtr) copy_data_fun;
1117     self->simcall.args[8].dp = (void*) data;
1118     self->simcall.args[9].d = (double) timeout;
1119     if (self != simix_global->maestro_process) {
1120       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1121                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1122       SIMIX_process_yield(self);
1123     } else {
1124       SIMIX_simcall_pre(&self->simcall, 0);
1125     }
1126
1127   }
1128   inline static smx_action_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) {
1129     smx_process_t self = SIMIX_process_self();
1130     self->simcall.call = SIMCALL_COMM_ISEND;
1131     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1132     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1133     self->simcall.args[0].dp = (void*) src;
1134     self->simcall.args[1].dp = (void*) rdv;
1135     self->simcall.args[2].d = (double) task_size;
1136     self->simcall.args[3].d = (double) rate;
1137     self->simcall.args[4].dp = (void*) src_buff;
1138     self->simcall.args[5].sz = (size_t) src_buff_size;
1139     self->simcall.args[6].fp = (FPtr) match_fun;
1140     self->simcall.args[7].fp = (FPtr) clean_fun;
1141     self->simcall.args[8].fp = (FPtr) copy_data_fun;
1142     self->simcall.args[9].dp = (void*) data;
1143     self->simcall.args[10].i = (int) detached;
1144     if (self != simix_global->maestro_process) {
1145       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1146                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1147       SIMIX_process_yield(self);
1148     } else {
1149       SIMIX_simcall_pre(&self->simcall, 0);
1150     }
1151     return self->simcall.result.dp;
1152   }
1153   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) {
1154     smx_process_t self = SIMIX_process_self();
1155     self->simcall.call = SIMCALL_COMM_RECV;
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*) rdv;
1159     self->simcall.args[1].dp = (void*) dst_buff;
1160     self->simcall.args[2].dp = (void*) dst_buff_size;
1161     self->simcall.args[3].fp = (FPtr) match_fun;
1162     self->simcall.args[4].fp = (FPtr) copy_data_fun;
1163     self->simcall.args[5].dp = (void*) data;
1164     self->simcall.args[6].d = (double) timeout;
1165     self->simcall.args[7].d = (double) rate;
1166     if (self != simix_global->maestro_process) {
1167       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1168                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1169       SIMIX_process_yield(self);
1170     } else {
1171       SIMIX_simcall_pre(&self->simcall, 0);
1172     }
1173
1174   }
1175   inline static smx_action_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) {
1176     smx_process_t self = SIMIX_process_self();
1177     self->simcall.call = SIMCALL_COMM_IRECV;
1178     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1179     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1180     self->simcall.args[0].dp = (void*) rdv;
1181     self->simcall.args[1].dp = (void*) dst_buff;
1182     self->simcall.args[2].dp = (void*) dst_buff_size;
1183     self->simcall.args[3].fp = (FPtr) match_fun;
1184     self->simcall.args[4].fp = (FPtr) copy_data_fun;
1185     self->simcall.args[5].dp = (void*) data;
1186     self->simcall.args[6].d = (double) rate;
1187     if (self != simix_global->maestro_process) {
1188       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1189                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1190       SIMIX_process_yield(self);
1191     } else {
1192       SIMIX_simcall_pre(&self->simcall, 0);
1193     }
1194     return self->simcall.result.dp;
1195   }
1196   inline static void simcall_BODY_comm_cancel(smx_action_t comm) {
1197     smx_process_t self = SIMIX_process_self();
1198     self->simcall.call = SIMCALL_COMM_CANCEL;
1199     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1200     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1201     self->simcall.args[0].dp = (void*) comm;
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_pre(&self->simcall, 0);
1208     }
1209
1210   }
1211   inline static int simcall_BODY_comm_waitany(xbt_dynar_t comms) {
1212     smx_process_t self = SIMIX_process_self();
1213     self->simcall.call = SIMCALL_COMM_WAITANY;
1214     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1215     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1216     self->simcall.args[0].dp = (void*) comms;
1217     if (self != simix_global->maestro_process) {
1218       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1219                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1220       SIMIX_process_yield(self);
1221     } else {
1222       SIMIX_simcall_pre(&self->simcall, 0);
1223     }
1224     return self->simcall.result.i;
1225   }
1226   inline static void simcall_BODY_comm_wait(smx_action_t comm, double timeout) {
1227     smx_process_t self = SIMIX_process_self();
1228     self->simcall.call = SIMCALL_COMM_WAIT;
1229     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1230     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1231     self->simcall.args[0].dp = (void*) comm;
1232     self->simcall.args[1].d = (double) timeout;
1233     if (self != simix_global->maestro_process) {
1234       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1235                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1236       SIMIX_process_yield(self);
1237     } else {
1238       SIMIX_simcall_pre(&self->simcall, 0);
1239     }
1240
1241   }
1242   inline static int simcall_BODY_comm_test(smx_action_t comm) {
1243     smx_process_t self = SIMIX_process_self();
1244     self->simcall.call = SIMCALL_COMM_TEST;
1245     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1246     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1247     self->simcall.args[0].dp = (void*) comm;
1248     if (self != simix_global->maestro_process) {
1249       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1250                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1251       SIMIX_process_yield(self);
1252     } else {
1253       SIMIX_simcall_pre(&self->simcall, 0);
1254     }
1255     return self->simcall.result.i;
1256   }
1257   inline static int simcall_BODY_comm_testany(xbt_dynar_t comms) {
1258     smx_process_t self = SIMIX_process_self();
1259     self->simcall.call = SIMCALL_COMM_TESTANY;
1260     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1261     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1262     self->simcall.args[0].dp = (void*) comms;
1263     if (self != simix_global->maestro_process) {
1264       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1265                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1266       SIMIX_process_yield(self);
1267     } else {
1268       SIMIX_simcall_pre(&self->simcall, 0);
1269     }
1270     return self->simcall.result.i;
1271   }
1272   inline static double simcall_BODY_comm_get_remains(smx_action_t comm) {
1273     smx_process_t self = SIMIX_process_self();
1274     self->simcall.call = SIMCALL_COMM_GET_REMAINS;
1275     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1276     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1277     self->simcall.args[0].dp = (void*) comm;
1278     if (self != simix_global->maestro_process) {
1279       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1280                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1281       SIMIX_process_yield(self);
1282     } else {
1283       SIMIX_simcall_pre(&self->simcall, 0);
1284     }
1285     return self->simcall.result.d;
1286   }
1287   inline static int simcall_BODY_comm_get_state(smx_action_t comm) {
1288     smx_process_t self = SIMIX_process_self();
1289     self->simcall.call = SIMCALL_COMM_GET_STATE;
1290     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1291     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1292     self->simcall.args[0].dp = (void*) comm;
1293     if (self != simix_global->maestro_process) {
1294       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1295                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1296       SIMIX_process_yield(self);
1297     } else {
1298       SIMIX_simcall_pre(&self->simcall, 0);
1299     }
1300     return self->simcall.result.i;
1301   }
1302   inline static void* simcall_BODY_comm_get_src_data(smx_action_t comm) {
1303     smx_process_t self = SIMIX_process_self();
1304     self->simcall.call = SIMCALL_COMM_GET_SRC_DATA;
1305     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1306     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1307     self->simcall.args[0].dp = (void*) comm;
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_pre(&self->simcall, 0);
1314     }
1315     return self->simcall.result.dp;
1316   }
1317   inline static void* simcall_BODY_comm_get_dst_data(smx_action_t comm) {
1318     smx_process_t self = SIMIX_process_self();
1319     self->simcall.call = SIMCALL_COMM_GET_DST_DATA;
1320     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1321     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1322     self->simcall.args[0].dp = (void*) comm;
1323     if (self != simix_global->maestro_process) {
1324       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1325                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1326       SIMIX_process_yield(self);
1327     } else {
1328       SIMIX_simcall_pre(&self->simcall, 0);
1329     }
1330     return self->simcall.result.dp;
1331   }
1332   inline static smx_process_t simcall_BODY_comm_get_src_proc(smx_action_t comm) {
1333     smx_process_t self = SIMIX_process_self();
1334     self->simcall.call = SIMCALL_COMM_GET_SRC_PROC;
1335     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1336     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1337     self->simcall.args[0].dp = (void*) comm;
1338     if (self != simix_global->maestro_process) {
1339       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1340                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1341       SIMIX_process_yield(self);
1342     } else {
1343       SIMIX_simcall_pre(&self->simcall, 0);
1344     }
1345     return self->simcall.result.dp;
1346   }
1347   inline static smx_process_t simcall_BODY_comm_get_dst_proc(smx_action_t comm) {
1348     smx_process_t self = SIMIX_process_self();
1349     self->simcall.call = SIMCALL_COMM_GET_DST_PROC;
1350     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1351     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1352     self->simcall.args[0].dp = (void*) comm;
1353     if (self != simix_global->maestro_process) {
1354       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1355                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1356       SIMIX_process_yield(self);
1357     } else {
1358       SIMIX_simcall_pre(&self->simcall, 0);
1359     }
1360     return self->simcall.result.dp;
1361   }
1362   inline static smx_mutex_t simcall_BODY_mutex_init() {
1363     smx_process_t self = SIMIX_process_self();
1364     self->simcall.call = SIMCALL_MUTEX_INIT;
1365     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1366     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1367
1368     if (self != simix_global->maestro_process) {
1369       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1370                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1371       SIMIX_process_yield(self);
1372     } else {
1373       SIMIX_simcall_pre(&self->simcall, 0);
1374     }
1375     return self->simcall.result.dp;
1376   }
1377   inline static void simcall_BODY_mutex_destroy(smx_mutex_t mutex) {
1378     smx_process_t self = SIMIX_process_self();
1379     self->simcall.call = SIMCALL_MUTEX_DESTROY;
1380     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1381     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1382     self->simcall.args[0].dp = (void*) mutex;
1383     if (self != simix_global->maestro_process) {
1384       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1385                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1386       SIMIX_process_yield(self);
1387     } else {
1388       SIMIX_simcall_pre(&self->simcall, 0);
1389     }
1390
1391   }
1392   inline static void simcall_BODY_mutex_lock(smx_mutex_t mutex) {
1393     smx_process_t self = SIMIX_process_self();
1394     self->simcall.call = SIMCALL_MUTEX_LOCK;
1395     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1396     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1397     self->simcall.args[0].dp = (void*) mutex;
1398     if (self != simix_global->maestro_process) {
1399       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1400                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1401       SIMIX_process_yield(self);
1402     } else {
1403       SIMIX_simcall_pre(&self->simcall, 0);
1404     }
1405
1406   }
1407   inline static int simcall_BODY_mutex_trylock(smx_mutex_t mutex) {
1408     smx_process_t self = SIMIX_process_self();
1409     self->simcall.call = SIMCALL_MUTEX_TRYLOCK;
1410     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1411     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1412     self->simcall.args[0].dp = (void*) mutex;
1413     if (self != simix_global->maestro_process) {
1414       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1415                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1416       SIMIX_process_yield(self);
1417     } else {
1418       SIMIX_simcall_pre(&self->simcall, 0);
1419     }
1420     return self->simcall.result.i;
1421   }
1422   inline static void simcall_BODY_mutex_unlock(smx_mutex_t mutex) {
1423     smx_process_t self = SIMIX_process_self();
1424     self->simcall.call = SIMCALL_MUTEX_UNLOCK;
1425     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1426     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1427     self->simcall.args[0].dp = (void*) mutex;
1428     if (self != simix_global->maestro_process) {
1429       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1430                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1431       SIMIX_process_yield(self);
1432     } else {
1433       SIMIX_simcall_pre(&self->simcall, 0);
1434     }
1435
1436   }
1437   inline static smx_cond_t simcall_BODY_cond_init() {
1438     smx_process_t self = SIMIX_process_self();
1439     self->simcall.call = SIMCALL_COND_INIT;
1440     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1441     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1442
1443     if (self != simix_global->maestro_process) {
1444       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1445                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1446       SIMIX_process_yield(self);
1447     } else {
1448       SIMIX_simcall_pre(&self->simcall, 0);
1449     }
1450     return self->simcall.result.dp;
1451   }
1452   inline static void simcall_BODY_cond_destroy(smx_cond_t cond) {
1453     smx_process_t self = SIMIX_process_self();
1454     self->simcall.call = SIMCALL_COND_DESTROY;
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*) cond;
1458     if (self != simix_global->maestro_process) {
1459       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1460                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1461       SIMIX_process_yield(self);
1462     } else {
1463       SIMIX_simcall_pre(&self->simcall, 0);
1464     }
1465
1466   }
1467   inline static void simcall_BODY_cond_signal(smx_cond_t cond) {
1468     smx_process_t self = SIMIX_process_self();
1469     self->simcall.call = SIMCALL_COND_SIGNAL;
1470     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1471     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1472     self->simcall.args[0].dp = (void*) cond;
1473     if (self != simix_global->maestro_process) {
1474       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1475                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1476       SIMIX_process_yield(self);
1477     } else {
1478       SIMIX_simcall_pre(&self->simcall, 0);
1479     }
1480
1481   }
1482   inline static void simcall_BODY_cond_wait(smx_cond_t cond, smx_mutex_t mutex) {
1483     smx_process_t self = SIMIX_process_self();
1484     self->simcall.call = SIMCALL_COND_WAIT;
1485     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1486     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1487     self->simcall.args[0].dp = (void*) cond;
1488     self->simcall.args[1].dp = (void*) mutex;
1489     if (self != simix_global->maestro_process) {
1490       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1491                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1492       SIMIX_process_yield(self);
1493     } else {
1494       SIMIX_simcall_pre(&self->simcall, 0);
1495     }
1496
1497   }
1498   inline static void simcall_BODY_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double timeout) {
1499     smx_process_t self = SIMIX_process_self();
1500     self->simcall.call = SIMCALL_COND_WAIT_TIMEOUT;
1501     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1502     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1503     self->simcall.args[0].dp = (void*) cond;
1504     self->simcall.args[1].dp = (void*) mutex;
1505     self->simcall.args[2].d = (double) timeout;
1506     if (self != simix_global->maestro_process) {
1507       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1508                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1509       SIMIX_process_yield(self);
1510     } else {
1511       SIMIX_simcall_pre(&self->simcall, 0);
1512     }
1513
1514   }
1515   inline static void simcall_BODY_cond_broadcast(smx_cond_t cond) {
1516     smx_process_t self = SIMIX_process_self();
1517     self->simcall.call = SIMCALL_COND_BROADCAST;
1518     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1519     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1520     self->simcall.args[0].dp = (void*) cond;
1521     if (self != simix_global->maestro_process) {
1522       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1523                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1524       SIMIX_process_yield(self);
1525     } else {
1526       SIMIX_simcall_pre(&self->simcall, 0);
1527     }
1528
1529   }
1530   inline static smx_sem_t simcall_BODY_sem_init(int capacity) {
1531     smx_process_t self = SIMIX_process_self();
1532     self->simcall.call = SIMCALL_SEM_INIT;
1533     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1534     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1535     self->simcall.args[0].i = (int) capacity;
1536     if (self != simix_global->maestro_process) {
1537       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1538                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1539       SIMIX_process_yield(self);
1540     } else {
1541       SIMIX_simcall_pre(&self->simcall, 0);
1542     }
1543     return self->simcall.result.dp;
1544   }
1545   inline static void simcall_BODY_sem_destroy(smx_sem_t sem) {
1546     smx_process_t self = SIMIX_process_self();
1547     self->simcall.call = SIMCALL_SEM_DESTROY;
1548     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1549     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1550     self->simcall.args[0].dp = (void*) sem;
1551     if (self != simix_global->maestro_process) {
1552       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1553                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1554       SIMIX_process_yield(self);
1555     } else {
1556       SIMIX_simcall_pre(&self->simcall, 0);
1557     }
1558
1559   }
1560   inline static void simcall_BODY_sem_release(smx_sem_t sem) {
1561     smx_process_t self = SIMIX_process_self();
1562     self->simcall.call = SIMCALL_SEM_RELEASE;
1563     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1564     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1565     self->simcall.args[0].dp = (void*) sem;
1566     if (self != simix_global->maestro_process) {
1567       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1568                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1569       SIMIX_process_yield(self);
1570     } else {
1571       SIMIX_simcall_pre(&self->simcall, 0);
1572     }
1573
1574   }
1575   inline static int simcall_BODY_sem_would_block(smx_sem_t sem) {
1576     smx_process_t self = SIMIX_process_self();
1577     self->simcall.call = SIMCALL_SEM_WOULD_BLOCK;
1578     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1579     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1580     self->simcall.args[0].dp = (void*) sem;
1581     if (self != simix_global->maestro_process) {
1582       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1583                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1584       SIMIX_process_yield(self);
1585     } else {
1586       SIMIX_simcall_pre(&self->simcall, 0);
1587     }
1588     return self->simcall.result.i;
1589   }
1590   inline static void simcall_BODY_sem_acquire(smx_sem_t sem) {
1591     smx_process_t self = SIMIX_process_self();
1592     self->simcall.call = SIMCALL_SEM_ACQUIRE;
1593     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1594     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1595     self->simcall.args[0].dp = (void*) sem;
1596     if (self != simix_global->maestro_process) {
1597       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1598                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1599       SIMIX_process_yield(self);
1600     } else {
1601       SIMIX_simcall_pre(&self->simcall, 0);
1602     }
1603
1604   }
1605   inline static void simcall_BODY_sem_acquire_timeout(smx_sem_t sem, double timeout) {
1606     smx_process_t self = SIMIX_process_self();
1607     self->simcall.call = SIMCALL_SEM_ACQUIRE_TIMEOUT;
1608     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1609     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1610     self->simcall.args[0].dp = (void*) sem;
1611     self->simcall.args[1].d = (double) timeout;
1612     if (self != simix_global->maestro_process) {
1613       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1614                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1615       SIMIX_process_yield(self);
1616     } else {
1617       SIMIX_simcall_pre(&self->simcall, 0);
1618     }
1619
1620   }
1621   inline static int simcall_BODY_sem_get_capacity(smx_sem_t sem) {
1622     smx_process_t self = SIMIX_process_self();
1623     self->simcall.call = SIMCALL_SEM_GET_CAPACITY;
1624     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1625     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1626     self->simcall.args[0].dp = (void*) sem;
1627     if (self != simix_global->maestro_process) {
1628       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1629                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1630       SIMIX_process_yield(self);
1631     } else {
1632       SIMIX_simcall_pre(&self->simcall, 0);
1633     }
1634     return self->simcall.result.i;
1635   }
1636   inline static sg_size_t simcall_BODY_file_read(smx_file_t fd, sg_size_t size, smx_host_t host) {
1637     smx_process_t self = SIMIX_process_self();
1638     self->simcall.call = SIMCALL_FILE_READ;
1639     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1640     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1641     self->simcall.args[0].dp = (void*) fd;
1642     self->simcall.args[1].sgsz = (sg_size_t) size;
1643     self->simcall.args[2].dp = (void*) host;
1644     if (self != simix_global->maestro_process) {
1645       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1646                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1647       SIMIX_process_yield(self);
1648     } else {
1649       SIMIX_simcall_pre(&self->simcall, 0);
1650     }
1651     return self->simcall.result.sgsz;
1652   }
1653   inline static sg_size_t simcall_BODY_file_write(smx_file_t fd, sg_size_t size, smx_host_t host) {
1654     smx_process_t self = SIMIX_process_self();
1655     self->simcall.call = SIMCALL_FILE_WRITE;
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*) fd;
1659     self->simcall.args[1].sgsz = (sg_size_t) size;
1660     self->simcall.args[2].dp = (void*) host;
1661     if (self != simix_global->maestro_process) {
1662       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1663                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1664       SIMIX_process_yield(self);
1665     } else {
1666       SIMIX_simcall_pre(&self->simcall, 0);
1667     }
1668     return self->simcall.result.sgsz;
1669   }
1670   inline static smx_file_t simcall_BODY_file_open(const char* fullpath, smx_host_t host) {
1671     smx_process_t self = SIMIX_process_self();
1672     self->simcall.call = SIMCALL_FILE_OPEN;
1673     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1674     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1675     self->simcall.args[0].cc = (const char*) fullpath;
1676     self->simcall.args[1].dp = (void*) host;
1677     if (self != simix_global->maestro_process) {
1678       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1679                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1680       SIMIX_process_yield(self);
1681     } else {
1682       SIMIX_simcall_pre(&self->simcall, 0);
1683     }
1684     return self->simcall.result.dp;
1685   }
1686   inline static int simcall_BODY_file_close(smx_file_t fd, smx_host_t host) {
1687     smx_process_t self = SIMIX_process_self();
1688     self->simcall.call = SIMCALL_FILE_CLOSE;
1689     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1690     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1691     self->simcall.args[0].dp = (void*) fd;
1692     self->simcall.args[1].dp = (void*) host;
1693     if (self != simix_global->maestro_process) {
1694       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1695                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1696       SIMIX_process_yield(self);
1697     } else {
1698       SIMIX_simcall_pre(&self->simcall, 0);
1699     }
1700     return self->simcall.result.i;
1701   }
1702   inline static int simcall_BODY_file_unlink(smx_file_t fd, smx_host_t host) {
1703     smx_process_t self = SIMIX_process_self();
1704     self->simcall.call = SIMCALL_FILE_UNLINK;
1705     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1706     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1707     self->simcall.args[0].dp = (void*) fd;
1708     self->simcall.args[1].dp = (void*) host;
1709     if (self != simix_global->maestro_process) {
1710       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1711                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1712       SIMIX_process_yield(self);
1713     } else {
1714       SIMIX_simcall_pre(&self->simcall, 0);
1715     }
1716     return self->simcall.result.i;
1717   }
1718   inline static sg_size_t simcall_BODY_file_get_size(smx_file_t fd) {
1719     smx_process_t self = SIMIX_process_self();
1720     self->simcall.call = SIMCALL_FILE_GET_SIZE;
1721     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1722     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1723     self->simcall.args[0].dp = (void*) fd;
1724     if (self != simix_global->maestro_process) {
1725       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1726                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1727       SIMIX_process_yield(self);
1728     } else {
1729       SIMIX_simcall_pre(&self->simcall, 0);
1730     }
1731     return self->simcall.result.sgsz;
1732   }
1733   inline static sg_size_t simcall_BODY_file_tell(smx_file_t fd) {
1734     smx_process_t self = SIMIX_process_self();
1735     self->simcall.call = SIMCALL_FILE_TELL;
1736     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1737     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1738     self->simcall.args[0].dp = (void*) fd;
1739     if (self != simix_global->maestro_process) {
1740       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1741                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1742       SIMIX_process_yield(self);
1743     } else {
1744       SIMIX_simcall_pre(&self->simcall, 0);
1745     }
1746     return self->simcall.result.sgsz;
1747   }
1748   inline static int simcall_BODY_file_seek(smx_file_t fd, sg_offset_t offset, int origin) {
1749     smx_process_t self = SIMIX_process_self();
1750     self->simcall.call = SIMCALL_FILE_SEEK;
1751     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1752     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1753     self->simcall.args[0].dp = (void*) fd;
1754     self->simcall.args[1].sgoff = (sg_offset_t) offset;
1755     self->simcall.args[2].i = (int) origin;
1756     if (self != simix_global->maestro_process) {
1757       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1758                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1759       SIMIX_process_yield(self);
1760     } else {
1761       SIMIX_simcall_pre(&self->simcall, 0);
1762     }
1763     return self->simcall.result.i;
1764   }
1765   inline static xbt_dynar_t simcall_BODY_file_get_info(smx_file_t fd) {
1766     smx_process_t self = SIMIX_process_self();
1767     self->simcall.call = SIMCALL_FILE_GET_INFO;
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*) fd;
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_pre(&self->simcall, 0);
1777     }
1778     return self->simcall.result.dp;
1779   }
1780   inline static int simcall_BODY_file_move(smx_file_t fd, const char* fullpath) {
1781     smx_process_t self = SIMIX_process_self();
1782     self->simcall.call = SIMCALL_FILE_MOVE;
1783     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1784     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1785     self->simcall.args[0].dp = (void*) fd;
1786     self->simcall.args[1].cc = (const char*) fullpath;
1787     if (self != simix_global->maestro_process) {
1788       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1789                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1790       SIMIX_process_yield(self);
1791     } else {
1792       SIMIX_simcall_pre(&self->simcall, 0);
1793     }
1794     return self->simcall.result.i;
1795   }
1796   inline static sg_size_t simcall_BODY_storage_get_free_size(smx_storage_t storage) {
1797     smx_process_t self = SIMIX_process_self();
1798     self->simcall.call = SIMCALL_STORAGE_GET_FREE_SIZE;
1799     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1800     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1801     self->simcall.args[0].dp = (void*) storage;
1802     if (self != simix_global->maestro_process) {
1803       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1804                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1805       SIMIX_process_yield(self);
1806     } else {
1807       SIMIX_simcall_pre(&self->simcall, 0);
1808     }
1809     return self->simcall.result.sgsz;
1810   }
1811   inline static sg_size_t simcall_BODY_storage_get_used_size(smx_storage_t name) {
1812     smx_process_t self = SIMIX_process_self();
1813     self->simcall.call = SIMCALL_STORAGE_GET_USED_SIZE;
1814     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1815     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1816     self->simcall.args[0].dp = (void*) name;
1817     if (self != simix_global->maestro_process) {
1818       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1819                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1820       SIMIX_process_yield(self);
1821     } else {
1822       SIMIX_simcall_pre(&self->simcall, 0);
1823     }
1824     return self->simcall.result.sgsz;
1825   }
1826   inline static xbt_dict_t simcall_BODY_storage_get_properties(smx_storage_t storage) {
1827     smx_process_t self = SIMIX_process_self();
1828     self->simcall.call = SIMCALL_STORAGE_GET_PROPERTIES;
1829     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1830     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1831     self->simcall.args[0].dp = (void*) storage;
1832     if (self != simix_global->maestro_process) {
1833       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1834                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1835       SIMIX_process_yield(self);
1836     } else {
1837       SIMIX_simcall_pre(&self->simcall, 0);
1838     }
1839     return self->simcall.result.dp;
1840   }
1841   inline static xbt_dict_t simcall_BODY_storage_get_content(smx_storage_t storage) {
1842     smx_process_t self = SIMIX_process_self();
1843     self->simcall.call = SIMCALL_STORAGE_GET_CONTENT;
1844     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1845     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1846     self->simcall.args[0].dp = (void*) storage;
1847     if (self != simix_global->maestro_process) {
1848       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1849                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1850       SIMIX_process_yield(self);
1851     } else {
1852       SIMIX_simcall_pre(&self->simcall, 0);
1853     }
1854     return self->simcall.result.dp;
1855   }
1856   inline static xbt_dict_t simcall_BODY_asr_get_properties(const char* name) {
1857     smx_process_t self = SIMIX_process_self();
1858     self->simcall.call = SIMCALL_ASR_GET_PROPERTIES;
1859     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1860     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1861     self->simcall.args[0].cc = (const char*) name;
1862     if (self != simix_global->maestro_process) {
1863       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1864                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1865       SIMIX_process_yield(self);
1866     } else {
1867       SIMIX_simcall_pre(&self->simcall, 0);
1868     }
1869     return self->simcall.result.dp;
1870   }
1871 #ifdef HAVE_LATENCY_BOUND_TRACKING
1872   inline static int simcall_BODY_comm_is_latency_bounded(smx_action_t comm) {
1873     smx_process_t self = SIMIX_process_self();
1874     self->simcall.call = SIMCALL_COMM_IS_LATENCY_BOUNDED;
1875     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1876     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1877     self->simcall.args[0].dp = (void*) comm;
1878     if (self != simix_global->maestro_process) {
1879       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1880                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1881       SIMIX_process_yield(self);
1882     } else {
1883       SIMIX_simcall_pre(&self->simcall, 0);
1884     }
1885     return self->simcall.result.i;
1886   }
1887 #endif
1888
1889 #ifdef HAVE_TRACING
1890   inline static void simcall_BODY_set_category(smx_action_t action, const char* category) {
1891     smx_process_t self = SIMIX_process_self();
1892     self->simcall.call = SIMCALL_SET_CATEGORY;
1893     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1894     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1895     self->simcall.args[0].dp = (void*) action;
1896     self->simcall.args[1].cc = (const char*) category;
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_pre(&self->simcall, 0);
1903     }
1904
1905   }
1906 #endif
1907
1908 #ifdef HAVE_MC
1909   inline static void* simcall_BODY_mc_snapshot() {
1910     smx_process_t self = SIMIX_process_self();
1911     self->simcall.call = SIMCALL_MC_SNAPSHOT;
1912     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1913     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1914
1915     if (self != simix_global->maestro_process) {
1916       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1917                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1918       SIMIX_process_yield(self);
1919     } else {
1920       SIMIX_simcall_pre(&self->simcall, 0);
1921     }
1922     return self->simcall.result.dp;
1923   }
1924   inline static int simcall_BODY_mc_compare_snapshots(void* s1, void* s2) {
1925     smx_process_t self = SIMIX_process_self();
1926     self->simcall.call = SIMCALL_MC_COMPARE_SNAPSHOTS;
1927     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1928     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1929     self->simcall.args[0].dp = (void*) s1;
1930     self->simcall.args[1].dp = (void*) s2;
1931     if (self != simix_global->maestro_process) {
1932       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1933                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1934       SIMIX_process_yield(self);
1935     } else {
1936       SIMIX_simcall_pre(&self->simcall, 0);
1937     }
1938     return self->simcall.result.i;
1939   }
1940   inline static int simcall_BODY_mc_random(int min, int max) {
1941     smx_process_t self = SIMIX_process_self();
1942     self->simcall.call = SIMCALL_MC_RANDOM;
1943     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1944     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1945     self->simcall.args[0].i = (int) min;
1946     self->simcall.args[1].i = (int) max;
1947     if (self != simix_global->maestro_process) {
1948       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1949                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1950       SIMIX_process_yield(self);
1951     } else {
1952       SIMIX_simcall_pre(&self->simcall, 0);
1953     }
1954     return self->simcall.result.i;
1955   }
1956 #endif