1 /**********************************************************************/
2 /* File generated by src/simix/simcalls.py from src/simix/simcalls.in */
4 /* DO NOT EVER CHANGE THIS FILE */
6 /* change simcalls specification in src/simix/simcalls.in */
7 /**********************************************************************/
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.
13 * That's not about http://en.wikipedia.org/wiki/Poop, despite the odor :)
16 #include "smx_private.h"
17 #include "mc/mc_forward.h"
20 inline static smx_host_t simcall_BODY_host_get_by_name(const char* name) {
21 smx_process_t self = SIMIX_process_self();
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 */
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);
36 SIMIX_simcall_handle(&self->simcall, 0);
38 return self->simcall.result.dp;
41 inline static const char* simcall_BODY_host_get_name(smx_host_t host) {
42 smx_process_t self = SIMIX_process_self();
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 */
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);
57 SIMIX_simcall_handle(&self->simcall, 0);
59 return self->simcall.result.cc;
62 inline static void simcall_BODY_host_on(smx_host_t host) {
63 smx_process_t self = SIMIX_process_self();
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 */
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);
78 SIMIX_simcall_handle(&self->simcall, 0);
83 inline static void simcall_BODY_host_off(smx_host_t host) {
84 smx_process_t self = SIMIX_process_self();
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 */
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);
99 SIMIX_simcall_handle(&self->simcall, 0);
104 inline static xbt_dict_t simcall_BODY_host_get_properties(smx_host_t host) {
105 smx_process_t self = SIMIX_process_self();
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 */
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);
120 SIMIX_simcall_handle(&self->simcall, 0);
122 return self->simcall.result.dp;
125 inline static int simcall_BODY_host_get_core(smx_host_t host) {
126 smx_process_t self = SIMIX_process_self();
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 */
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);
141 SIMIX_simcall_handle(&self->simcall, 0);
143 return self->simcall.result.i;
146 inline static xbt_swag_t simcall_BODY_host_get_process_list(smx_host_t host) {
147 smx_process_t self = SIMIX_process_self();
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 */
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);
162 SIMIX_simcall_handle(&self->simcall, 0);
164 return self->simcall.result.dp;
167 inline static double simcall_BODY_host_get_speed(smx_host_t host) {
168 smx_process_t self = SIMIX_process_self();
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 */
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);
183 SIMIX_simcall_handle(&self->simcall, 0);
185 return self->simcall.result.d;
188 inline static double simcall_BODY_host_get_available_speed(smx_host_t host) {
189 smx_process_t self = SIMIX_process_self();
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 */
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);
204 SIMIX_simcall_handle(&self->simcall, 0);
206 return self->simcall.result.d;
209 inline static int simcall_BODY_host_get_state(smx_host_t host) {
210 smx_process_t self = SIMIX_process_self();
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 */
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);
225 SIMIX_simcall_handle(&self->simcall, 0);
227 return self->simcall.result.i;
230 inline static double simcall_BODY_host_get_current_power_peak(smx_host_t host) {
231 smx_process_t self = SIMIX_process_self();
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 */
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);
246 SIMIX_simcall_handle(&self->simcall, 0);
248 return self->simcall.result.d;
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();
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 */
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);
268 SIMIX_simcall_handle(&self->simcall, 0);
270 return self->simcall.result.d;
273 inline static int simcall_BODY_host_get_nb_pstates(smx_host_t host) {
274 smx_process_t self = SIMIX_process_self();
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 */
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);
289 SIMIX_simcall_handle(&self->simcall, 0);
291 return self->simcall.result.i;
294 inline static double simcall_BODY_host_get_wattmin_at(smx_host_t host, int pstate_index) {
295 smx_process_t self = SIMIX_process_self();
297 /* Go to that function to follow the code flow through the simcall barrier */
298 if (0) SIMIX_host_get_wattmin_at(host, pstate_index);
299 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
301 self->simcall.call = SIMCALL_HOST_GET_WATTMIN_AT;
302 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
303 memset(self->simcall.args, 0, sizeof(self->simcall.args));
304 self->simcall.args[0].dp = (void*) host;
305 self->simcall.args[1].i = (int) pstate_index;
306 if (self != simix_global->maestro_process) {
307 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
308 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
309 SIMIX_process_yield(self);
311 SIMIX_simcall_handle(&self->simcall, 0);
313 return self->simcall.result.d;
316 inline static double simcall_BODY_host_get_wattmax_at(smx_host_t host, int pstate_index) {
317 smx_process_t self = SIMIX_process_self();
319 /* Go to that function to follow the code flow through the simcall barrier */
320 if (0) SIMIX_host_get_wattmax_at(host, pstate_index);
321 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
323 self->simcall.call = SIMCALL_HOST_GET_WATTMAX_AT;
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 self->simcall.args[1].i = (int) pstate_index;
328 if (self != simix_global->maestro_process) {
329 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
330 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
331 SIMIX_process_yield(self);
333 SIMIX_simcall_handle(&self->simcall, 0);
335 return self->simcall.result.d;
338 inline static void simcall_BODY_host_set_pstate(smx_host_t host, int pstate_index) {
339 smx_process_t self = SIMIX_process_self();
341 /* Go to that function to follow the code flow through the simcall barrier */
342 if (0) SIMIX_host_set_pstate(host, pstate_index);
343 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
345 self->simcall.call = SIMCALL_HOST_SET_PSTATE;
346 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
347 memset(self->simcall.args, 0, sizeof(self->simcall.args));
348 self->simcall.args[0].dp = (void*) host;
349 self->simcall.args[1].i = (int) pstate_index;
350 if (self != simix_global->maestro_process) {
351 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
352 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
353 SIMIX_process_yield(self);
355 SIMIX_simcall_handle(&self->simcall, 0);
360 inline static int simcall_BODY_host_get_pstate(smx_host_t host) {
361 smx_process_t self = SIMIX_process_self();
363 /* Go to that function to follow the code flow through the simcall barrier */
364 if (0) SIMIX_host_get_pstate(host);
365 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
367 self->simcall.call = SIMCALL_HOST_GET_PSTATE;
368 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
369 memset(self->simcall.args, 0, sizeof(self->simcall.args));
370 self->simcall.args[0].dp = (void*) host;
371 if (self != simix_global->maestro_process) {
372 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
373 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
374 SIMIX_process_yield(self);
376 SIMIX_simcall_handle(&self->simcall, 0);
378 return self->simcall.result.i;
381 inline static double simcall_BODY_host_get_consumed_energy(smx_host_t host) {
382 smx_process_t self = SIMIX_process_self();
384 /* Go to that function to follow the code flow through the simcall barrier */
385 if (0) SIMIX_host_get_consumed_energy(host);
386 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
388 self->simcall.call = SIMCALL_HOST_GET_CONSUMED_ENERGY;
389 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
390 memset(self->simcall.args, 0, sizeof(self->simcall.args));
391 self->simcall.args[0].dp = (void*) host;
392 if (self != simix_global->maestro_process) {
393 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
394 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
395 SIMIX_process_yield(self);
397 SIMIX_simcall_handle(&self->simcall, 0);
399 return self->simcall.result.d;
402 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) {
403 smx_process_t self = SIMIX_process_self();
405 /* Go to that function to follow the code flow through the simcall barrier */
406 if (0) SIMIX_host_execute(name, host, flops_amount, priority, bound, affinity_mask);
407 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
409 self->simcall.call = SIMCALL_HOST_EXECUTE;
410 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
411 memset(self->simcall.args, 0, sizeof(self->simcall.args));
412 self->simcall.args[0].cc = (const char*) name;
413 self->simcall.args[1].dp = (void*) host;
414 self->simcall.args[2].d = (double) flops_amount;
415 self->simcall.args[3].d = (double) priority;
416 self->simcall.args[4].d = (double) bound;
417 self->simcall.args[5].ul = (unsigned long) affinity_mask;
418 if (self != simix_global->maestro_process) {
419 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
420 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
421 SIMIX_process_yield(self);
423 SIMIX_simcall_handle(&self->simcall, 0);
425 return self->simcall.result.dp;
428 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) {
429 smx_process_t self = SIMIX_process_self();
431 /* Go to that function to follow the code flow through the simcall barrier */
432 if (0) SIMIX_host_parallel_execute(name, host_nb, host_list, flops_amount, bytes_amount, amount, rate);
433 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
435 self->simcall.call = SIMCALL_HOST_PARALLEL_EXECUTE;
436 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
437 memset(self->simcall.args, 0, sizeof(self->simcall.args));
438 self->simcall.args[0].cc = (const char*) name;
439 self->simcall.args[1].i = (int) host_nb;
440 self->simcall.args[2].dp = (void*) host_list;
441 self->simcall.args[3].dp = (void*) flops_amount;
442 self->simcall.args[4].dp = (void*) bytes_amount;
443 self->simcall.args[5].d = (double) amount;
444 self->simcall.args[6].d = (double) rate;
445 if (self != simix_global->maestro_process) {
446 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
447 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
448 SIMIX_process_yield(self);
450 SIMIX_simcall_handle(&self->simcall, 0);
452 return self->simcall.result.dp;
455 inline static void simcall_BODY_host_execution_destroy(smx_synchro_t execution) {
456 smx_process_t self = SIMIX_process_self();
458 /* Go to that function to follow the code flow through the simcall barrier */
459 if (0) SIMIX_host_execution_destroy(execution);
460 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
462 self->simcall.call = SIMCALL_HOST_EXECUTION_DESTROY;
463 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
464 memset(self->simcall.args, 0, sizeof(self->simcall.args));
465 self->simcall.args[0].dp = (void*) execution;
466 if (self != simix_global->maestro_process) {
467 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
468 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
469 SIMIX_process_yield(self);
471 SIMIX_simcall_handle(&self->simcall, 0);
476 inline static void simcall_BODY_host_execution_cancel(smx_synchro_t execution) {
477 smx_process_t self = SIMIX_process_self();
479 /* Go to that function to follow the code flow through the simcall barrier */
480 if (0) SIMIX_host_execution_cancel(execution);
481 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
483 self->simcall.call = SIMCALL_HOST_EXECUTION_CANCEL;
484 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
485 memset(self->simcall.args, 0, sizeof(self->simcall.args));
486 self->simcall.args[0].dp = (void*) execution;
487 if (self != simix_global->maestro_process) {
488 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
489 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
490 SIMIX_process_yield(self);
492 SIMIX_simcall_handle(&self->simcall, 0);
497 inline static double simcall_BODY_host_execution_get_remains(smx_synchro_t execution) {
498 smx_process_t self = SIMIX_process_self();
500 /* Go to that function to follow the code flow through the simcall barrier */
501 if (0) SIMIX_host_execution_get_remains(execution);
502 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
504 self->simcall.call = SIMCALL_HOST_EXECUTION_GET_REMAINS;
505 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
506 memset(self->simcall.args, 0, sizeof(self->simcall.args));
507 self->simcall.args[0].dp = (void*) execution;
508 if (self != simix_global->maestro_process) {
509 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
510 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
511 SIMIX_process_yield(self);
513 SIMIX_simcall_handle(&self->simcall, 0);
515 return self->simcall.result.d;
518 inline static e_smx_state_t simcall_BODY_host_execution_get_state(smx_synchro_t execution) {
519 smx_process_t self = SIMIX_process_self();
521 /* Go to that function to follow the code flow through the simcall barrier */
522 if (0) SIMIX_host_execution_get_state(execution);
523 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
525 self->simcall.call = SIMCALL_HOST_EXECUTION_GET_STATE;
526 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
527 memset(self->simcall.args, 0, sizeof(self->simcall.args));
528 self->simcall.args[0].dp = (void*) execution;
529 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);
534 SIMIX_simcall_handle(&self->simcall, 0);
536 return self->simcall.result.i;
539 inline static void simcall_BODY_host_execution_set_priority(smx_synchro_t execution, double priority) {
540 smx_process_t self = SIMIX_process_self();
542 /* Go to that function to follow the code flow through the simcall barrier */
543 if (0) SIMIX_host_execution_set_priority(execution, priority);
544 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
546 self->simcall.call = SIMCALL_HOST_EXECUTION_SET_PRIORITY;
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].d = (double) priority;
551 if (self != simix_global->maestro_process) {
552 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
553 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
554 SIMIX_process_yield(self);
556 SIMIX_simcall_handle(&self->simcall, 0);
561 inline static void simcall_BODY_host_execution_set_bound(smx_synchro_t execution, double bound) {
562 smx_process_t self = SIMIX_process_self();
564 /* Go to that function to follow the code flow through the simcall barrier */
565 if (0) SIMIX_host_execution_set_bound(execution, bound);
566 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
568 self->simcall.call = SIMCALL_HOST_EXECUTION_SET_BOUND;
569 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
570 memset(self->simcall.args, 0, sizeof(self->simcall.args));
571 self->simcall.args[0].dp = (void*) execution;
572 self->simcall.args[1].d = (double) bound;
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);
578 SIMIX_simcall_handle(&self->simcall, 0);
583 inline static void simcall_BODY_host_execution_set_affinity(smx_synchro_t execution, smx_host_t ws, unsigned long mask) {
584 smx_process_t self = SIMIX_process_self();
586 /* Go to that function to follow the code flow through the simcall barrier */
587 if (0) SIMIX_host_execution_set_affinity(execution, ws, mask);
588 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
590 self->simcall.call = SIMCALL_HOST_EXECUTION_SET_AFFINITY;
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*) execution;
594 self->simcall.args[1].dp = (void*) ws;
595 self->simcall.args[2].ul = (unsigned long) mask;
596 if (self != simix_global->maestro_process) {
597 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
598 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
599 SIMIX_process_yield(self);
601 SIMIX_simcall_handle(&self->simcall, 0);
606 inline static int simcall_BODY_host_execution_wait(smx_synchro_t execution) {
607 smx_process_t self = SIMIX_process_self();
609 /* Go to that function to follow the code flow through the simcall barrier */
610 if (0) simcall_HANDLER_host_execution_wait(&self->simcall, execution);
611 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
613 self->simcall.call = SIMCALL_HOST_EXECUTION_WAIT;
614 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
615 memset(self->simcall.args, 0, sizeof(self->simcall.args));
616 self->simcall.args[0].dp = (void*) execution;
617 if (self != simix_global->maestro_process) {
618 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
619 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
620 SIMIX_process_yield(self);
622 SIMIX_simcall_handle(&self->simcall, 0);
624 return self->simcall.result.i;
627 inline static xbt_dict_t simcall_BODY_host_get_mounted_storage_list(smx_host_t host) {
628 smx_process_t self = SIMIX_process_self();
630 /* Go to that function to follow the code flow through the simcall barrier */
631 if (0) SIMIX_host_get_mounted_storage_list(host);
632 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
634 self->simcall.call = SIMCALL_HOST_GET_MOUNTED_STORAGE_LIST;
635 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
636 memset(self->simcall.args, 0, sizeof(self->simcall.args));
637 self->simcall.args[0].dp = (void*) host;
638 if (self != simix_global->maestro_process) {
639 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
640 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
641 SIMIX_process_yield(self);
643 SIMIX_simcall_handle(&self->simcall, 0);
645 return self->simcall.result.dp;
648 inline static xbt_dynar_t simcall_BODY_host_get_attached_storage_list(smx_host_t host) {
649 smx_process_t self = SIMIX_process_self();
651 /* Go to that function to follow the code flow through the simcall barrier */
652 if (0) SIMIX_host_get_attached_storage_list(host);
653 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
655 self->simcall.call = SIMCALL_HOST_GET_ATTACHED_STORAGE_LIST;
656 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
657 memset(self->simcall.args, 0, sizeof(self->simcall.args));
658 self->simcall.args[0].dp = (void*) host;
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);
664 SIMIX_simcall_handle(&self->simcall, 0);
666 return self->simcall.result.dp;
669 inline static void simcall_BODY_host_get_params(smx_host_t ind_vm, ws_params_t params) {
670 smx_process_t self = SIMIX_process_self();
672 /* Go to that function to follow the code flow through the simcall barrier */
673 if (0) SIMIX_host_get_params(ind_vm, params);
674 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
676 self->simcall.call = SIMCALL_HOST_GET_PARAMS;
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].dp = (void*) ind_vm;
680 self->simcall.args[1].dp = (void*) params;
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);
686 SIMIX_simcall_handle(&self->simcall, 0);
691 inline static void simcall_BODY_host_set_params(smx_host_t ind_vm, ws_params_t params) {
692 smx_process_t self = SIMIX_process_self();
694 /* Go to that function to follow the code flow through the simcall barrier */
695 if (0) SIMIX_host_set_params(ind_vm, params);
696 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
698 self->simcall.call = SIMCALL_HOST_SET_PARAMS;
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 self->simcall.args[1].dp = (void*) params;
703 if (self != simix_global->maestro_process) {
704 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
705 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
706 SIMIX_process_yield(self);
708 SIMIX_simcall_handle(&self->simcall, 0);
713 inline static smx_host_t simcall_BODY_vm_create(const char* name, smx_host_t ind_pm) {
714 smx_process_t self = SIMIX_process_self();
716 /* Go to that function to follow the code flow through the simcall barrier */
717 if (0) SIMIX_vm_create(name, ind_pm);
718 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
720 self->simcall.call = SIMCALL_VM_CREATE;
721 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
722 memset(self->simcall.args, 0, sizeof(self->simcall.args));
723 self->simcall.args[0].cc = (const char*) name;
724 self->simcall.args[1].dp = (void*) ind_pm;
725 if (self != simix_global->maestro_process) {
726 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
727 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
728 SIMIX_process_yield(self);
730 SIMIX_simcall_handle(&self->simcall, 0);
732 return self->simcall.result.dp;
735 inline static void simcall_BODY_vm_start(smx_host_t ind_vm) {
736 smx_process_t self = SIMIX_process_self();
738 /* Go to that function to follow the code flow through the simcall barrier */
739 if (0) SIMIX_vm_start(ind_vm);
740 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
742 self->simcall.call = SIMCALL_VM_START;
743 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
744 memset(self->simcall.args, 0, sizeof(self->simcall.args));
745 self->simcall.args[0].dp = (void*) ind_vm;
746 if (self != simix_global->maestro_process) {
747 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
748 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
749 SIMIX_process_yield(self);
751 SIMIX_simcall_handle(&self->simcall, 0);
756 inline static int simcall_BODY_vm_get_state(smx_host_t ind_vm) {
757 smx_process_t self = SIMIX_process_self();
759 /* Go to that function to follow the code flow through the simcall barrier */
760 if (0) SIMIX_vm_get_state(ind_vm);
761 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
763 self->simcall.call = SIMCALL_VM_GET_STATE;
764 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
765 memset(self->simcall.args, 0, sizeof(self->simcall.args));
766 self->simcall.args[0].dp = (void*) ind_vm;
767 if (self != simix_global->maestro_process) {
768 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
769 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
770 SIMIX_process_yield(self);
772 SIMIX_simcall_handle(&self->simcall, 0);
774 return self->simcall.result.i;
777 inline static void simcall_BODY_vm_migrate(smx_host_t ind_vm, smx_host_t ind_dst_pm) {
778 smx_process_t self = SIMIX_process_self();
780 /* Go to that function to follow the code flow through the simcall barrier */
781 if (0) SIMIX_vm_migrate(ind_vm, ind_dst_pm);
782 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
784 self->simcall.call = SIMCALL_VM_MIGRATE;
785 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
786 memset(self->simcall.args, 0, sizeof(self->simcall.args));
787 self->simcall.args[0].dp = (void*) ind_vm;
788 self->simcall.args[1].dp = (void*) ind_dst_pm;
789 if (self != simix_global->maestro_process) {
790 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
791 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
792 SIMIX_process_yield(self);
794 SIMIX_simcall_handle(&self->simcall, 0);
799 inline static void* simcall_BODY_vm_get_pm(smx_host_t ind_vm) {
800 smx_process_t self = SIMIX_process_self();
802 /* Go to that function to follow the code flow through the simcall barrier */
803 if (0) SIMIX_vm_get_pm(ind_vm);
804 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
806 self->simcall.call = SIMCALL_VM_GET_PM;
807 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
808 memset(self->simcall.args, 0, sizeof(self->simcall.args));
809 self->simcall.args[0].dp = (void*) ind_vm;
810 if (self != simix_global->maestro_process) {
811 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
812 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
813 SIMIX_process_yield(self);
815 SIMIX_simcall_handle(&self->simcall, 0);
817 return self->simcall.result.dp;
820 inline static void simcall_BODY_vm_set_bound(smx_host_t ind_vm, double bound) {
821 smx_process_t self = SIMIX_process_self();
823 /* Go to that function to follow the code flow through the simcall barrier */
824 if (0) SIMIX_vm_set_bound(ind_vm, bound);
825 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
827 self->simcall.call = SIMCALL_VM_SET_BOUND;
828 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
829 memset(self->simcall.args, 0, sizeof(self->simcall.args));
830 self->simcall.args[0].dp = (void*) ind_vm;
831 self->simcall.args[1].d = (double) bound;
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);
837 SIMIX_simcall_handle(&self->simcall, 0);
842 inline static void simcall_BODY_vm_set_affinity(smx_host_t ind_vm, smx_host_t ind_pm, unsigned long mask) {
843 smx_process_t self = SIMIX_process_self();
845 /* Go to that function to follow the code flow through the simcall barrier */
846 if (0) SIMIX_vm_set_affinity(ind_vm, ind_pm, mask);
847 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
849 self->simcall.call = SIMCALL_VM_SET_AFFINITY;
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 self->simcall.args[1].dp = (void*) ind_pm;
854 self->simcall.args[2].ul = (unsigned long) mask;
855 if (self != simix_global->maestro_process) {
856 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
857 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
858 SIMIX_process_yield(self);
860 SIMIX_simcall_handle(&self->simcall, 0);
865 inline static void simcall_BODY_vm_destroy(smx_host_t ind_vm) {
866 smx_process_t self = SIMIX_process_self();
868 /* Go to that function to follow the code flow through the simcall barrier */
869 if (0) SIMIX_vm_destroy(ind_vm);
870 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
872 self->simcall.call = SIMCALL_VM_DESTROY;
873 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
874 memset(self->simcall.args, 0, sizeof(self->simcall.args));
875 self->simcall.args[0].dp = (void*) ind_vm;
876 if (self != simix_global->maestro_process) {
877 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
878 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
879 SIMIX_process_yield(self);
881 SIMIX_simcall_handle(&self->simcall, 0);
886 inline static void simcall_BODY_vm_suspend(smx_host_t ind_vm) {
887 smx_process_t self = SIMIX_process_self();
889 /* Go to that function to follow the code flow through the simcall barrier */
890 if (0) simcall_HANDLER_vm_suspend(&self->simcall, ind_vm);
891 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
893 self->simcall.call = SIMCALL_VM_SUSPEND;
894 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
895 memset(self->simcall.args, 0, sizeof(self->simcall.args));
896 self->simcall.args[0].dp = (void*) ind_vm;
897 if (self != simix_global->maestro_process) {
898 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
899 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
900 SIMIX_process_yield(self);
902 SIMIX_simcall_handle(&self->simcall, 0);
907 inline static void simcall_BODY_vm_resume(smx_host_t ind_vm) {
908 smx_process_t self = SIMIX_process_self();
910 /* Go to that function to follow the code flow through the simcall barrier */
911 if (0) simcall_HANDLER_vm_resume(&self->simcall, ind_vm);
912 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
914 self->simcall.call = SIMCALL_VM_RESUME;
915 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
916 memset(self->simcall.args, 0, sizeof(self->simcall.args));
917 self->simcall.args[0].dp = (void*) ind_vm;
918 if (self != simix_global->maestro_process) {
919 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
920 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
921 SIMIX_process_yield(self);
923 SIMIX_simcall_handle(&self->simcall, 0);
928 inline static void simcall_BODY_vm_shutdown(smx_host_t ind_vm) {
929 smx_process_t self = SIMIX_process_self();
931 /* Go to that function to follow the code flow through the simcall barrier */
932 if (0) simcall_HANDLER_vm_shutdown(&self->simcall, ind_vm);
933 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
935 self->simcall.call = SIMCALL_VM_SHUTDOWN;
936 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
937 memset(self->simcall.args, 0, sizeof(self->simcall.args));
938 self->simcall.args[0].dp = (void*) ind_vm;
939 if (self != simix_global->maestro_process) {
940 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
941 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
942 SIMIX_process_yield(self);
944 SIMIX_simcall_handle(&self->simcall, 0);
949 inline static void simcall_BODY_vm_save(smx_host_t ind_vm) {
950 smx_process_t self = SIMIX_process_self();
952 /* Go to that function to follow the code flow through the simcall barrier */
953 if (0) simcall_HANDLER_vm_save(&self->simcall, ind_vm);
954 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
956 self->simcall.call = SIMCALL_VM_SAVE;
957 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
958 memset(self->simcall.args, 0, sizeof(self->simcall.args));
959 self->simcall.args[0].dp = (void*) ind_vm;
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);
965 SIMIX_simcall_handle(&self->simcall, 0);
970 inline static void simcall_BODY_vm_restore(smx_host_t ind_vm) {
971 smx_process_t self = SIMIX_process_self();
973 /* Go to that function to follow the code flow through the simcall barrier */
974 if (0) simcall_HANDLER_vm_restore(&self->simcall, ind_vm);
975 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
977 self->simcall.call = SIMCALL_VM_RESTORE;
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*) ind_vm;
981 if (self != simix_global->maestro_process) {
982 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
983 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
984 SIMIX_process_yield(self);
986 SIMIX_simcall_handle(&self->simcall, 0);
991 inline static void simcall_BODY_vm_migratefrom_resumeto(smx_host_t vm, smx_host_t src_pm, smx_host_t dst_pm) {
992 smx_process_t self = SIMIX_process_self();
994 /* Go to that function to follow the code flow through the simcall barrier */
995 if (0) SIMIX_vm_migratefrom_resumeto(vm, src_pm, dst_pm);
996 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
998 self->simcall.call = SIMCALL_VM_MIGRATEFROM_RESUMETO;
999 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1000 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1001 self->simcall.args[0].dp = (void*) vm;
1002 self->simcall.args[1].dp = (void*) src_pm;
1003 self->simcall.args[2].dp = (void*) dst_pm;
1004 if (self != simix_global->maestro_process) {
1005 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1006 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1007 SIMIX_process_yield(self);
1009 SIMIX_simcall_handle(&self->simcall, 0);
1014 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) {
1015 smx_process_t self = SIMIX_process_self();
1017 /* Go to that function to follow the code flow through the simcall barrier */
1018 if (0) simcall_HANDLER_process_create(&self->simcall, process, name, code, data, hostname, kill_time, argc, argv, properties, auto_restart);
1019 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1021 self->simcall.call = SIMCALL_PROCESS_CREATE;
1022 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1023 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1024 self->simcall.args[0].dp = (void*) process;
1025 self->simcall.args[1].cc = (const char*) name;
1026 self->simcall.args[2].fp = (FPtr) code;
1027 self->simcall.args[3].dp = (void*) data;
1028 self->simcall.args[4].cc = (const char*) hostname;
1029 self->simcall.args[5].d = (double) kill_time;
1030 self->simcall.args[6].i = (int) argc;
1031 self->simcall.args[7].dp = (void*) argv;
1032 self->simcall.args[8].dp = (void*) properties;
1033 self->simcall.args[9].i = (int) auto_restart;
1034 if (self != simix_global->maestro_process) {
1035 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1036 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1037 SIMIX_process_yield(self);
1039 SIMIX_simcall_handle(&self->simcall, 0);
1044 inline static void simcall_BODY_process_kill(smx_process_t process) {
1045 smx_process_t self = SIMIX_process_self();
1047 /* Go to that function to follow the code flow through the simcall barrier */
1048 if (0) simcall_HANDLER_process_kill(&self->simcall, process);
1049 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1051 self->simcall.call = SIMCALL_PROCESS_KILL;
1052 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1053 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1054 self->simcall.args[0].dp = (void*) process;
1055 if (self != simix_global->maestro_process) {
1056 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1057 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1058 SIMIX_process_yield(self);
1060 SIMIX_simcall_handle(&self->simcall, 0);
1065 inline static void simcall_BODY_process_killall(int reset_pid) {
1066 smx_process_t self = SIMIX_process_self();
1068 /* Go to that function to follow the code flow through the simcall barrier */
1069 if (0) simcall_HANDLER_process_killall(&self->simcall, reset_pid);
1070 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1072 self->simcall.call = SIMCALL_PROCESS_KILLALL;
1073 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1074 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1075 self->simcall.args[0].i = (int) reset_pid;
1076 if (self != simix_global->maestro_process) {
1077 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1078 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1079 SIMIX_process_yield(self);
1081 SIMIX_simcall_handle(&self->simcall, 0);
1086 inline static void simcall_BODY_process_cleanup(smx_process_t process) {
1087 smx_process_t self = SIMIX_process_self();
1089 /* Go to that function to follow the code flow through the simcall barrier */
1090 if (0) SIMIX_process_cleanup(process);
1091 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1093 self->simcall.call = SIMCALL_PROCESS_CLEANUP;
1094 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1095 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1096 self->simcall.args[0].dp = (void*) process;
1097 if (self != simix_global->maestro_process) {
1098 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1099 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1100 SIMIX_process_yield(self);
1102 SIMIX_simcall_handle(&self->simcall, 0);
1107 inline static void simcall_BODY_process_change_host(smx_process_t process, smx_host_t dest) {
1108 smx_process_t self = SIMIX_process_self();
1110 /* Go to that function to follow the code flow through the simcall barrier */
1111 if (0) simcall_HANDLER_process_change_host(&self->simcall, process, dest);
1112 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1114 self->simcall.call = SIMCALL_PROCESS_CHANGE_HOST;
1115 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1116 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1117 self->simcall.args[0].dp = (void*) process;
1118 self->simcall.args[1].dp = (void*) dest;
1119 if (self != simix_global->maestro_process) {
1120 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1121 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1122 SIMIX_process_yield(self);
1124 SIMIX_simcall_handle(&self->simcall, 0);
1129 inline static void simcall_BODY_process_suspend(smx_process_t process) {
1130 smx_process_t self = SIMIX_process_self();
1132 /* Go to that function to follow the code flow through the simcall barrier */
1133 if (0) simcall_HANDLER_process_suspend(&self->simcall, process);
1134 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1136 self->simcall.call = SIMCALL_PROCESS_SUSPEND;
1137 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1138 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1139 self->simcall.args[0].dp = (void*) process;
1140 if (self != simix_global->maestro_process) {
1141 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1142 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1143 SIMIX_process_yield(self);
1145 SIMIX_simcall_handle(&self->simcall, 0);
1150 inline static void simcall_BODY_process_resume(smx_process_t process) {
1151 smx_process_t self = SIMIX_process_self();
1153 /* Go to that function to follow the code flow through the simcall barrier */
1154 if (0) simcall_HANDLER_process_resume(&self->simcall, process);
1155 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1157 self->simcall.call = SIMCALL_PROCESS_RESUME;
1158 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1159 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1160 self->simcall.args[0].dp = (void*) process;
1161 if (self != simix_global->maestro_process) {
1162 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1163 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1164 SIMIX_process_yield(self);
1166 SIMIX_simcall_handle(&self->simcall, 0);
1171 inline static int simcall_BODY_process_count() {
1172 smx_process_t self = SIMIX_process_self();
1174 /* Go to that function to follow the code flow through the simcall barrier */
1175 if (0) SIMIX_process_count();
1176 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1178 self->simcall.call = SIMCALL_PROCESS_COUNT;
1179 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1180 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1182 if (self != simix_global->maestro_process) {
1183 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1184 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1185 SIMIX_process_yield(self);
1187 SIMIX_simcall_handle(&self->simcall, 0);
1189 return self->simcall.result.i;
1192 inline static int simcall_BODY_process_get_PID(smx_process_t process) {
1193 smx_process_t self = SIMIX_process_self();
1195 /* Go to that function to follow the code flow through the simcall barrier */
1196 if (0) SIMIX_process_get_PID(process);
1197 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1199 self->simcall.call = SIMCALL_PROCESS_GET_PID;
1200 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1201 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1202 self->simcall.args[0].dp = (void*) process;
1203 if (self != simix_global->maestro_process) {
1204 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1205 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1206 SIMIX_process_yield(self);
1208 SIMIX_simcall_handle(&self->simcall, 0);
1210 return self->simcall.result.i;
1213 inline static int simcall_BODY_process_get_PPID(smx_process_t process) {
1214 smx_process_t self = SIMIX_process_self();
1216 /* Go to that function to follow the code flow through the simcall barrier */
1217 if (0) SIMIX_process_get_PPID(process);
1218 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1220 self->simcall.call = SIMCALL_PROCESS_GET_PPID;
1221 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1222 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1223 self->simcall.args[0].dp = (void*) process;
1224 if (self != simix_global->maestro_process) {
1225 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1226 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1227 SIMIX_process_yield(self);
1229 SIMIX_simcall_handle(&self->simcall, 0);
1231 return self->simcall.result.i;
1234 inline static void* simcall_BODY_process_get_data(smx_process_t process) {
1235 smx_process_t self = SIMIX_process_self();
1237 /* Go to that function to follow the code flow through the simcall barrier */
1238 if (0) SIMIX_process_get_data(process);
1239 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1241 self->simcall.call = SIMCALL_PROCESS_GET_DATA;
1242 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1243 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1244 self->simcall.args[0].dp = (void*) process;
1245 if (self != simix_global->maestro_process) {
1246 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1247 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1248 SIMIX_process_yield(self);
1250 SIMIX_simcall_handle(&self->simcall, 0);
1252 return self->simcall.result.dp;
1255 inline static void simcall_BODY_process_set_data(smx_process_t process, void* data) {
1256 smx_process_t self = SIMIX_process_self();
1258 /* Go to that function to follow the code flow through the simcall barrier */
1259 if (0) SIMIX_process_set_data(process, data);
1260 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1262 self->simcall.call = SIMCALL_PROCESS_SET_DATA;
1263 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1264 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1265 self->simcall.args[0].dp = (void*) process;
1266 self->simcall.args[1].dp = (void*) data;
1267 if (self != simix_global->maestro_process) {
1268 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1269 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1270 SIMIX_process_yield(self);
1272 SIMIX_simcall_handle(&self->simcall, 0);
1277 inline static smx_host_t simcall_BODY_process_get_host(smx_process_t process) {
1278 smx_process_t self = SIMIX_process_self();
1280 /* Go to that function to follow the code flow through the simcall barrier */
1281 if (0) SIMIX_process_get_host(process);
1282 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1284 self->simcall.call = SIMCALL_PROCESS_GET_HOST;
1285 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1286 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1287 self->simcall.args[0].dp = (void*) process;
1288 if (self != simix_global->maestro_process) {
1289 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1290 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1291 SIMIX_process_yield(self);
1293 SIMIX_simcall_handle(&self->simcall, 0);
1295 return self->simcall.result.dp;
1298 inline static const char* simcall_BODY_process_get_name(smx_process_t process) {
1299 smx_process_t self = SIMIX_process_self();
1301 /* Go to that function to follow the code flow through the simcall barrier */
1302 if (0) SIMIX_process_get_name(process);
1303 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1305 self->simcall.call = SIMCALL_PROCESS_GET_NAME;
1306 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1307 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1308 self->simcall.args[0].dp = (void*) process;
1309 if (self != simix_global->maestro_process) {
1310 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1311 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1312 SIMIX_process_yield(self);
1314 SIMIX_simcall_handle(&self->simcall, 0);
1316 return self->simcall.result.cc;
1319 inline static int simcall_BODY_process_is_suspended(smx_process_t process) {
1320 smx_process_t self = SIMIX_process_self();
1322 /* Go to that function to follow the code flow through the simcall barrier */
1323 if (0) SIMIX_process_is_suspended(process);
1324 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1326 self->simcall.call = SIMCALL_PROCESS_IS_SUSPENDED;
1327 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1328 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1329 self->simcall.args[0].dp = (void*) process;
1330 if (self != simix_global->maestro_process) {
1331 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1332 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1333 SIMIX_process_yield(self);
1335 SIMIX_simcall_handle(&self->simcall, 0);
1337 return self->simcall.result.i;
1340 inline static xbt_dict_t simcall_BODY_process_get_properties(smx_process_t process) {
1341 smx_process_t self = SIMIX_process_self();
1343 /* Go to that function to follow the code flow through the simcall barrier */
1344 if (0) SIMIX_process_get_properties(process);
1345 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1347 self->simcall.call = SIMCALL_PROCESS_GET_PROPERTIES;
1348 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1349 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1350 self->simcall.args[0].dp = (void*) process;
1351 if (self != simix_global->maestro_process) {
1352 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1353 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1354 SIMIX_process_yield(self);
1356 SIMIX_simcall_handle(&self->simcall, 0);
1358 return self->simcall.result.dp;
1361 inline static int simcall_BODY_process_join(smx_process_t process, double timeout) {
1362 smx_process_t self = SIMIX_process_self();
1364 /* Go to that function to follow the code flow through the simcall barrier */
1365 if (0) simcall_HANDLER_process_join(&self->simcall, process, timeout);
1366 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1368 self->simcall.call = SIMCALL_PROCESS_JOIN;
1369 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1370 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1371 self->simcall.args[0].dp = (void*) process;
1372 self->simcall.args[1].d = (double) timeout;
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);
1378 SIMIX_simcall_handle(&self->simcall, 0);
1380 return self->simcall.result.i;
1383 inline static int simcall_BODY_process_sleep(double duration) {
1384 smx_process_t self = SIMIX_process_self();
1386 /* Go to that function to follow the code flow through the simcall barrier */
1387 if (0) simcall_HANDLER_process_sleep(&self->simcall, duration);
1388 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1390 self->simcall.call = SIMCALL_PROCESS_SLEEP;
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].d = (double) duration;
1394 if (self != simix_global->maestro_process) {
1395 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1396 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1397 SIMIX_process_yield(self);
1399 SIMIX_simcall_handle(&self->simcall, 0);
1401 return self->simcall.result.i;
1404 inline static void simcall_BODY_process_on_exit(smx_process_t process, int_f_pvoid_pvoid_t fun, void* data) {
1405 smx_process_t self = SIMIX_process_self();
1407 /* Go to that function to follow the code flow through the simcall barrier */
1408 if (0) SIMIX_process_on_exit(process, fun, data);
1409 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1411 self->simcall.call = SIMCALL_PROCESS_ON_EXIT;
1412 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1413 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1414 self->simcall.args[0].dp = (void*) process;
1415 self->simcall.args[1].fp = (FPtr) fun;
1416 self->simcall.args[2].dp = (void*) data;
1417 if (self != simix_global->maestro_process) {
1418 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1419 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1420 SIMIX_process_yield(self);
1422 SIMIX_simcall_handle(&self->simcall, 0);
1427 inline static void simcall_BODY_process_auto_restart_set(smx_process_t process, int auto_restart) {
1428 smx_process_t self = SIMIX_process_self();
1430 /* Go to that function to follow the code flow through the simcall barrier */
1431 if (0) SIMIX_process_auto_restart_set(process, auto_restart);
1432 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1434 self->simcall.call = SIMCALL_PROCESS_AUTO_RESTART_SET;
1435 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1436 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1437 self->simcall.args[0].dp = (void*) process;
1438 self->simcall.args[1].i = (int) auto_restart;
1439 if (self != simix_global->maestro_process) {
1440 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1441 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1442 SIMIX_process_yield(self);
1444 SIMIX_simcall_handle(&self->simcall, 0);
1449 inline static smx_process_t simcall_BODY_process_restart(smx_process_t process) {
1450 smx_process_t self = SIMIX_process_self();
1452 /* Go to that function to follow the code flow through the simcall barrier */
1453 if (0) simcall_HANDLER_process_restart(&self->simcall, process);
1454 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1456 self->simcall.call = SIMCALL_PROCESS_RESTART;
1457 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1458 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1459 self->simcall.args[0].dp = (void*) process;
1460 if (self != simix_global->maestro_process) {
1461 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1462 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1463 SIMIX_process_yield(self);
1465 SIMIX_simcall_handle(&self->simcall, 0);
1467 return self->simcall.result.dp;
1470 inline static smx_rdv_t simcall_BODY_rdv_create(const char* name) {
1471 smx_process_t self = SIMIX_process_self();
1473 /* Go to that function to follow the code flow through the simcall barrier */
1474 if (0) SIMIX_rdv_create(name);
1475 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1477 self->simcall.call = SIMCALL_RDV_CREATE;
1478 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1479 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1480 self->simcall.args[0].cc = (const char*) name;
1481 if (self != simix_global->maestro_process) {
1482 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1483 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1484 SIMIX_process_yield(self);
1486 SIMIX_simcall_handle(&self->simcall, 0);
1488 return self->simcall.result.dp;
1491 inline static void simcall_BODY_rdv_destroy(smx_rdv_t rdv) {
1492 smx_process_t self = SIMIX_process_self();
1494 /* Go to that function to follow the code flow through the simcall barrier */
1495 if (0) SIMIX_rdv_destroy(rdv);
1496 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1498 self->simcall.call = SIMCALL_RDV_DESTROY;
1499 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1500 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1501 self->simcall.args[0].dp = (void*) rdv;
1502 if (self != simix_global->maestro_process) {
1503 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1504 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1505 SIMIX_process_yield(self);
1507 SIMIX_simcall_handle(&self->simcall, 0);
1512 inline static unsigned int simcall_BODY_rdv_comm_count_by_host(smx_rdv_t rdv, smx_host_t host) {
1513 smx_process_t self = SIMIX_process_self();
1515 /* Go to that function to follow the code flow through the simcall barrier */
1516 if (0) SIMIX_rdv_comm_count_by_host(rdv, host);
1517 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1519 self->simcall.call = SIMCALL_RDV_COMM_COUNT_BY_HOST;
1520 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1521 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1522 self->simcall.args[0].dp = (void*) rdv;
1523 self->simcall.args[1].dp = (void*) host;
1524 if (self != simix_global->maestro_process) {
1525 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1526 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1527 SIMIX_process_yield(self);
1529 SIMIX_simcall_handle(&self->simcall, 0);
1531 return self->simcall.result.ui;
1534 inline static smx_synchro_t simcall_BODY_rdv_get_head(smx_rdv_t rdv) {
1535 smx_process_t self = SIMIX_process_self();
1537 /* Go to that function to follow the code flow through the simcall barrier */
1538 if (0) SIMIX_rdv_get_head(rdv);
1539 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1541 self->simcall.call = SIMCALL_RDV_GET_HEAD;
1542 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1543 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1544 self->simcall.args[0].dp = (void*) rdv;
1545 if (self != simix_global->maestro_process) {
1546 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1547 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1548 SIMIX_process_yield(self);
1550 SIMIX_simcall_handle(&self->simcall, 0);
1552 return self->simcall.result.dp;
1555 inline static void simcall_BODY_rdv_set_receiver(smx_rdv_t rdv, smx_process_t receiver) {
1556 smx_process_t self = SIMIX_process_self();
1558 /* Go to that function to follow the code flow through the simcall barrier */
1559 if (0) SIMIX_rdv_set_receiver(rdv, receiver);
1560 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1562 self->simcall.call = SIMCALL_RDV_SET_RECEIVER;
1563 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1564 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1565 self->simcall.args[0].dp = (void*) rdv;
1566 self->simcall.args[1].dp = (void*) receiver;
1567 if (self != simix_global->maestro_process) {
1568 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1569 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1570 SIMIX_process_yield(self);
1572 SIMIX_simcall_handle(&self->simcall, 0);
1577 inline static smx_process_t simcall_BODY_rdv_get_receiver(smx_rdv_t rdv) {
1578 smx_process_t self = SIMIX_process_self();
1580 /* Go to that function to follow the code flow through the simcall barrier */
1581 if (0) SIMIX_rdv_get_receiver(rdv);
1582 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1584 self->simcall.call = SIMCALL_RDV_GET_RECEIVER;
1585 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1586 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1587 self->simcall.args[0].dp = (void*) rdv;
1588 if (self != simix_global->maestro_process) {
1589 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1590 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1591 SIMIX_process_yield(self);
1593 SIMIX_simcall_handle(&self->simcall, 0);
1595 return self->simcall.result.dp;
1598 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) {
1599 smx_process_t self = SIMIX_process_self();
1601 /* Go to that function to follow the code flow through the simcall barrier */
1602 if (0) simcall_HANDLER_comm_iprobe(&self->simcall, rdv, type, src, tag, match_fun, data);
1603 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1605 self->simcall.call = SIMCALL_COMM_IPROBE;
1606 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1607 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1608 self->simcall.args[0].dp = (void*) rdv;
1609 self->simcall.args[1].i = (int) type;
1610 self->simcall.args[2].i = (int) src;
1611 self->simcall.args[3].i = (int) tag;
1612 self->simcall.args[4].fp = (FPtr) match_fun;
1613 self->simcall.args[5].dp = (void*) data;
1614 if (self != simix_global->maestro_process) {
1615 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1616 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1617 SIMIX_process_yield(self);
1619 SIMIX_simcall_handle(&self->simcall, 0);
1621 return self->simcall.result.dp;
1624 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) {
1625 smx_process_t self = SIMIX_process_self();
1627 /* Go to that function to follow the code flow through the simcall barrier */
1628 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);
1629 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1631 self->simcall.call = SIMCALL_COMM_SEND;
1632 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1633 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1634 self->simcall.args[0].dp = (void*) src;
1635 self->simcall.args[1].dp = (void*) rdv;
1636 self->simcall.args[2].d = (double) task_size;
1637 self->simcall.args[3].d = (double) rate;
1638 self->simcall.args[4].dp = (void*) src_buff;
1639 self->simcall.args[5].sz = (size_t) src_buff_size;
1640 self->simcall.args[6].fp = (FPtr) match_fun;
1641 self->simcall.args[7].fp = (FPtr) copy_data_fun;
1642 self->simcall.args[8].dp = (void*) data;
1643 self->simcall.args[9].d = (double) timeout;
1644 if (self != simix_global->maestro_process) {
1645 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1646 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1647 SIMIX_process_yield(self);
1649 SIMIX_simcall_handle(&self->simcall, 0);
1654 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) {
1655 smx_process_t self = SIMIX_process_self();
1657 /* Go to that function to follow the code flow through the simcall barrier */
1658 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);
1659 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1661 self->simcall.call = SIMCALL_COMM_ISEND;
1662 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1663 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1664 self->simcall.args[0].dp = (void*) src;
1665 self->simcall.args[1].dp = (void*) rdv;
1666 self->simcall.args[2].d = (double) task_size;
1667 self->simcall.args[3].d = (double) rate;
1668 self->simcall.args[4].dp = (void*) src_buff;
1669 self->simcall.args[5].sz = (size_t) src_buff_size;
1670 self->simcall.args[6].fp = (FPtr) match_fun;
1671 self->simcall.args[7].fp = (FPtr) clean_fun;
1672 self->simcall.args[8].fp = (FPtr) copy_data_fun;
1673 self->simcall.args[9].dp = (void*) data;
1674 self->simcall.args[10].i = (int) detached;
1675 if (self != simix_global->maestro_process) {
1676 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1677 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1678 SIMIX_process_yield(self);
1680 SIMIX_simcall_handle(&self->simcall, 0);
1682 return self->simcall.result.dp;
1685 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) {
1686 smx_process_t self = SIMIX_process_self();
1688 /* Go to that function to follow the code flow through the simcall barrier */
1689 if (0) simcall_HANDLER_comm_recv(&self->simcall, rdv, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, timeout, rate);
1690 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1692 self->simcall.call = SIMCALL_COMM_RECV;
1693 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1694 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1695 self->simcall.args[0].dp = (void*) rdv;
1696 self->simcall.args[1].dp = (void*) dst_buff;
1697 self->simcall.args[2].dp = (void*) dst_buff_size;
1698 self->simcall.args[3].fp = (FPtr) match_fun;
1699 self->simcall.args[4].fp = (FPtr) copy_data_fun;
1700 self->simcall.args[5].dp = (void*) data;
1701 self->simcall.args[6].d = (double) timeout;
1702 self->simcall.args[7].d = (double) rate;
1703 if (self != simix_global->maestro_process) {
1704 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1705 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1706 SIMIX_process_yield(self);
1708 SIMIX_simcall_handle(&self->simcall, 0);
1713 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) {
1714 smx_process_t self = SIMIX_process_self();
1716 /* Go to that function to follow the code flow through the simcall barrier */
1717 if (0) simcall_HANDLER_comm_irecv(&self->simcall, rdv, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, rate);
1718 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1720 self->simcall.call = SIMCALL_COMM_IRECV;
1721 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1722 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1723 self->simcall.args[0].dp = (void*) rdv;
1724 self->simcall.args[1].dp = (void*) dst_buff;
1725 self->simcall.args[2].dp = (void*) dst_buff_size;
1726 self->simcall.args[3].fp = (FPtr) match_fun;
1727 self->simcall.args[4].fp = (FPtr) copy_data_fun;
1728 self->simcall.args[5].dp = (void*) data;
1729 self->simcall.args[6].d = (double) rate;
1730 if (self != simix_global->maestro_process) {
1731 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1732 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1733 SIMIX_process_yield(self);
1735 SIMIX_simcall_handle(&self->simcall, 0);
1737 return self->simcall.result.dp;
1740 inline static void simcall_BODY_comm_cancel(smx_synchro_t comm) {
1741 smx_process_t self = SIMIX_process_self();
1743 /* Go to that function to follow the code flow through the simcall barrier */
1744 if (0) SIMIX_comm_cancel(comm);
1745 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1747 self->simcall.call = SIMCALL_COMM_CANCEL;
1748 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1749 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1750 self->simcall.args[0].dp = (void*) comm;
1751 if (self != simix_global->maestro_process) {
1752 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1753 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1754 SIMIX_process_yield(self);
1756 SIMIX_simcall_handle(&self->simcall, 0);
1761 inline static int simcall_BODY_comm_waitany(xbt_dynar_t comms) {
1762 smx_process_t self = SIMIX_process_self();
1764 /* Go to that function to follow the code flow through the simcall barrier */
1765 if (0) simcall_HANDLER_comm_waitany(&self->simcall, comms);
1766 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1768 self->simcall.call = SIMCALL_COMM_WAITANY;
1769 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1770 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1771 self->simcall.args[0].dp = (void*) comms;
1772 if (self != simix_global->maestro_process) {
1773 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1774 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1775 SIMIX_process_yield(self);
1777 SIMIX_simcall_handle(&self->simcall, 0);
1779 return self->simcall.result.i;
1782 inline static void simcall_BODY_comm_wait(smx_synchro_t comm, double timeout) {
1783 smx_process_t self = SIMIX_process_self();
1785 /* Go to that function to follow the code flow through the simcall barrier */
1786 if (0) simcall_HANDLER_comm_wait(&self->simcall, comm, timeout);
1787 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1789 self->simcall.call = SIMCALL_COMM_WAIT;
1790 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1791 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1792 self->simcall.args[0].dp = (void*) comm;
1793 self->simcall.args[1].d = (double) timeout;
1794 if (self != simix_global->maestro_process) {
1795 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1796 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1797 SIMIX_process_yield(self);
1799 SIMIX_simcall_handle(&self->simcall, 0);
1804 inline static int simcall_BODY_comm_test(smx_synchro_t comm) {
1805 smx_process_t self = SIMIX_process_self();
1807 /* Go to that function to follow the code flow through the simcall barrier */
1808 if (0) simcall_HANDLER_comm_test(&self->simcall, comm);
1809 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1811 self->simcall.call = SIMCALL_COMM_TEST;
1812 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1813 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1814 self->simcall.args[0].dp = (void*) comm;
1815 if (self != simix_global->maestro_process) {
1816 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1817 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1818 SIMIX_process_yield(self);
1820 SIMIX_simcall_handle(&self->simcall, 0);
1822 return self->simcall.result.i;
1825 inline static int simcall_BODY_comm_testany(xbt_dynar_t comms) {
1826 smx_process_t self = SIMIX_process_self();
1828 /* Go to that function to follow the code flow through the simcall barrier */
1829 if (0) simcall_HANDLER_comm_testany(&self->simcall, comms);
1830 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1832 self->simcall.call = SIMCALL_COMM_TESTANY;
1833 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1834 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1835 self->simcall.args[0].dp = (void*) comms;
1836 if (self != simix_global->maestro_process) {
1837 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1838 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1839 SIMIX_process_yield(self);
1841 SIMIX_simcall_handle(&self->simcall, 0);
1843 return self->simcall.result.i;
1846 inline static double simcall_BODY_comm_get_remains(smx_synchro_t comm) {
1847 smx_process_t self = SIMIX_process_self();
1849 /* Go to that function to follow the code flow through the simcall barrier */
1850 if (0) SIMIX_comm_get_remains(comm);
1851 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1853 self->simcall.call = SIMCALL_COMM_GET_REMAINS;
1854 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1855 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1856 self->simcall.args[0].dp = (void*) comm;
1857 if (self != simix_global->maestro_process) {
1858 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1859 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1860 SIMIX_process_yield(self);
1862 SIMIX_simcall_handle(&self->simcall, 0);
1864 return self->simcall.result.d;
1867 inline static e_smx_state_t simcall_BODY_comm_get_state(smx_synchro_t comm) {
1868 smx_process_t self = SIMIX_process_self();
1870 /* Go to that function to follow the code flow through the simcall barrier */
1871 if (0) SIMIX_comm_get_state(comm);
1872 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1874 self->simcall.call = SIMCALL_COMM_GET_STATE;
1875 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1876 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1877 self->simcall.args[0].dp = (void*) comm;
1878 if (self != simix_global->maestro_process) {
1879 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1880 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1881 SIMIX_process_yield(self);
1883 SIMIX_simcall_handle(&self->simcall, 0);
1885 return self->simcall.result.i;
1888 inline static void* simcall_BODY_comm_get_src_data(smx_synchro_t comm) {
1889 smx_process_t self = SIMIX_process_self();
1891 /* Go to that function to follow the code flow through the simcall barrier */
1892 if (0) SIMIX_comm_get_src_data(comm);
1893 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1895 self->simcall.call = SIMCALL_COMM_GET_SRC_DATA;
1896 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1897 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1898 self->simcall.args[0].dp = (void*) comm;
1899 if (self != simix_global->maestro_process) {
1900 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1901 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1902 SIMIX_process_yield(self);
1904 SIMIX_simcall_handle(&self->simcall, 0);
1906 return self->simcall.result.dp;
1909 inline static void* simcall_BODY_comm_get_dst_data(smx_synchro_t comm) {
1910 smx_process_t self = SIMIX_process_self();
1912 /* Go to that function to follow the code flow through the simcall barrier */
1913 if (0) SIMIX_comm_get_dst_data(comm);
1914 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1916 self->simcall.call = SIMCALL_COMM_GET_DST_DATA;
1917 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1918 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1919 self->simcall.args[0].dp = (void*) comm;
1920 if (self != simix_global->maestro_process) {
1921 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1922 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1923 SIMIX_process_yield(self);
1925 SIMIX_simcall_handle(&self->simcall, 0);
1927 return self->simcall.result.dp;
1930 inline static smx_process_t simcall_BODY_comm_get_src_proc(smx_synchro_t comm) {
1931 smx_process_t self = SIMIX_process_self();
1933 /* Go to that function to follow the code flow through the simcall barrier */
1934 if (0) SIMIX_comm_get_src_proc(comm);
1935 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1937 self->simcall.call = SIMCALL_COMM_GET_SRC_PROC;
1938 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1939 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1940 self->simcall.args[0].dp = (void*) comm;
1941 if (self != simix_global->maestro_process) {
1942 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1943 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1944 SIMIX_process_yield(self);
1946 SIMIX_simcall_handle(&self->simcall, 0);
1948 return self->simcall.result.dp;
1951 inline static smx_process_t simcall_BODY_comm_get_dst_proc(smx_synchro_t comm) {
1952 smx_process_t self = SIMIX_process_self();
1954 /* Go to that function to follow the code flow through the simcall barrier */
1955 if (0) SIMIX_comm_get_dst_proc(comm);
1956 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1958 self->simcall.call = SIMCALL_COMM_GET_DST_PROC;
1959 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1960 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1961 self->simcall.args[0].dp = (void*) comm;
1962 if (self != simix_global->maestro_process) {
1963 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1964 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1965 SIMIX_process_yield(self);
1967 SIMIX_simcall_handle(&self->simcall, 0);
1969 return self->simcall.result.dp;
1972 inline static smx_mutex_t simcall_BODY_mutex_init() {
1973 smx_process_t self = SIMIX_process_self();
1975 /* Go to that function to follow the code flow through the simcall barrier */
1976 if (0) simcall_HANDLER_mutex_init(&self->simcall);
1977 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1979 self->simcall.call = SIMCALL_MUTEX_INIT;
1980 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1981 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1983 if (self != simix_global->maestro_process) {
1984 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1985 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1986 SIMIX_process_yield(self);
1988 SIMIX_simcall_handle(&self->simcall, 0);
1990 return self->simcall.result.dp;
1993 inline static void simcall_BODY_mutex_destroy(smx_mutex_t mutex) {
1994 smx_process_t self = SIMIX_process_self();
1996 /* Go to that function to follow the code flow through the simcall barrier */
1997 if (0) SIMIX_mutex_destroy(mutex);
1998 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2000 self->simcall.call = SIMCALL_MUTEX_DESTROY;
2001 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2002 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2003 self->simcall.args[0].dp = (void*) mutex;
2004 if (self != simix_global->maestro_process) {
2005 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2006 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2007 SIMIX_process_yield(self);
2009 SIMIX_simcall_handle(&self->simcall, 0);
2014 inline static void simcall_BODY_mutex_lock(smx_mutex_t mutex) {
2015 smx_process_t self = SIMIX_process_self();
2017 /* Go to that function to follow the code flow through the simcall barrier */
2018 if (0) simcall_HANDLER_mutex_lock(&self->simcall, mutex);
2019 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2021 self->simcall.call = SIMCALL_MUTEX_LOCK;
2022 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2023 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2024 self->simcall.args[0].dp = (void*) mutex;
2025 if (self != simix_global->maestro_process) {
2026 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2027 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2028 SIMIX_process_yield(self);
2030 SIMIX_simcall_handle(&self->simcall, 0);
2035 inline static int simcall_BODY_mutex_trylock(smx_mutex_t mutex) {
2036 smx_process_t self = SIMIX_process_self();
2038 /* Go to that function to follow the code flow through the simcall barrier */
2039 if (0) simcall_HANDLER_mutex_trylock(&self->simcall, mutex);
2040 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2042 self->simcall.call = SIMCALL_MUTEX_TRYLOCK;
2043 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2044 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2045 self->simcall.args[0].dp = (void*) mutex;
2046 if (self != simix_global->maestro_process) {
2047 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2048 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2049 SIMIX_process_yield(self);
2051 SIMIX_simcall_handle(&self->simcall, 0);
2053 return self->simcall.result.i;
2056 inline static void simcall_BODY_mutex_unlock(smx_mutex_t mutex) {
2057 smx_process_t self = SIMIX_process_self();
2059 /* Go to that function to follow the code flow through the simcall barrier */
2060 if (0) simcall_HANDLER_mutex_unlock(&self->simcall, mutex);
2061 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2063 self->simcall.call = SIMCALL_MUTEX_UNLOCK;
2064 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2065 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2066 self->simcall.args[0].dp = (void*) mutex;
2067 if (self != simix_global->maestro_process) {
2068 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2069 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2070 SIMIX_process_yield(self);
2072 SIMIX_simcall_handle(&self->simcall, 0);
2077 inline static smx_cond_t simcall_BODY_cond_init() {
2078 smx_process_t self = SIMIX_process_self();
2080 /* Go to that function to follow the code flow through the simcall barrier */
2081 if (0) SIMIX_cond_init();
2082 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2084 self->simcall.call = SIMCALL_COND_INIT;
2085 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2086 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2088 if (self != simix_global->maestro_process) {
2089 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2090 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2091 SIMIX_process_yield(self);
2093 SIMIX_simcall_handle(&self->simcall, 0);
2095 return self->simcall.result.dp;
2098 inline static void simcall_BODY_cond_destroy(smx_cond_t cond) {
2099 smx_process_t self = SIMIX_process_self();
2101 /* Go to that function to follow the code flow through the simcall barrier */
2102 if (0) SIMIX_cond_destroy(cond);
2103 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2105 self->simcall.call = SIMCALL_COND_DESTROY;
2106 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2107 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2108 self->simcall.args[0].dp = (void*) cond;
2109 if (self != simix_global->maestro_process) {
2110 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2111 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2112 SIMIX_process_yield(self);
2114 SIMIX_simcall_handle(&self->simcall, 0);
2119 inline static void simcall_BODY_cond_signal(smx_cond_t cond) {
2120 smx_process_t self = SIMIX_process_self();
2122 /* Go to that function to follow the code flow through the simcall barrier */
2123 if (0) SIMIX_cond_signal(cond);
2124 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2126 self->simcall.call = SIMCALL_COND_SIGNAL;
2127 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2128 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2129 self->simcall.args[0].dp = (void*) cond;
2130 if (self != simix_global->maestro_process) {
2131 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2132 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2133 SIMIX_process_yield(self);
2135 SIMIX_simcall_handle(&self->simcall, 0);
2140 inline static void simcall_BODY_cond_wait(smx_cond_t cond, smx_mutex_t mutex) {
2141 smx_process_t self = SIMIX_process_self();
2143 /* Go to that function to follow the code flow through the simcall barrier */
2144 if (0) simcall_HANDLER_cond_wait(&self->simcall, cond, mutex);
2145 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2147 self->simcall.call = SIMCALL_COND_WAIT;
2148 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2149 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2150 self->simcall.args[0].dp = (void*) cond;
2151 self->simcall.args[1].dp = (void*) mutex;
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);
2157 SIMIX_simcall_handle(&self->simcall, 0);
2162 inline static void simcall_BODY_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double timeout) {
2163 smx_process_t self = SIMIX_process_self();
2165 /* Go to that function to follow the code flow through the simcall barrier */
2166 if (0) simcall_HANDLER_cond_wait_timeout(&self->simcall, cond, mutex, timeout);
2167 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2169 self->simcall.call = SIMCALL_COND_WAIT_TIMEOUT;
2170 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2171 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2172 self->simcall.args[0].dp = (void*) cond;
2173 self->simcall.args[1].dp = (void*) mutex;
2174 self->simcall.args[2].d = (double) timeout;
2175 if (self != simix_global->maestro_process) {
2176 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2177 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2178 SIMIX_process_yield(self);
2180 SIMIX_simcall_handle(&self->simcall, 0);
2185 inline static void simcall_BODY_cond_broadcast(smx_cond_t cond) {
2186 smx_process_t self = SIMIX_process_self();
2188 /* Go to that function to follow the code flow through the simcall barrier */
2189 if (0) SIMIX_cond_broadcast(cond);
2190 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2192 self->simcall.call = SIMCALL_COND_BROADCAST;
2193 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2194 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2195 self->simcall.args[0].dp = (void*) cond;
2196 if (self != simix_global->maestro_process) {
2197 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2198 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2199 SIMIX_process_yield(self);
2201 SIMIX_simcall_handle(&self->simcall, 0);
2206 inline static smx_sem_t simcall_BODY_sem_init(unsigned int capacity) {
2207 smx_process_t self = SIMIX_process_self();
2209 /* Go to that function to follow the code flow through the simcall barrier */
2210 if (0) SIMIX_sem_init(capacity);
2211 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2213 self->simcall.call = SIMCALL_SEM_INIT;
2214 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2215 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2216 self->simcall.args[0].ui = (unsigned int) capacity;
2217 if (self != simix_global->maestro_process) {
2218 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2219 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2220 SIMIX_process_yield(self);
2222 SIMIX_simcall_handle(&self->simcall, 0);
2224 return self->simcall.result.dp;
2227 inline static void simcall_BODY_sem_destroy(smx_sem_t sem) {
2228 smx_process_t self = SIMIX_process_self();
2230 /* Go to that function to follow the code flow through the simcall barrier */
2231 if (0) SIMIX_sem_destroy(sem);
2232 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2234 self->simcall.call = SIMCALL_SEM_DESTROY;
2235 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2236 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2237 self->simcall.args[0].dp = (void*) sem;
2238 if (self != simix_global->maestro_process) {
2239 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2240 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2241 SIMIX_process_yield(self);
2243 SIMIX_simcall_handle(&self->simcall, 0);
2248 inline static void simcall_BODY_sem_release(smx_sem_t sem) {
2249 smx_process_t self = SIMIX_process_self();
2251 /* Go to that function to follow the code flow through the simcall barrier */
2252 if (0) simcall_HANDLER_sem_release(&self->simcall, sem);
2253 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2255 self->simcall.call = SIMCALL_SEM_RELEASE;
2256 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2257 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2258 self->simcall.args[0].dp = (void*) sem;
2259 if (self != simix_global->maestro_process) {
2260 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2261 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2262 SIMIX_process_yield(self);
2264 SIMIX_simcall_handle(&self->simcall, 0);
2269 inline static int simcall_BODY_sem_would_block(smx_sem_t sem) {
2270 smx_process_t self = SIMIX_process_self();
2272 /* Go to that function to follow the code flow through the simcall barrier */
2273 if (0) simcall_HANDLER_sem_would_block(&self->simcall, sem);
2274 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2276 self->simcall.call = SIMCALL_SEM_WOULD_BLOCK;
2277 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2278 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2279 self->simcall.args[0].dp = (void*) sem;
2280 if (self != simix_global->maestro_process) {
2281 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2282 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2283 SIMIX_process_yield(self);
2285 SIMIX_simcall_handle(&self->simcall, 0);
2287 return self->simcall.result.i;
2290 inline static void simcall_BODY_sem_acquire(smx_sem_t sem) {
2291 smx_process_t self = SIMIX_process_self();
2293 /* Go to that function to follow the code flow through the simcall barrier */
2294 if (0) simcall_HANDLER_sem_acquire(&self->simcall, sem);
2295 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2297 self->simcall.call = SIMCALL_SEM_ACQUIRE;
2298 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2299 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2300 self->simcall.args[0].dp = (void*) sem;
2301 if (self != simix_global->maestro_process) {
2302 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2303 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2304 SIMIX_process_yield(self);
2306 SIMIX_simcall_handle(&self->simcall, 0);
2311 inline static void simcall_BODY_sem_acquire_timeout(smx_sem_t sem, double timeout) {
2312 smx_process_t self = SIMIX_process_self();
2314 /* Go to that function to follow the code flow through the simcall barrier */
2315 if (0) simcall_HANDLER_sem_acquire_timeout(&self->simcall, sem, timeout);
2316 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2318 self->simcall.call = SIMCALL_SEM_ACQUIRE_TIMEOUT;
2319 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2320 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2321 self->simcall.args[0].dp = (void*) sem;
2322 self->simcall.args[1].d = (double) timeout;
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);
2328 SIMIX_simcall_handle(&self->simcall, 0);
2333 inline static int simcall_BODY_sem_get_capacity(smx_sem_t sem) {
2334 smx_process_t self = SIMIX_process_self();
2336 /* Go to that function to follow the code flow through the simcall barrier */
2337 if (0) simcall_HANDLER_sem_get_capacity(&self->simcall, sem);
2338 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2340 self->simcall.call = SIMCALL_SEM_GET_CAPACITY;
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*) sem;
2344 if (self != simix_global->maestro_process) {
2345 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2346 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2347 SIMIX_process_yield(self);
2349 SIMIX_simcall_handle(&self->simcall, 0);
2351 return self->simcall.result.i;
2354 inline static sg_size_t simcall_BODY_file_read(smx_file_t fd, sg_size_t size, smx_host_t host) {
2355 smx_process_t self = SIMIX_process_self();
2357 /* Go to that function to follow the code flow through the simcall barrier */
2358 if (0) simcall_HANDLER_file_read(&self->simcall, fd, size, host);
2359 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2361 self->simcall.call = SIMCALL_FILE_READ;
2362 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2363 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2364 self->simcall.args[0].dp = (void*) fd;
2365 self->simcall.args[1].sgsz = (sg_size_t) size;
2366 self->simcall.args[2].dp = (void*) host;
2367 if (self != simix_global->maestro_process) {
2368 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2369 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2370 SIMIX_process_yield(self);
2372 SIMIX_simcall_handle(&self->simcall, 0);
2374 return self->simcall.result.sgsz;
2377 inline static sg_size_t simcall_BODY_file_write(smx_file_t fd, sg_size_t size, smx_host_t host) {
2378 smx_process_t self = SIMIX_process_self();
2380 /* Go to that function to follow the code flow through the simcall barrier */
2381 if (0) simcall_HANDLER_file_write(&self->simcall, fd, size, host);
2382 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2384 self->simcall.call = SIMCALL_FILE_WRITE;
2385 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2386 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2387 self->simcall.args[0].dp = (void*) fd;
2388 self->simcall.args[1].sgsz = (sg_size_t) size;
2389 self->simcall.args[2].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);
2395 SIMIX_simcall_handle(&self->simcall, 0);
2397 return self->simcall.result.sgsz;
2400 inline static smx_file_t simcall_BODY_file_open(const char* fullpath, smx_host_t host) {
2401 smx_process_t self = SIMIX_process_self();
2403 /* Go to that function to follow the code flow through the simcall barrier */
2404 if (0) simcall_HANDLER_file_open(&self->simcall, fullpath, host);
2405 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2407 self->simcall.call = SIMCALL_FILE_OPEN;
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].cc = (const char*) fullpath;
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);
2417 SIMIX_simcall_handle(&self->simcall, 0);
2419 return self->simcall.result.dp;
2422 inline static int simcall_BODY_file_close(smx_file_t fd, smx_host_t host) {
2423 smx_process_t self = SIMIX_process_self();
2425 /* Go to that function to follow the code flow through the simcall barrier */
2426 if (0) simcall_HANDLER_file_close(&self->simcall, fd, host);
2427 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2429 self->simcall.call = SIMCALL_FILE_CLOSE;
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 self->simcall.args[1].dp = (void*) host;
2434 if (self != simix_global->maestro_process) {
2435 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2436 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2437 SIMIX_process_yield(self);
2439 SIMIX_simcall_handle(&self->simcall, 0);
2441 return self->simcall.result.i;
2444 inline static int simcall_BODY_file_unlink(smx_file_t fd, smx_host_t host) {
2445 smx_process_t self = SIMIX_process_self();
2447 /* Go to that function to follow the code flow through the simcall barrier */
2448 if (0) SIMIX_file_unlink(fd, host);
2449 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2451 self->simcall.call = SIMCALL_FILE_UNLINK;
2452 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2453 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2454 self->simcall.args[0].dp = (void*) fd;
2455 self->simcall.args[1].dp = (void*) host;
2456 if (self != simix_global->maestro_process) {
2457 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2458 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2459 SIMIX_process_yield(self);
2461 SIMIX_simcall_handle(&self->simcall, 0);
2463 return self->simcall.result.i;
2466 inline static sg_size_t simcall_BODY_file_get_size(smx_file_t fd) {
2467 smx_process_t self = SIMIX_process_self();
2469 /* Go to that function to follow the code flow through the simcall barrier */
2470 if (0) simcall_HANDLER_file_get_size(&self->simcall, fd);
2471 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2473 self->simcall.call = SIMCALL_FILE_GET_SIZE;
2474 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2475 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2476 self->simcall.args[0].dp = (void*) fd;
2477 if (self != simix_global->maestro_process) {
2478 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2479 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2480 SIMIX_process_yield(self);
2482 SIMIX_simcall_handle(&self->simcall, 0);
2484 return self->simcall.result.sgsz;
2487 inline static sg_size_t simcall_BODY_file_tell(smx_file_t fd) {
2488 smx_process_t self = SIMIX_process_self();
2490 /* Go to that function to follow the code flow through the simcall barrier */
2491 if (0) simcall_HANDLER_file_tell(&self->simcall, fd);
2492 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2494 self->simcall.call = SIMCALL_FILE_TELL;
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);
2503 SIMIX_simcall_handle(&self->simcall, 0);
2505 return self->simcall.result.sgsz;
2508 inline static int simcall_BODY_file_seek(smx_file_t fd, sg_offset_t offset, int origin) {
2509 smx_process_t self = SIMIX_process_self();
2511 /* Go to that function to follow the code flow through the simcall barrier */
2512 if (0) simcall_HANDLER_file_seek(&self->simcall, fd, offset, origin);
2513 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2515 self->simcall.call = SIMCALL_FILE_SEEK;
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].sgoff = (sg_offset_t) offset;
2520 self->simcall.args[2].i = (int) origin;
2521 if (self != simix_global->maestro_process) {
2522 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2523 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2524 SIMIX_process_yield(self);
2526 SIMIX_simcall_handle(&self->simcall, 0);
2528 return self->simcall.result.i;
2531 inline static xbt_dynar_t simcall_BODY_file_get_info(smx_file_t fd) {
2532 smx_process_t self = SIMIX_process_self();
2534 /* Go to that function to follow the code flow through the simcall barrier */
2535 if (0) simcall_HANDLER_file_get_info(&self->simcall, fd);
2536 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2538 self->simcall.call = SIMCALL_FILE_GET_INFO;
2539 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2540 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2541 self->simcall.args[0].dp = (void*) fd;
2542 if (self != simix_global->maestro_process) {
2543 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2544 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2545 SIMIX_process_yield(self);
2547 SIMIX_simcall_handle(&self->simcall, 0);
2549 return self->simcall.result.dp;
2552 inline static int simcall_BODY_file_move(smx_file_t fd, const char* fullpath) {
2553 smx_process_t self = SIMIX_process_self();
2555 /* Go to that function to follow the code flow through the simcall barrier */
2556 if (0) simcall_HANDLER_file_move(&self->simcall, fd, fullpath);
2557 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2559 self->simcall.call = SIMCALL_FILE_MOVE;
2560 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2561 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2562 self->simcall.args[0].dp = (void*) fd;
2563 self->simcall.args[1].cc = (const char*) fullpath;
2564 if (self != simix_global->maestro_process) {
2565 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2566 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2567 SIMIX_process_yield(self);
2569 SIMIX_simcall_handle(&self->simcall, 0);
2571 return self->simcall.result.i;
2574 inline static sg_size_t simcall_BODY_storage_get_free_size(smx_storage_t storage) {
2575 smx_process_t self = SIMIX_process_self();
2577 /* Go to that function to follow the code flow through the simcall barrier */
2578 if (0) simcall_HANDLER_storage_get_free_size(&self->simcall, storage);
2579 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2581 self->simcall.call = SIMCALL_STORAGE_GET_FREE_SIZE;
2582 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2583 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2584 self->simcall.args[0].dp = (void*) storage;
2585 if (self != simix_global->maestro_process) {
2586 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2587 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2588 SIMIX_process_yield(self);
2590 SIMIX_simcall_handle(&self->simcall, 0);
2592 return self->simcall.result.sgsz;
2595 inline static sg_size_t simcall_BODY_storage_get_used_size(smx_storage_t name) {
2596 smx_process_t self = SIMIX_process_self();
2598 /* Go to that function to follow the code flow through the simcall barrier */
2599 if (0) simcall_HANDLER_storage_get_used_size(&self->simcall, name);
2600 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2602 self->simcall.call = SIMCALL_STORAGE_GET_USED_SIZE;
2603 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2604 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2605 self->simcall.args[0].dp = (void*) name;
2606 if (self != simix_global->maestro_process) {
2607 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2608 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2609 SIMIX_process_yield(self);
2611 SIMIX_simcall_handle(&self->simcall, 0);
2613 return self->simcall.result.sgsz;
2616 inline static xbt_dict_t simcall_BODY_storage_get_properties(smx_storage_t storage) {
2617 smx_process_t self = SIMIX_process_self();
2619 /* Go to that function to follow the code flow through the simcall barrier */
2620 if (0) SIMIX_storage_get_properties(storage);
2621 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2623 self->simcall.call = SIMCALL_STORAGE_GET_PROPERTIES;
2624 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2625 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2626 self->simcall.args[0].dp = (void*) storage;
2627 if (self != simix_global->maestro_process) {
2628 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2629 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2630 SIMIX_process_yield(self);
2632 SIMIX_simcall_handle(&self->simcall, 0);
2634 return self->simcall.result.dp;
2637 inline static xbt_dict_t simcall_BODY_storage_get_content(smx_storage_t storage) {
2638 smx_process_t self = SIMIX_process_self();
2640 /* Go to that function to follow the code flow through the simcall barrier */
2641 if (0) SIMIX_storage_get_content(storage);
2642 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2644 self->simcall.call = SIMCALL_STORAGE_GET_CONTENT;
2645 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2646 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2647 self->simcall.args[0].dp = (void*) storage;
2648 if (self != simix_global->maestro_process) {
2649 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2650 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2651 SIMIX_process_yield(self);
2653 SIMIX_simcall_handle(&self->simcall, 0);
2655 return self->simcall.result.dp;
2658 inline static xbt_dict_t simcall_BODY_asr_get_properties(const char* name) {
2659 smx_process_t self = SIMIX_process_self();
2661 /* Go to that function to follow the code flow through the simcall barrier */
2662 if (0) simcall_HANDLER_asr_get_properties(&self->simcall, name);
2663 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2665 self->simcall.call = SIMCALL_ASR_GET_PROPERTIES;
2666 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2667 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2668 self->simcall.args[0].cc = (const char*) name;
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);
2674 SIMIX_simcall_handle(&self->simcall, 0);
2676 return self->simcall.result.dp;
2679 inline static int simcall_BODY_mc_random(int min, int max) {
2680 smx_process_t self = SIMIX_process_self();
2682 /* Go to that function to follow the code flow through the simcall barrier */
2683 if (0) simcall_HANDLER_mc_random(&self->simcall, min, max);
2684 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2686 self->simcall.call = SIMCALL_MC_RANDOM;
2687 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2688 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2689 self->simcall.args[0].i = (int) min;
2690 self->simcall.args[1].i = (int) max;
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);
2696 SIMIX_simcall_handle(&self->simcall, 0);
2698 return self->simcall.result.i;
2701 inline static void simcall_BODY_set_category(smx_synchro_t synchro, const char* category) {
2702 smx_process_t self = SIMIX_process_self();
2704 /* Go to that function to follow the code flow through the simcall barrier */
2705 if (0) SIMIX_set_category(synchro, category);
2706 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2708 self->simcall.call = SIMCALL_SET_CATEGORY;
2709 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2710 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2711 self->simcall.args[0].dp = (void*) synchro;
2712 self->simcall.args[1].cc = (const char*) category;
2713 if (self != simix_global->maestro_process) {
2714 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2715 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2716 SIMIX_process_yield(self);
2718 SIMIX_simcall_handle(&self->simcall, 0);
2722 #ifdef HAVE_LATENCY_BOUND_TRACKING
2724 inline static int simcall_BODY_comm_is_latency_bounded(smx_synchro_t comm) {
2725 smx_process_t self = SIMIX_process_self();
2727 /* Go to that function to follow the code flow through the simcall barrier */
2728 if (0) SIMIX_comm_is_latency_bounded(comm);
2729 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2731 self->simcall.call = SIMCALL_COMM_IS_LATENCY_BOUNDED;
2732 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2733 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2734 self->simcall.args[0].dp = (void*) comm;
2735 if (self != simix_global->maestro_process) {
2736 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2737 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2738 SIMIX_process_yield(self);
2740 SIMIX_simcall_handle(&self->simcall, 0);
2742 return self->simcall.result.i;
2748 inline static mc_snapshot_t simcall_BODY_mc_snapshot() {
2749 smx_process_t self = SIMIX_process_self();
2751 /* Go to that function to follow the code flow through the simcall barrier */
2752 if (0) simcall_HANDLER_mc_snapshot(&self->simcall);
2753 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2755 self->simcall.call = SIMCALL_MC_SNAPSHOT;
2756 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2757 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2759 if (self != simix_global->maestro_process) {
2760 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2761 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2762 SIMIX_process_yield(self);
2764 SIMIX_simcall_handle(&self->simcall, 0);
2766 return self->simcall.result.dp;
2769 inline static int simcall_BODY_mc_compare_snapshots(mc_snapshot_t s1, mc_snapshot_t s2) {
2770 smx_process_t self = SIMIX_process_self();
2772 /* Go to that function to follow the code flow through the simcall barrier */
2773 if (0) simcall_HANDLER_mc_compare_snapshots(&self->simcall, s1, s2);
2774 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2776 self->simcall.call = SIMCALL_MC_COMPARE_SNAPSHOTS;
2777 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2778 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2779 self->simcall.args[0].dp = (void*) s1;
2780 self->simcall.args[1].dp = (void*) s2;
2781 if (self != simix_global->maestro_process) {
2782 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2783 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2784 SIMIX_process_yield(self);
2786 SIMIX_simcall_handle(&self->simcall, 0);
2788 return self->simcall.result.i;