Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Add MSG_process_join [#13601]
[simgrid.git] / 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 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) src;
1091     self->simcall.args[2].i = (int) tag;
1092     self->simcall.args[3].fp = (FPtr) match_fun;
1093     self->simcall.args[4].dp = (void*) data;
1094     if (self != simix_global->maestro_process) {
1095       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1096                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1097       SIMIX_process_yield(self);
1098     } else {
1099       SIMIX_simcall_pre(&self->simcall, 0);
1100     }    
1101     return self->simcall.result.dp;
1102   }
1103   inline static void simcall_BODY_comm_send(smx_rdv_t rdv, double task_size, double rate, void* src_buff, size_t src_buff_size, simix_match_func_t match_fun, void* data, double timeout) {
1104     smx_process_t self = SIMIX_process_self();
1105     self->simcall.call = SIMCALL_COMM_SEND;
1106     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1107     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1108     self->simcall.args[0].dp = (void*) rdv;
1109     self->simcall.args[1].d = (double) task_size;
1110     self->simcall.args[2].d = (double) rate;
1111     self->simcall.args[3].dp = (void*) src_buff;
1112     self->simcall.args[4].sz = (size_t) src_buff_size;
1113     self->simcall.args[5].fp = (FPtr) match_fun;
1114     self->simcall.args[6].dp = (void*) data;
1115     self->simcall.args[7].d = (double) timeout;
1116     if (self != simix_global->maestro_process) {
1117       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1118                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1119       SIMIX_process_yield(self);
1120     } else {
1121       SIMIX_simcall_pre(&self->simcall, 0);
1122     }    
1123     
1124   }
1125   inline static smx_action_t simcall_BODY_comm_isend(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, void* data, int detached) {
1126     smx_process_t self = SIMIX_process_self();
1127     self->simcall.call = SIMCALL_COMM_ISEND;
1128     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1129     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1130     self->simcall.args[0].dp = (void*) rdv;
1131     self->simcall.args[1].d = (double) task_size;
1132     self->simcall.args[2].d = (double) rate;
1133     self->simcall.args[3].dp = (void*) src_buff;
1134     self->simcall.args[4].sz = (size_t) src_buff_size;
1135     self->simcall.args[5].fp = (FPtr) match_fun;
1136     self->simcall.args[6].fp = (FPtr) clean_fun;
1137     self->simcall.args[7].dp = (void*) data;
1138     self->simcall.args[8].i = (int) detached;
1139     if (self != simix_global->maestro_process) {
1140       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1141                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1142       SIMIX_process_yield(self);
1143     } else {
1144       SIMIX_simcall_pre(&self->simcall, 0);
1145     }    
1146     return self->simcall.result.dp;
1147   }
1148   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, void* data, double timeout, double rate) {
1149     smx_process_t self = SIMIX_process_self();
1150     self->simcall.call = SIMCALL_COMM_RECV;
1151     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1152     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1153     self->simcall.args[0].dp = (void*) rdv;
1154     self->simcall.args[1].dp = (void*) dst_buff;
1155     self->simcall.args[2].dp = (void*) dst_buff_size;
1156     self->simcall.args[3].fp = (FPtr) match_fun;
1157     self->simcall.args[4].dp = (void*) data;
1158     self->simcall.args[5].d = (double) timeout;
1159     self->simcall.args[6].d = (double) rate;
1160     if (self != simix_global->maestro_process) {
1161       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1162                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1163       SIMIX_process_yield(self);
1164     } else {
1165       SIMIX_simcall_pre(&self->simcall, 0);
1166     }    
1167     
1168   }
1169   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, void* data, double rate) {
1170     smx_process_t self = SIMIX_process_self();
1171     self->simcall.call = SIMCALL_COMM_IRECV;
1172     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1173     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1174     self->simcall.args[0].dp = (void*) rdv;
1175     self->simcall.args[1].dp = (void*) dst_buff;
1176     self->simcall.args[2].dp = (void*) dst_buff_size;
1177     self->simcall.args[3].fp = (FPtr) match_fun;
1178     self->simcall.args[4].dp = (void*) data;
1179     self->simcall.args[5].d = (double) rate;
1180     if (self != simix_global->maestro_process) {
1181       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1182                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1183       SIMIX_process_yield(self);
1184     } else {
1185       SIMIX_simcall_pre(&self->simcall, 0);
1186     }    
1187     return self->simcall.result.dp;
1188   }
1189   inline static void simcall_BODY_comm_cancel(smx_action_t comm) {
1190     smx_process_t self = SIMIX_process_self();
1191     self->simcall.call = SIMCALL_COMM_CANCEL;
1192     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1193     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1194     self->simcall.args[0].dp = (void*) comm;
1195     if (self != simix_global->maestro_process) {
1196       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1197                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1198       SIMIX_process_yield(self);
1199     } else {
1200       SIMIX_simcall_pre(&self->simcall, 0);
1201     }    
1202     
1203   }
1204   inline static int simcall_BODY_comm_waitany(xbt_dynar_t comms) {
1205     smx_process_t self = SIMIX_process_self();
1206     self->simcall.call = SIMCALL_COMM_WAITANY;
1207     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1208     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1209     self->simcall.args[0].dp = (void*) comms;
1210     if (self != simix_global->maestro_process) {
1211       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1212                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1213       SIMIX_process_yield(self);
1214     } else {
1215       SIMIX_simcall_pre(&self->simcall, 0);
1216     }    
1217     return self->simcall.result.i;
1218   }
1219   inline static void simcall_BODY_comm_wait(smx_action_t comm, double timeout) {
1220     smx_process_t self = SIMIX_process_self();
1221     self->simcall.call = SIMCALL_COMM_WAIT;
1222     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1223     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1224     self->simcall.args[0].dp = (void*) comm;
1225     self->simcall.args[1].d = (double) timeout;
1226     if (self != simix_global->maestro_process) {
1227       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1228                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1229       SIMIX_process_yield(self);
1230     } else {
1231       SIMIX_simcall_pre(&self->simcall, 0);
1232     }    
1233     
1234   }
1235   inline static int simcall_BODY_comm_test(smx_action_t comm) {
1236     smx_process_t self = SIMIX_process_self();
1237     self->simcall.call = SIMCALL_COMM_TEST;
1238     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1239     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1240     self->simcall.args[0].dp = (void*) comm;
1241     if (self != simix_global->maestro_process) {
1242       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1243                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1244       SIMIX_process_yield(self);
1245     } else {
1246       SIMIX_simcall_pre(&self->simcall, 0);
1247     }    
1248     return self->simcall.result.i;
1249   }
1250   inline static int simcall_BODY_comm_testany(xbt_dynar_t comms) {
1251     smx_process_t self = SIMIX_process_self();
1252     self->simcall.call = SIMCALL_COMM_TESTANY;
1253     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1254     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1255     self->simcall.args[0].dp = (void*) comms;
1256     if (self != simix_global->maestro_process) {
1257       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1258                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1259       SIMIX_process_yield(self);
1260     } else {
1261       SIMIX_simcall_pre(&self->simcall, 0);
1262     }    
1263     return self->simcall.result.i;
1264   }
1265   inline static double simcall_BODY_comm_get_remains(smx_action_t comm) {
1266     smx_process_t self = SIMIX_process_self();
1267     self->simcall.call = SIMCALL_COMM_GET_REMAINS;
1268     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1269     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1270     self->simcall.args[0].dp = (void*) comm;
1271     if (self != simix_global->maestro_process) {
1272       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1273                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1274       SIMIX_process_yield(self);
1275     } else {
1276       SIMIX_simcall_pre(&self->simcall, 0);
1277     }    
1278     return self->simcall.result.d;
1279   }
1280   inline static int simcall_BODY_comm_get_state(smx_action_t comm) {
1281     smx_process_t self = SIMIX_process_self();
1282     self->simcall.call = SIMCALL_COMM_GET_STATE;
1283     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1284     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1285     self->simcall.args[0].dp = (void*) comm;
1286     if (self != simix_global->maestro_process) {
1287       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1288                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1289       SIMIX_process_yield(self);
1290     } else {
1291       SIMIX_simcall_pre(&self->simcall, 0);
1292     }    
1293     return self->simcall.result.i;
1294   }
1295   inline static void* simcall_BODY_comm_get_src_data(smx_action_t comm) {
1296     smx_process_t self = SIMIX_process_self();
1297     self->simcall.call = SIMCALL_COMM_GET_SRC_DATA;
1298     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1299     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1300     self->simcall.args[0].dp = (void*) comm;
1301     if (self != simix_global->maestro_process) {
1302       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1303                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1304       SIMIX_process_yield(self);
1305     } else {
1306       SIMIX_simcall_pre(&self->simcall, 0);
1307     }    
1308     return self->simcall.result.dp;
1309   }
1310   inline static void* simcall_BODY_comm_get_dst_data(smx_action_t comm) {
1311     smx_process_t self = SIMIX_process_self();
1312     self->simcall.call = SIMCALL_COMM_GET_DST_DATA;
1313     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1314     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1315     self->simcall.args[0].dp = (void*) comm;
1316     if (self != simix_global->maestro_process) {
1317       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1318                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1319       SIMIX_process_yield(self);
1320     } else {
1321       SIMIX_simcall_pre(&self->simcall, 0);
1322     }    
1323     return self->simcall.result.dp;
1324   }
1325   inline static smx_process_t simcall_BODY_comm_get_src_proc(smx_action_t comm) {
1326     smx_process_t self = SIMIX_process_self();
1327     self->simcall.call = SIMCALL_COMM_GET_SRC_PROC;
1328     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1329     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1330     self->simcall.args[0].dp = (void*) comm;
1331     if (self != simix_global->maestro_process) {
1332       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1333                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1334       SIMIX_process_yield(self);
1335     } else {
1336       SIMIX_simcall_pre(&self->simcall, 0);
1337     }    
1338     return self->simcall.result.dp;
1339   }
1340   inline static smx_process_t simcall_BODY_comm_get_dst_proc(smx_action_t comm) {
1341     smx_process_t self = SIMIX_process_self();
1342     self->simcall.call = SIMCALL_COMM_GET_DST_PROC;
1343     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1344     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1345     self->simcall.args[0].dp = (void*) comm;
1346     if (self != simix_global->maestro_process) {
1347       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1348                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1349       SIMIX_process_yield(self);
1350     } else {
1351       SIMIX_simcall_pre(&self->simcall, 0);
1352     }    
1353     return self->simcall.result.dp;
1354   }
1355   inline static smx_mutex_t simcall_BODY_mutex_init() {
1356     smx_process_t self = SIMIX_process_self();
1357     self->simcall.call = SIMCALL_MUTEX_INIT;
1358     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1359     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1360
1361     if (self != simix_global->maestro_process) {
1362       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1363                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1364       SIMIX_process_yield(self);
1365     } else {
1366       SIMIX_simcall_pre(&self->simcall, 0);
1367     }    
1368     return self->simcall.result.dp;
1369   }
1370   inline static void simcall_BODY_mutex_destroy(smx_mutex_t mutex) {
1371     smx_process_t self = SIMIX_process_self();
1372     self->simcall.call = SIMCALL_MUTEX_DESTROY;
1373     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1374     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1375     self->simcall.args[0].dp = (void*) mutex;
1376     if (self != simix_global->maestro_process) {
1377       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1378                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1379       SIMIX_process_yield(self);
1380     } else {
1381       SIMIX_simcall_pre(&self->simcall, 0);
1382     }    
1383     
1384   }
1385   inline static void simcall_BODY_mutex_lock(smx_mutex_t mutex) {
1386     smx_process_t self = SIMIX_process_self();
1387     self->simcall.call = SIMCALL_MUTEX_LOCK;
1388     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1389     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1390     self->simcall.args[0].dp = (void*) mutex;
1391     if (self != simix_global->maestro_process) {
1392       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1393                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1394       SIMIX_process_yield(self);
1395     } else {
1396       SIMIX_simcall_pre(&self->simcall, 0);
1397     }    
1398     
1399   }
1400   inline static int simcall_BODY_mutex_trylock(smx_mutex_t mutex) {
1401     smx_process_t self = SIMIX_process_self();
1402     self->simcall.call = SIMCALL_MUTEX_TRYLOCK;
1403     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1404     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1405     self->simcall.args[0].dp = (void*) mutex;
1406     if (self != simix_global->maestro_process) {
1407       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1408                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1409       SIMIX_process_yield(self);
1410     } else {
1411       SIMIX_simcall_pre(&self->simcall, 0);
1412     }    
1413     return self->simcall.result.i;
1414   }
1415   inline static void simcall_BODY_mutex_unlock(smx_mutex_t mutex) {
1416     smx_process_t self = SIMIX_process_self();
1417     self->simcall.call = SIMCALL_MUTEX_UNLOCK;
1418     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1419     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1420     self->simcall.args[0].dp = (void*) mutex;
1421     if (self != simix_global->maestro_process) {
1422       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1423                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1424       SIMIX_process_yield(self);
1425     } else {
1426       SIMIX_simcall_pre(&self->simcall, 0);
1427     }    
1428     
1429   }
1430   inline static smx_cond_t simcall_BODY_cond_init() {
1431     smx_process_t self = SIMIX_process_self();
1432     self->simcall.call = SIMCALL_COND_INIT;
1433     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1434     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1435
1436     if (self != simix_global->maestro_process) {
1437       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1438                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1439       SIMIX_process_yield(self);
1440     } else {
1441       SIMIX_simcall_pre(&self->simcall, 0);
1442     }    
1443     return self->simcall.result.dp;
1444   }
1445   inline static void simcall_BODY_cond_destroy(smx_cond_t cond) {
1446     smx_process_t self = SIMIX_process_self();
1447     self->simcall.call = SIMCALL_COND_DESTROY;
1448     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1449     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1450     self->simcall.args[0].dp = (void*) cond;
1451     if (self != simix_global->maestro_process) {
1452       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1453                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1454       SIMIX_process_yield(self);
1455     } else {
1456       SIMIX_simcall_pre(&self->simcall, 0);
1457     }    
1458     
1459   }
1460   inline static void simcall_BODY_cond_signal(smx_cond_t cond) {
1461     smx_process_t self = SIMIX_process_self();
1462     self->simcall.call = SIMCALL_COND_SIGNAL;
1463     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1464     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1465     self->simcall.args[0].dp = (void*) cond;
1466     if (self != simix_global->maestro_process) {
1467       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1468                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1469       SIMIX_process_yield(self);
1470     } else {
1471       SIMIX_simcall_pre(&self->simcall, 0);
1472     }    
1473     
1474   }
1475   inline static void simcall_BODY_cond_wait(smx_cond_t cond, smx_mutex_t mutex) {
1476     smx_process_t self = SIMIX_process_self();
1477     self->simcall.call = SIMCALL_COND_WAIT;
1478     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1479     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1480     self->simcall.args[0].dp = (void*) cond;
1481     self->simcall.args[1].dp = (void*) mutex;
1482     if (self != simix_global->maestro_process) {
1483       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1484                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1485       SIMIX_process_yield(self);
1486     } else {
1487       SIMIX_simcall_pre(&self->simcall, 0);
1488     }    
1489     
1490   }
1491   inline static void simcall_BODY_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double timeout) {
1492     smx_process_t self = SIMIX_process_self();
1493     self->simcall.call = SIMCALL_COND_WAIT_TIMEOUT;
1494     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1495     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1496     self->simcall.args[0].dp = (void*) cond;
1497     self->simcall.args[1].dp = (void*) mutex;
1498     self->simcall.args[2].d = (double) timeout;
1499     if (self != simix_global->maestro_process) {
1500       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1501                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1502       SIMIX_process_yield(self);
1503     } else {
1504       SIMIX_simcall_pre(&self->simcall, 0);
1505     }    
1506     
1507   }
1508   inline static void simcall_BODY_cond_broadcast(smx_cond_t cond) {
1509     smx_process_t self = SIMIX_process_self();
1510     self->simcall.call = SIMCALL_COND_BROADCAST;
1511     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1512     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1513     self->simcall.args[0].dp = (void*) cond;
1514     if (self != simix_global->maestro_process) {
1515       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1516                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1517       SIMIX_process_yield(self);
1518     } else {
1519       SIMIX_simcall_pre(&self->simcall, 0);
1520     }    
1521     
1522   }
1523   inline static smx_sem_t simcall_BODY_sem_init(int capacity) {
1524     smx_process_t self = SIMIX_process_self();
1525     self->simcall.call = SIMCALL_SEM_INIT;
1526     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1527     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1528     self->simcall.args[0].i = (int) capacity;
1529     if (self != simix_global->maestro_process) {
1530       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1531                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1532       SIMIX_process_yield(self);
1533     } else {
1534       SIMIX_simcall_pre(&self->simcall, 0);
1535     }    
1536     return self->simcall.result.dp;
1537   }
1538   inline static void simcall_BODY_sem_destroy(smx_sem_t sem) {
1539     smx_process_t self = SIMIX_process_self();
1540     self->simcall.call = SIMCALL_SEM_DESTROY;
1541     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1542     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1543     self->simcall.args[0].dp = (void*) sem;
1544     if (self != simix_global->maestro_process) {
1545       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1546                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1547       SIMIX_process_yield(self);
1548     } else {
1549       SIMIX_simcall_pre(&self->simcall, 0);
1550     }    
1551     
1552   }
1553   inline static void simcall_BODY_sem_release(smx_sem_t sem) {
1554     smx_process_t self = SIMIX_process_self();
1555     self->simcall.call = SIMCALL_SEM_RELEASE;
1556     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1557     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1558     self->simcall.args[0].dp = (void*) sem;
1559     if (self != simix_global->maestro_process) {
1560       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1561                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1562       SIMIX_process_yield(self);
1563     } else {
1564       SIMIX_simcall_pre(&self->simcall, 0);
1565     }    
1566     
1567   }
1568   inline static int simcall_BODY_sem_would_block(smx_sem_t sem) {
1569     smx_process_t self = SIMIX_process_self();
1570     self->simcall.call = SIMCALL_SEM_WOULD_BLOCK;
1571     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1572     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1573     self->simcall.args[0].dp = (void*) sem;
1574     if (self != simix_global->maestro_process) {
1575       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1576                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1577       SIMIX_process_yield(self);
1578     } else {
1579       SIMIX_simcall_pre(&self->simcall, 0);
1580     }    
1581     return self->simcall.result.i;
1582   }
1583   inline static void simcall_BODY_sem_acquire(smx_sem_t sem) {
1584     smx_process_t self = SIMIX_process_self();
1585     self->simcall.call = SIMCALL_SEM_ACQUIRE;
1586     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1587     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1588     self->simcall.args[0].dp = (void*) sem;
1589     if (self != simix_global->maestro_process) {
1590       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1591                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1592       SIMIX_process_yield(self);
1593     } else {
1594       SIMIX_simcall_pre(&self->simcall, 0);
1595     }    
1596     
1597   }
1598   inline static void simcall_BODY_sem_acquire_timeout(smx_sem_t sem, double timeout) {
1599     smx_process_t self = SIMIX_process_self();
1600     self->simcall.call = SIMCALL_SEM_ACQUIRE_TIMEOUT;
1601     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1602     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1603     self->simcall.args[0].dp = (void*) sem;
1604     self->simcall.args[1].d = (double) timeout;
1605     if (self != simix_global->maestro_process) {
1606       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1607                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1608       SIMIX_process_yield(self);
1609     } else {
1610       SIMIX_simcall_pre(&self->simcall, 0);
1611     }    
1612     
1613   }
1614   inline static int simcall_BODY_sem_get_capacity(smx_sem_t sem) {
1615     smx_process_t self = SIMIX_process_self();
1616     self->simcall.call = SIMCALL_SEM_GET_CAPACITY;
1617     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1618     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1619     self->simcall.args[0].dp = (void*) sem;
1620     if (self != simix_global->maestro_process) {
1621       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1622                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1623       SIMIX_process_yield(self);
1624     } else {
1625       SIMIX_simcall_pre(&self->simcall, 0);
1626     }    
1627     return self->simcall.result.i;
1628   }
1629   inline static sg_size_t simcall_BODY_file_read(smx_file_t fd, sg_size_t size, smx_host_t host) {
1630     smx_process_t self = SIMIX_process_self();
1631     self->simcall.call = SIMCALL_FILE_READ;
1632     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1633     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1634     self->simcall.args[0].dp = (void*) fd;
1635     self->simcall.args[1].sgsz = (sg_size_t) size;
1636     self->simcall.args[2].dp = (void*) host;
1637     if (self != simix_global->maestro_process) {
1638       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1639                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1640       SIMIX_process_yield(self);
1641     } else {
1642       SIMIX_simcall_pre(&self->simcall, 0);
1643     }    
1644     return self->simcall.result.sgsz;
1645   }
1646   inline static sg_size_t simcall_BODY_file_write(smx_file_t fd, sg_size_t size, smx_host_t host) {
1647     smx_process_t self = SIMIX_process_self();
1648     self->simcall.call = SIMCALL_FILE_WRITE;
1649     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1650     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1651     self->simcall.args[0].dp = (void*) fd;
1652     self->simcall.args[1].sgsz = (sg_size_t) size;
1653     self->simcall.args[2].dp = (void*) host;
1654     if (self != simix_global->maestro_process) {
1655       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1656                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1657       SIMIX_process_yield(self);
1658     } else {
1659       SIMIX_simcall_pre(&self->simcall, 0);
1660     }    
1661     return self->simcall.result.sgsz;
1662   }
1663   inline static smx_file_t simcall_BODY_file_open(const char* fullpath, smx_host_t host) {
1664     smx_process_t self = SIMIX_process_self();
1665     self->simcall.call = SIMCALL_FILE_OPEN;
1666     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1667     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1668     self->simcall.args[0].cc = (const char*) fullpath;
1669     self->simcall.args[1].dp = (void*) host;
1670     if (self != simix_global->maestro_process) {
1671       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1672                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1673       SIMIX_process_yield(self);
1674     } else {
1675       SIMIX_simcall_pre(&self->simcall, 0);
1676     }    
1677     return self->simcall.result.dp;
1678   }
1679   inline static int simcall_BODY_file_close(smx_file_t fd, smx_host_t host) {
1680     smx_process_t self = SIMIX_process_self();
1681     self->simcall.call = SIMCALL_FILE_CLOSE;
1682     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1683     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1684     self->simcall.args[0].dp = (void*) fd;
1685     self->simcall.args[1].dp = (void*) host;
1686     if (self != simix_global->maestro_process) {
1687       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1688                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1689       SIMIX_process_yield(self);
1690     } else {
1691       SIMIX_simcall_pre(&self->simcall, 0);
1692     }    
1693     return self->simcall.result.i;
1694   }
1695   inline static int simcall_BODY_file_unlink(smx_file_t fd) {
1696     smx_process_t self = SIMIX_process_self();
1697     self->simcall.call = SIMCALL_FILE_UNLINK;
1698     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1699     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1700     self->simcall.args[0].dp = (void*) fd;
1701     if (self != simix_global->maestro_process) {
1702       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1703                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1704       SIMIX_process_yield(self);
1705     } else {
1706       SIMIX_simcall_pre(&self->simcall, 0);
1707     }    
1708     return self->simcall.result.i;
1709   }
1710   inline static sg_size_t simcall_BODY_file_get_size(smx_file_t fd) {
1711     smx_process_t self = SIMIX_process_self();
1712     self->simcall.call = SIMCALL_FILE_GET_SIZE;
1713     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1714     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1715     self->simcall.args[0].dp = (void*) fd;
1716     if (self != simix_global->maestro_process) {
1717       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1718                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1719       SIMIX_process_yield(self);
1720     } else {
1721       SIMIX_simcall_pre(&self->simcall, 0);
1722     }    
1723     return self->simcall.result.sgsz;
1724   }
1725   inline static sg_size_t simcall_BODY_file_tell(smx_file_t fd) {
1726     smx_process_t self = SIMIX_process_self();
1727     self->simcall.call = SIMCALL_FILE_TELL;
1728     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1729     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1730     self->simcall.args[0].dp = (void*) fd;
1731     if (self != simix_global->maestro_process) {
1732       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1733                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1734       SIMIX_process_yield(self);
1735     } else {
1736       SIMIX_simcall_pre(&self->simcall, 0);
1737     }    
1738     return self->simcall.result.sgsz;
1739   }
1740   inline static int simcall_BODY_file_seek(smx_file_t fd, sg_size_t offset, int origin) {
1741     smx_process_t self = SIMIX_process_self();
1742     self->simcall.call = SIMCALL_FILE_SEEK;
1743     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1744     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1745     self->simcall.args[0].dp = (void*) fd;
1746     self->simcall.args[1].sgsz = (sg_size_t) offset;
1747     self->simcall.args[2].i = (int) origin;
1748     if (self != simix_global->maestro_process) {
1749       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1750                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1751       SIMIX_process_yield(self);
1752     } else {
1753       SIMIX_simcall_pre(&self->simcall, 0);
1754     }    
1755     return self->simcall.result.i;
1756   }
1757   inline static xbt_dynar_t simcall_BODY_file_get_info(smx_file_t fd) {
1758     smx_process_t self = SIMIX_process_self();
1759     self->simcall.call = SIMCALL_FILE_GET_INFO;
1760     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1761     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1762     self->simcall.args[0].dp = (void*) fd;
1763     if (self != simix_global->maestro_process) {
1764       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1765                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1766       SIMIX_process_yield(self);
1767     } else {
1768       SIMIX_simcall_pre(&self->simcall, 0);
1769     }    
1770     return self->simcall.result.dp;
1771   }
1772   inline static int simcall_BODY_file_move(smx_file_t fd, const char* fullpath) {
1773     smx_process_t self = SIMIX_process_self();
1774     self->simcall.call = SIMCALL_FILE_MOVE;
1775     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1776     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1777     self->simcall.args[0].dp = (void*) fd;
1778     self->simcall.args[1].cc = (const char*) fullpath;
1779     if (self != simix_global->maestro_process) {
1780       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1781                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1782       SIMIX_process_yield(self);
1783     } else {
1784       SIMIX_simcall_pre(&self->simcall, 0);
1785     }    
1786     return self->simcall.result.i;
1787   }
1788   inline static sg_size_t simcall_BODY_storage_get_free_size(smx_storage_t storage) {
1789     smx_process_t self = SIMIX_process_self();
1790     self->simcall.call = SIMCALL_STORAGE_GET_FREE_SIZE;
1791     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1792     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1793     self->simcall.args[0].dp = (void*) storage;
1794     if (self != simix_global->maestro_process) {
1795       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1796                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1797       SIMIX_process_yield(self);
1798     } else {
1799       SIMIX_simcall_pre(&self->simcall, 0);
1800     }    
1801     return self->simcall.result.sgsz;
1802   }
1803   inline static sg_size_t simcall_BODY_storage_get_used_size(smx_storage_t name) {
1804     smx_process_t self = SIMIX_process_self();
1805     self->simcall.call = SIMCALL_STORAGE_GET_USED_SIZE;
1806     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1807     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1808     self->simcall.args[0].dp = (void*) name;
1809     if (self != simix_global->maestro_process) {
1810       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1811                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1812       SIMIX_process_yield(self);
1813     } else {
1814       SIMIX_simcall_pre(&self->simcall, 0);
1815     }    
1816     return self->simcall.result.sgsz;
1817   }
1818   inline static xbt_dict_t simcall_BODY_storage_get_properties(smx_storage_t storage) {
1819     smx_process_t self = SIMIX_process_self();
1820     self->simcall.call = SIMCALL_STORAGE_GET_PROPERTIES;
1821     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1822     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1823     self->simcall.args[0].dp = (void*) storage;
1824     if (self != simix_global->maestro_process) {
1825       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1826                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1827       SIMIX_process_yield(self);
1828     } else {
1829       SIMIX_simcall_pre(&self->simcall, 0);
1830     }    
1831     return self->simcall.result.dp;
1832   }
1833   inline static xbt_dict_t simcall_BODY_storage_get_content(smx_storage_t storage) {
1834     smx_process_t self = SIMIX_process_self();
1835     self->simcall.call = SIMCALL_STORAGE_GET_CONTENT;
1836     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1837     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1838     self->simcall.args[0].dp = (void*) storage;
1839     if (self != simix_global->maestro_process) {
1840       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1841                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1842       SIMIX_process_yield(self);
1843     } else {
1844       SIMIX_simcall_pre(&self->simcall, 0);
1845     }    
1846     return self->simcall.result.dp;
1847   }
1848   inline static xbt_dict_t simcall_BODY_asr_get_properties(const char* name) {
1849     smx_process_t self = SIMIX_process_self();
1850     self->simcall.call = SIMCALL_ASR_GET_PROPERTIES;
1851     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1852     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1853     self->simcall.args[0].cc = (const char*) name;
1854     if (self != simix_global->maestro_process) {
1855       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1856                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1857       SIMIX_process_yield(self);
1858     } else {
1859       SIMIX_simcall_pre(&self->simcall, 0);
1860     }    
1861     return self->simcall.result.dp;
1862   }
1863 #ifdef HAVE_LATENCY_BOUND_TRACKING
1864   inline static int simcall_BODY_comm_is_latency_bounded(smx_action_t comm) {
1865     smx_process_t self = SIMIX_process_self();
1866     self->simcall.call = SIMCALL_COMM_IS_LATENCY_BOUNDED;
1867     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1868     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1869     self->simcall.args[0].dp = (void*) comm;
1870     if (self != simix_global->maestro_process) {
1871       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1872                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1873       SIMIX_process_yield(self);
1874     } else {
1875       SIMIX_simcall_pre(&self->simcall, 0);
1876     }    
1877     return self->simcall.result.i;
1878   }
1879 #endif
1880
1881 #ifdef HAVE_TRACING
1882   inline static void simcall_BODY_set_category(smx_action_t action, const char* category) {
1883     smx_process_t self = SIMIX_process_self();
1884     self->simcall.call = SIMCALL_SET_CATEGORY;
1885     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1886     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1887     self->simcall.args[0].dp = (void*) action;
1888     self->simcall.args[1].cc = (const char*) category;
1889     if (self != simix_global->maestro_process) {
1890       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1891                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1892       SIMIX_process_yield(self);
1893     } else {
1894       SIMIX_simcall_pre(&self->simcall, 0);
1895     }    
1896     
1897   }
1898 #endif
1899
1900 #ifdef HAVE_MC
1901   inline static void* simcall_BODY_mc_snapshot() {
1902     smx_process_t self = SIMIX_process_self();
1903     self->simcall.call = SIMCALL_MC_SNAPSHOT;
1904     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1905     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1906
1907     if (self != simix_global->maestro_process) {
1908       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1909                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1910       SIMIX_process_yield(self);
1911     } else {
1912       SIMIX_simcall_pre(&self->simcall, 0);
1913     }    
1914     return self->simcall.result.dp;
1915   }
1916   inline static int simcall_BODY_mc_compare_snapshots(void* s1, void* s2) {
1917     smx_process_t self = SIMIX_process_self();
1918     self->simcall.call = SIMCALL_MC_COMPARE_SNAPSHOTS;
1919     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1920     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1921     self->simcall.args[0].dp = (void*) s1;
1922     self->simcall.args[1].dp = (void*) s2;
1923     if (self != simix_global->maestro_process) {
1924       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1925                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1926       SIMIX_process_yield(self);
1927     } else {
1928       SIMIX_simcall_pre(&self->simcall, 0);
1929     }    
1930     return self->simcall.result.i;
1931   }
1932   inline static int simcall_BODY_mc_random(int min, int max) {
1933     smx_process_t self = SIMIX_process_self();
1934     self->simcall.call = SIMCALL_MC_RANDOM;
1935     memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1936     memset(self->simcall.args, 0, sizeof(self->simcall.args));
1937     self->simcall.args[0].i = (int) min;
1938     self->simcall.args[1].i = (int) max;
1939     if (self != simix_global->maestro_process) {
1940       XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1941                 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1942       SIMIX_process_yield(self);
1943     } else {
1944       SIMIX_simcall_pre(&self->simcall, 0);
1945     }    
1946     return self->simcall.result.i;
1947   }
1948 #endif