Logo AND Algorithmique Numérique Distribuée

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