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_interface.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 void simcall_BODY_host_set_power_peak_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_set_power_peak_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_SET_POWER_PEAK_AT;
302 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
303 memset(self->simcall.args, 0, sizeof(self->simcall.args));
304 self->simcall.args[0].dp = (void*) host;
305 self->simcall.args[1].i = (int) pstate_index;
306 if (self != simix_global->maestro_process) {
307 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
308 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
309 SIMIX_process_yield(self);
311 SIMIX_simcall_handle(&self->simcall, 0);
316 inline static double simcall_BODY_host_get_consumed_energy(smx_host_t host) {
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_consumed_energy(host);
321 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
323 self->simcall.call = SIMCALL_HOST_GET_CONSUMED_ENERGY;
324 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
325 memset(self->simcall.args, 0, sizeof(self->simcall.args));
326 self->simcall.args[0].dp = (void*) host;
327 if (self != simix_global->maestro_process) {
328 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
329 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
330 SIMIX_process_yield(self);
332 SIMIX_simcall_handle(&self->simcall, 0);
334 return self->simcall.result.d;
337 inline static smx_synchro_t simcall_BODY_host_execute(const char* name, smx_host_t host, double flops_amount, double priority, double bound, unsigned long affinity_mask) {
338 smx_process_t self = SIMIX_process_self();
340 /* Go to that function to follow the code flow through the simcall barrier */
341 if (0) SIMIX_host_execute(name, host, flops_amount, priority, bound, affinity_mask);
342 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
344 self->simcall.call = SIMCALL_HOST_EXECUTE;
345 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
346 memset(self->simcall.args, 0, sizeof(self->simcall.args));
347 self->simcall.args[0].cc = (const char*) name;
348 self->simcall.args[1].dp = (void*) host;
349 self->simcall.args[2].d = (double) flops_amount;
350 self->simcall.args[3].d = (double) priority;
351 self->simcall.args[4].d = (double) bound;
352 self->simcall.args[5].ul = (unsigned long) affinity_mask;
353 if (self != simix_global->maestro_process) {
354 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
355 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
356 SIMIX_process_yield(self);
358 SIMIX_simcall_handle(&self->simcall, 0);
360 return self->simcall.result.dp;
363 inline static smx_synchro_t simcall_BODY_host_parallel_execute(const char* name, int host_nb, smx_host_t* host_list, double* flops_amount, double* bytes_amount, double amount, double rate) {
364 smx_process_t self = SIMIX_process_self();
366 /* Go to that function to follow the code flow through the simcall barrier */
367 if (0) SIMIX_host_parallel_execute(name, host_nb, host_list, flops_amount, bytes_amount, amount, rate);
368 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
370 self->simcall.call = SIMCALL_HOST_PARALLEL_EXECUTE;
371 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
372 memset(self->simcall.args, 0, sizeof(self->simcall.args));
373 self->simcall.args[0].cc = (const char*) name;
374 self->simcall.args[1].i = (int) host_nb;
375 self->simcall.args[2].dp = (void*) host_list;
376 self->simcall.args[3].dp = (void*) flops_amount;
377 self->simcall.args[4].dp = (void*) bytes_amount;
378 self->simcall.args[5].d = (double) amount;
379 self->simcall.args[6].d = (double) rate;
380 if (self != simix_global->maestro_process) {
381 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
382 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
383 SIMIX_process_yield(self);
385 SIMIX_simcall_handle(&self->simcall, 0);
387 return self->simcall.result.dp;
390 inline static void simcall_BODY_host_execution_destroy(smx_synchro_t execution) {
391 smx_process_t self = SIMIX_process_self();
393 /* Go to that function to follow the code flow through the simcall barrier */
394 if (0) SIMIX_host_execution_destroy(execution);
395 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
397 self->simcall.call = SIMCALL_HOST_EXECUTION_DESTROY;
398 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
399 memset(self->simcall.args, 0, sizeof(self->simcall.args));
400 self->simcall.args[0].dp = (void*) execution;
401 if (self != simix_global->maestro_process) {
402 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
403 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
404 SIMIX_process_yield(self);
406 SIMIX_simcall_handle(&self->simcall, 0);
411 inline static void simcall_BODY_host_execution_cancel(smx_synchro_t execution) {
412 smx_process_t self = SIMIX_process_self();
414 /* Go to that function to follow the code flow through the simcall barrier */
415 if (0) SIMIX_host_execution_cancel(execution);
416 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
418 self->simcall.call = SIMCALL_HOST_EXECUTION_CANCEL;
419 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
420 memset(self->simcall.args, 0, sizeof(self->simcall.args));
421 self->simcall.args[0].dp = (void*) execution;
422 if (self != simix_global->maestro_process) {
423 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
424 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
425 SIMIX_process_yield(self);
427 SIMIX_simcall_handle(&self->simcall, 0);
432 inline static double simcall_BODY_host_execution_get_remains(smx_synchro_t execution) {
433 smx_process_t self = SIMIX_process_self();
435 /* Go to that function to follow the code flow through the simcall barrier */
436 if (0) SIMIX_host_execution_get_remains(execution);
437 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
439 self->simcall.call = SIMCALL_HOST_EXECUTION_GET_REMAINS;
440 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
441 memset(self->simcall.args, 0, sizeof(self->simcall.args));
442 self->simcall.args[0].dp = (void*) execution;
443 if (self != simix_global->maestro_process) {
444 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
445 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
446 SIMIX_process_yield(self);
448 SIMIX_simcall_handle(&self->simcall, 0);
450 return self->simcall.result.d;
453 inline static e_smx_state_t simcall_BODY_host_execution_get_state(smx_synchro_t execution) {
454 smx_process_t self = SIMIX_process_self();
456 /* Go to that function to follow the code flow through the simcall barrier */
457 if (0) SIMIX_host_execution_get_state(execution);
458 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
460 self->simcall.call = SIMCALL_HOST_EXECUTION_GET_STATE;
461 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
462 memset(self->simcall.args, 0, sizeof(self->simcall.args));
463 self->simcall.args[0].dp = (void*) execution;
464 if (self != simix_global->maestro_process) {
465 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
466 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
467 SIMIX_process_yield(self);
469 SIMIX_simcall_handle(&self->simcall, 0);
471 return self->simcall.result.i;
474 inline static void simcall_BODY_host_execution_set_priority(smx_synchro_t execution, double priority) {
475 smx_process_t self = SIMIX_process_self();
477 /* Go to that function to follow the code flow through the simcall barrier */
478 if (0) SIMIX_host_execution_set_priority(execution, priority);
479 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
481 self->simcall.call = SIMCALL_HOST_EXECUTION_SET_PRIORITY;
482 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
483 memset(self->simcall.args, 0, sizeof(self->simcall.args));
484 self->simcall.args[0].dp = (void*) execution;
485 self->simcall.args[1].d = (double) priority;
486 if (self != simix_global->maestro_process) {
487 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
488 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
489 SIMIX_process_yield(self);
491 SIMIX_simcall_handle(&self->simcall, 0);
496 inline static void simcall_BODY_host_execution_set_bound(smx_synchro_t execution, double bound) {
497 smx_process_t self = SIMIX_process_self();
499 /* Go to that function to follow the code flow through the simcall barrier */
500 if (0) SIMIX_host_execution_set_bound(execution, bound);
501 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
503 self->simcall.call = SIMCALL_HOST_EXECUTION_SET_BOUND;
504 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
505 memset(self->simcall.args, 0, sizeof(self->simcall.args));
506 self->simcall.args[0].dp = (void*) execution;
507 self->simcall.args[1].d = (double) bound;
508 if (self != simix_global->maestro_process) {
509 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
510 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
511 SIMIX_process_yield(self);
513 SIMIX_simcall_handle(&self->simcall, 0);
518 inline static void simcall_BODY_host_execution_set_affinity(smx_synchro_t execution, smx_host_t ws, unsigned long mask) {
519 smx_process_t self = SIMIX_process_self();
521 /* Go to that function to follow the code flow through the simcall barrier */
522 if (0) SIMIX_host_execution_set_affinity(execution, ws, mask);
523 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
525 self->simcall.call = SIMCALL_HOST_EXECUTION_SET_AFFINITY;
526 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
527 memset(self->simcall.args, 0, sizeof(self->simcall.args));
528 self->simcall.args[0].dp = (void*) execution;
529 self->simcall.args[1].dp = (void*) ws;
530 self->simcall.args[2].ul = (unsigned long) mask;
531 if (self != simix_global->maestro_process) {
532 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
533 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
534 SIMIX_process_yield(self);
536 SIMIX_simcall_handle(&self->simcall, 0);
541 inline static int simcall_BODY_host_execution_wait(smx_synchro_t execution) {
542 smx_process_t self = SIMIX_process_self();
544 /* Go to that function to follow the code flow through the simcall barrier */
545 if (0) simcall_HANDLER_host_execution_wait(&self->simcall, execution);
546 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
548 self->simcall.call = SIMCALL_HOST_EXECUTION_WAIT;
549 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
550 memset(self->simcall.args, 0, sizeof(self->simcall.args));
551 self->simcall.args[0].dp = (void*) execution;
552 if (self != simix_global->maestro_process) {
553 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
554 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
555 SIMIX_process_yield(self);
557 SIMIX_simcall_handle(&self->simcall, 0);
559 return self->simcall.result.i;
562 inline static xbt_dict_t simcall_BODY_host_get_mounted_storage_list(smx_host_t host) {
563 smx_process_t self = SIMIX_process_self();
565 /* Go to that function to follow the code flow through the simcall barrier */
566 if (0) SIMIX_host_get_mounted_storage_list(host);
567 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
569 self->simcall.call = SIMCALL_HOST_GET_MOUNTED_STORAGE_LIST;
570 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
571 memset(self->simcall.args, 0, sizeof(self->simcall.args));
572 self->simcall.args[0].dp = (void*) host;
573 if (self != simix_global->maestro_process) {
574 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
575 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
576 SIMIX_process_yield(self);
578 SIMIX_simcall_handle(&self->simcall, 0);
580 return self->simcall.result.dp;
583 inline static xbt_dynar_t simcall_BODY_host_get_attached_storage_list(smx_host_t host) {
584 smx_process_t self = SIMIX_process_self();
586 /* Go to that function to follow the code flow through the simcall barrier */
587 if (0) SIMIX_host_get_attached_storage_list(host);
588 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
590 self->simcall.call = SIMCALL_HOST_GET_ATTACHED_STORAGE_LIST;
591 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
592 memset(self->simcall.args, 0, sizeof(self->simcall.args));
593 self->simcall.args[0].dp = (void*) host;
594 if (self != simix_global->maestro_process) {
595 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
596 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
597 SIMIX_process_yield(self);
599 SIMIX_simcall_handle(&self->simcall, 0);
601 return self->simcall.result.dp;
604 inline static void simcall_BODY_host_get_params(smx_host_t ind_vm, ws_params_t params) {
605 smx_process_t self = SIMIX_process_self();
607 /* Go to that function to follow the code flow through the simcall barrier */
608 if (0) SIMIX_host_get_params(ind_vm, params);
609 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
611 self->simcall.call = SIMCALL_HOST_GET_PARAMS;
612 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
613 memset(self->simcall.args, 0, sizeof(self->simcall.args));
614 self->simcall.args[0].dp = (void*) ind_vm;
615 self->simcall.args[1].dp = (void*) params;
616 if (self != simix_global->maestro_process) {
617 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
618 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
619 SIMIX_process_yield(self);
621 SIMIX_simcall_handle(&self->simcall, 0);
626 inline static void simcall_BODY_host_set_params(smx_host_t ind_vm, ws_params_t params) {
627 smx_process_t self = SIMIX_process_self();
629 /* Go to that function to follow the code flow through the simcall barrier */
630 if (0) SIMIX_host_set_params(ind_vm, params);
631 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
633 self->simcall.call = SIMCALL_HOST_SET_PARAMS;
634 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
635 memset(self->simcall.args, 0, sizeof(self->simcall.args));
636 self->simcall.args[0].dp = (void*) ind_vm;
637 self->simcall.args[1].dp = (void*) params;
638 if (self != simix_global->maestro_process) {
639 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
640 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
641 SIMIX_process_yield(self);
643 SIMIX_simcall_handle(&self->simcall, 0);
648 inline static smx_host_t simcall_BODY_vm_create(const char* name, smx_host_t ind_pm) {
649 smx_process_t self = SIMIX_process_self();
651 /* Go to that function to follow the code flow through the simcall barrier */
652 if (0) SIMIX_vm_create(name, ind_pm);
653 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
655 self->simcall.call = SIMCALL_VM_CREATE;
656 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
657 memset(self->simcall.args, 0, sizeof(self->simcall.args));
658 self->simcall.args[0].cc = (const char*) name;
659 self->simcall.args[1].dp = (void*) ind_pm;
660 if (self != simix_global->maestro_process) {
661 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
662 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
663 SIMIX_process_yield(self);
665 SIMIX_simcall_handle(&self->simcall, 0);
667 return self->simcall.result.dp;
670 inline static void simcall_BODY_vm_start(smx_host_t ind_vm) {
671 smx_process_t self = SIMIX_process_self();
673 /* Go to that function to follow the code flow through the simcall barrier */
674 if (0) SIMIX_vm_start(ind_vm);
675 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
677 self->simcall.call = SIMCALL_VM_START;
678 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
679 memset(self->simcall.args, 0, sizeof(self->simcall.args));
680 self->simcall.args[0].dp = (void*) ind_vm;
681 if (self != simix_global->maestro_process) {
682 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
683 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
684 SIMIX_process_yield(self);
686 SIMIX_simcall_handle(&self->simcall, 0);
691 inline static int simcall_BODY_vm_get_state(smx_host_t ind_vm) {
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_vm_get_state(ind_vm);
696 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
698 self->simcall.call = SIMCALL_VM_GET_STATE;
699 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
700 memset(self->simcall.args, 0, sizeof(self->simcall.args));
701 self->simcall.args[0].dp = (void*) ind_vm;
702 if (self != simix_global->maestro_process) {
703 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
704 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
705 SIMIX_process_yield(self);
707 SIMIX_simcall_handle(&self->simcall, 0);
709 return self->simcall.result.i;
712 inline static void simcall_BODY_vm_migrate(smx_host_t ind_vm, smx_host_t ind_dst_pm) {
713 smx_process_t self = SIMIX_process_self();
715 /* Go to that function to follow the code flow through the simcall barrier */
716 if (0) SIMIX_vm_migrate(ind_vm, ind_dst_pm);
717 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
719 self->simcall.call = SIMCALL_VM_MIGRATE;
720 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
721 memset(self->simcall.args, 0, sizeof(self->simcall.args));
722 self->simcall.args[0].dp = (void*) ind_vm;
723 self->simcall.args[1].dp = (void*) ind_dst_pm;
724 if (self != simix_global->maestro_process) {
725 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
726 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
727 SIMIX_process_yield(self);
729 SIMIX_simcall_handle(&self->simcall, 0);
734 inline static void* simcall_BODY_vm_get_pm(smx_host_t ind_vm) {
735 smx_process_t self = SIMIX_process_self();
737 /* Go to that function to follow the code flow through the simcall barrier */
738 if (0) SIMIX_vm_get_pm(ind_vm);
739 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
741 self->simcall.call = SIMCALL_VM_GET_PM;
742 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
743 memset(self->simcall.args, 0, sizeof(self->simcall.args));
744 self->simcall.args[0].dp = (void*) ind_vm;
745 if (self != simix_global->maestro_process) {
746 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
747 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
748 SIMIX_process_yield(self);
750 SIMIX_simcall_handle(&self->simcall, 0);
752 return self->simcall.result.dp;
755 inline static void simcall_BODY_vm_set_bound(smx_host_t ind_vm, double bound) {
756 smx_process_t self = SIMIX_process_self();
758 /* Go to that function to follow the code flow through the simcall barrier */
759 if (0) SIMIX_vm_set_bound(ind_vm, bound);
760 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
762 self->simcall.call = SIMCALL_VM_SET_BOUND;
763 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
764 memset(self->simcall.args, 0, sizeof(self->simcall.args));
765 self->simcall.args[0].dp = (void*) ind_vm;
766 self->simcall.args[1].d = (double) bound;
767 if (self != simix_global->maestro_process) {
768 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
769 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
770 SIMIX_process_yield(self);
772 SIMIX_simcall_handle(&self->simcall, 0);
777 inline static void simcall_BODY_vm_set_affinity(smx_host_t ind_vm, smx_host_t ind_pm, unsigned long mask) {
778 smx_process_t self = SIMIX_process_self();
780 /* Go to that function to follow the code flow through the simcall barrier */
781 if (0) SIMIX_vm_set_affinity(ind_vm, ind_pm, mask);
782 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
784 self->simcall.call = SIMCALL_VM_SET_AFFINITY;
785 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
786 memset(self->simcall.args, 0, sizeof(self->simcall.args));
787 self->simcall.args[0].dp = (void*) ind_vm;
788 self->simcall.args[1].dp = (void*) ind_pm;
789 self->simcall.args[2].ul = (unsigned long) mask;
790 if (self != simix_global->maestro_process) {
791 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
792 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
793 SIMIX_process_yield(self);
795 SIMIX_simcall_handle(&self->simcall, 0);
800 inline static void simcall_BODY_vm_destroy(smx_host_t ind_vm) {
801 smx_process_t self = SIMIX_process_self();
803 /* Go to that function to follow the code flow through the simcall barrier */
804 if (0) SIMIX_vm_destroy(ind_vm);
805 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
807 self->simcall.call = SIMCALL_VM_DESTROY;
808 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
809 memset(self->simcall.args, 0, sizeof(self->simcall.args));
810 self->simcall.args[0].dp = (void*) ind_vm;
811 if (self != simix_global->maestro_process) {
812 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
813 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
814 SIMIX_process_yield(self);
816 SIMIX_simcall_handle(&self->simcall, 0);
821 inline static void simcall_BODY_vm_suspend(smx_host_t ind_vm) {
822 smx_process_t self = SIMIX_process_self();
824 /* Go to that function to follow the code flow through the simcall barrier */
825 if (0) simcall_HANDLER_vm_suspend(&self->simcall, ind_vm);
826 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
828 self->simcall.call = SIMCALL_VM_SUSPEND;
829 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
830 memset(self->simcall.args, 0, sizeof(self->simcall.args));
831 self->simcall.args[0].dp = (void*) ind_vm;
832 if (self != simix_global->maestro_process) {
833 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
834 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
835 SIMIX_process_yield(self);
837 SIMIX_simcall_handle(&self->simcall, 0);
842 inline static void simcall_BODY_vm_resume(smx_host_t ind_vm) {
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) simcall_HANDLER_vm_resume(&self->simcall, ind_vm);
847 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
849 self->simcall.call = SIMCALL_VM_RESUME;
850 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
851 memset(self->simcall.args, 0, sizeof(self->simcall.args));
852 self->simcall.args[0].dp = (void*) ind_vm;
853 if (self != simix_global->maestro_process) {
854 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
855 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
856 SIMIX_process_yield(self);
858 SIMIX_simcall_handle(&self->simcall, 0);
863 inline static void simcall_BODY_vm_shutdown(smx_host_t ind_vm) {
864 smx_process_t self = SIMIX_process_self();
866 /* Go to that function to follow the code flow through the simcall barrier */
867 if (0) simcall_HANDLER_vm_shutdown(&self->simcall, ind_vm);
868 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
870 self->simcall.call = SIMCALL_VM_SHUTDOWN;
871 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
872 memset(self->simcall.args, 0, sizeof(self->simcall.args));
873 self->simcall.args[0].dp = (void*) ind_vm;
874 if (self != simix_global->maestro_process) {
875 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
876 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
877 SIMIX_process_yield(self);
879 SIMIX_simcall_handle(&self->simcall, 0);
884 inline static void simcall_BODY_vm_save(smx_host_t ind_vm) {
885 smx_process_t self = SIMIX_process_self();
887 /* Go to that function to follow the code flow through the simcall barrier */
888 if (0) simcall_HANDLER_vm_save(&self->simcall, ind_vm);
889 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
891 self->simcall.call = SIMCALL_VM_SAVE;
892 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
893 memset(self->simcall.args, 0, sizeof(self->simcall.args));
894 self->simcall.args[0].dp = (void*) ind_vm;
895 if (self != simix_global->maestro_process) {
896 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
897 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
898 SIMIX_process_yield(self);
900 SIMIX_simcall_handle(&self->simcall, 0);
905 inline static void simcall_BODY_vm_restore(smx_host_t ind_vm) {
906 smx_process_t self = SIMIX_process_self();
908 /* Go to that function to follow the code flow through the simcall barrier */
909 if (0) simcall_HANDLER_vm_restore(&self->simcall, ind_vm);
910 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
912 self->simcall.call = SIMCALL_VM_RESTORE;
913 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
914 memset(self->simcall.args, 0, sizeof(self->simcall.args));
915 self->simcall.args[0].dp = (void*) ind_vm;
916 if (self != simix_global->maestro_process) {
917 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
918 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
919 SIMIX_process_yield(self);
921 SIMIX_simcall_handle(&self->simcall, 0);
926 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) {
927 smx_process_t self = SIMIX_process_self();
929 /* Go to that function to follow the code flow through the simcall barrier */
930 if (0) simcall_HANDLER_process_create(&self->simcall, process, name, code, data, hostname, kill_time, argc, argv, properties, auto_restart);
931 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
933 self->simcall.call = SIMCALL_PROCESS_CREATE;
934 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
935 memset(self->simcall.args, 0, sizeof(self->simcall.args));
936 self->simcall.args[0].dp = (void*) process;
937 self->simcall.args[1].cc = (const char*) name;
938 self->simcall.args[2].fp = (FPtr) code;
939 self->simcall.args[3].dp = (void*) data;
940 self->simcall.args[4].cc = (const char*) hostname;
941 self->simcall.args[5].d = (double) kill_time;
942 self->simcall.args[6].i = (int) argc;
943 self->simcall.args[7].dp = (void*) argv;
944 self->simcall.args[8].dp = (void*) properties;
945 self->simcall.args[9].i = (int) auto_restart;
946 if (self != simix_global->maestro_process) {
947 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
948 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
949 SIMIX_process_yield(self);
951 SIMIX_simcall_handle(&self->simcall, 0);
956 inline static void simcall_BODY_process_kill(smx_process_t process) {
957 smx_process_t self = SIMIX_process_self();
959 /* Go to that function to follow the code flow through the simcall barrier */
960 if (0) simcall_HANDLER_process_kill(&self->simcall, process);
961 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
963 self->simcall.call = SIMCALL_PROCESS_KILL;
964 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
965 memset(self->simcall.args, 0, sizeof(self->simcall.args));
966 self->simcall.args[0].dp = (void*) process;
967 if (self != simix_global->maestro_process) {
968 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
969 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
970 SIMIX_process_yield(self);
972 SIMIX_simcall_handle(&self->simcall, 0);
977 inline static void simcall_BODY_process_killall(int reset_pid) {
978 smx_process_t self = SIMIX_process_self();
980 /* Go to that function to follow the code flow through the simcall barrier */
981 if (0) simcall_HANDLER_process_killall(&self->simcall, reset_pid);
982 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
984 self->simcall.call = SIMCALL_PROCESS_KILLALL;
985 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
986 memset(self->simcall.args, 0, sizeof(self->simcall.args));
987 self->simcall.args[0].i = (int) reset_pid;
988 if (self != simix_global->maestro_process) {
989 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
990 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
991 SIMIX_process_yield(self);
993 SIMIX_simcall_handle(&self->simcall, 0);
998 inline static void simcall_BODY_process_cleanup(smx_process_t process) {
999 smx_process_t self = SIMIX_process_self();
1001 /* Go to that function to follow the code flow through the simcall barrier */
1002 if (0) SIMIX_process_cleanup(process);
1003 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1005 self->simcall.call = SIMCALL_PROCESS_CLEANUP;
1006 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1007 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1008 self->simcall.args[0].dp = (void*) process;
1009 if (self != simix_global->maestro_process) {
1010 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1011 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1012 SIMIX_process_yield(self);
1014 SIMIX_simcall_handle(&self->simcall, 0);
1019 inline static void simcall_BODY_process_change_host(smx_process_t process, smx_host_t dest) {
1020 smx_process_t self = SIMIX_process_self();
1022 /* Go to that function to follow the code flow through the simcall barrier */
1023 if (0) simcall_HANDLER_process_change_host(&self->simcall, process, dest);
1024 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1026 self->simcall.call = SIMCALL_PROCESS_CHANGE_HOST;
1027 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1028 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1029 self->simcall.args[0].dp = (void*) process;
1030 self->simcall.args[1].dp = (void*) dest;
1031 if (self != simix_global->maestro_process) {
1032 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1033 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1034 SIMIX_process_yield(self);
1036 SIMIX_simcall_handle(&self->simcall, 0);
1041 inline static void simcall_BODY_process_suspend(smx_process_t process) {
1042 smx_process_t self = SIMIX_process_self();
1044 /* Go to that function to follow the code flow through the simcall barrier */
1045 if (0) simcall_HANDLER_process_suspend(&self->simcall, process);
1046 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1048 self->simcall.call = SIMCALL_PROCESS_SUSPEND;
1049 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1050 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1051 self->simcall.args[0].dp = (void*) process;
1052 if (self != simix_global->maestro_process) {
1053 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1054 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1055 SIMIX_process_yield(self);
1057 SIMIX_simcall_handle(&self->simcall, 0);
1062 inline static void simcall_BODY_process_resume(smx_process_t process) {
1063 smx_process_t self = SIMIX_process_self();
1065 /* Go to that function to follow the code flow through the simcall barrier */
1066 if (0) simcall_HANDLER_process_resume(&self->simcall, process);
1067 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1069 self->simcall.call = SIMCALL_PROCESS_RESUME;
1070 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1071 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1072 self->simcall.args[0].dp = (void*) process;
1073 if (self != simix_global->maestro_process) {
1074 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1075 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1076 SIMIX_process_yield(self);
1078 SIMIX_simcall_handle(&self->simcall, 0);
1083 inline static int simcall_BODY_process_count() {
1084 smx_process_t self = SIMIX_process_self();
1086 /* Go to that function to follow the code flow through the simcall barrier */
1087 if (0) SIMIX_process_count();
1088 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1090 self->simcall.call = SIMCALL_PROCESS_COUNT;
1091 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1092 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1094 if (self != simix_global->maestro_process) {
1095 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1096 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1097 SIMIX_process_yield(self);
1099 SIMIX_simcall_handle(&self->simcall, 0);
1101 return self->simcall.result.i;
1104 inline static int simcall_BODY_process_get_PID(smx_process_t process) {
1105 smx_process_t self = SIMIX_process_self();
1107 /* Go to that function to follow the code flow through the simcall barrier */
1108 if (0) SIMIX_process_get_PID(process);
1109 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1111 self->simcall.call = SIMCALL_PROCESS_GET_PID;
1112 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1113 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1114 self->simcall.args[0].dp = (void*) process;
1115 if (self != simix_global->maestro_process) {
1116 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1117 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1118 SIMIX_process_yield(self);
1120 SIMIX_simcall_handle(&self->simcall, 0);
1122 return self->simcall.result.i;
1125 inline static int simcall_BODY_process_get_PPID(smx_process_t process) {
1126 smx_process_t self = SIMIX_process_self();
1128 /* Go to that function to follow the code flow through the simcall barrier */
1129 if (0) SIMIX_process_get_PPID(process);
1130 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1132 self->simcall.call = SIMCALL_PROCESS_GET_PPID;
1133 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1134 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1135 self->simcall.args[0].dp = (void*) process;
1136 if (self != simix_global->maestro_process) {
1137 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1138 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1139 SIMIX_process_yield(self);
1141 SIMIX_simcall_handle(&self->simcall, 0);
1143 return self->simcall.result.i;
1146 inline static void* simcall_BODY_process_get_data(smx_process_t process) {
1147 smx_process_t self = SIMIX_process_self();
1149 /* Go to that function to follow the code flow through the simcall barrier */
1150 if (0) SIMIX_process_get_data(process);
1151 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1153 self->simcall.call = SIMCALL_PROCESS_GET_DATA;
1154 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1155 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1156 self->simcall.args[0].dp = (void*) process;
1157 if (self != simix_global->maestro_process) {
1158 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1159 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1160 SIMIX_process_yield(self);
1162 SIMIX_simcall_handle(&self->simcall, 0);
1164 return self->simcall.result.dp;
1167 inline static void simcall_BODY_process_set_data(smx_process_t process, void* data) {
1168 smx_process_t self = SIMIX_process_self();
1170 /* Go to that function to follow the code flow through the simcall barrier */
1171 if (0) SIMIX_process_set_data(process, data);
1172 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1174 self->simcall.call = SIMCALL_PROCESS_SET_DATA;
1175 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1176 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1177 self->simcall.args[0].dp = (void*) process;
1178 self->simcall.args[1].dp = (void*) data;
1179 if (self != simix_global->maestro_process) {
1180 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1181 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1182 SIMIX_process_yield(self);
1184 SIMIX_simcall_handle(&self->simcall, 0);
1189 inline static smx_host_t simcall_BODY_process_get_host(smx_process_t process) {
1190 smx_process_t self = SIMIX_process_self();
1192 /* Go to that function to follow the code flow through the simcall barrier */
1193 if (0) SIMIX_process_get_host(process);
1194 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1196 self->simcall.call = SIMCALL_PROCESS_GET_HOST;
1197 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1198 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1199 self->simcall.args[0].dp = (void*) process;
1200 if (self != simix_global->maestro_process) {
1201 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1202 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1203 SIMIX_process_yield(self);
1205 SIMIX_simcall_handle(&self->simcall, 0);
1207 return self->simcall.result.dp;
1210 inline static const char* simcall_BODY_process_get_name(smx_process_t process) {
1211 smx_process_t self = SIMIX_process_self();
1213 /* Go to that function to follow the code flow through the simcall barrier */
1214 if (0) SIMIX_process_get_name(process);
1215 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1217 self->simcall.call = SIMCALL_PROCESS_GET_NAME;
1218 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1219 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1220 self->simcall.args[0].dp = (void*) process;
1221 if (self != simix_global->maestro_process) {
1222 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1223 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1224 SIMIX_process_yield(self);
1226 SIMIX_simcall_handle(&self->simcall, 0);
1228 return self->simcall.result.cc;
1231 inline static int simcall_BODY_process_is_suspended(smx_process_t process) {
1232 smx_process_t self = SIMIX_process_self();
1234 /* Go to that function to follow the code flow through the simcall barrier */
1235 if (0) SIMIX_process_is_suspended(process);
1236 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1238 self->simcall.call = SIMCALL_PROCESS_IS_SUSPENDED;
1239 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1240 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1241 self->simcall.args[0].dp = (void*) process;
1242 if (self != simix_global->maestro_process) {
1243 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1244 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1245 SIMIX_process_yield(self);
1247 SIMIX_simcall_handle(&self->simcall, 0);
1249 return self->simcall.result.i;
1252 inline static xbt_dict_t simcall_BODY_process_get_properties(smx_process_t process) {
1253 smx_process_t self = SIMIX_process_self();
1255 /* Go to that function to follow the code flow through the simcall barrier */
1256 if (0) SIMIX_process_get_properties(process);
1257 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1259 self->simcall.call = SIMCALL_PROCESS_GET_PROPERTIES;
1260 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1261 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1262 self->simcall.args[0].dp = (void*) process;
1263 if (self != simix_global->maestro_process) {
1264 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1265 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1266 SIMIX_process_yield(self);
1268 SIMIX_simcall_handle(&self->simcall, 0);
1270 return self->simcall.result.dp;
1273 inline static int simcall_BODY_process_join(smx_process_t process, double timeout) {
1274 smx_process_t self = SIMIX_process_self();
1276 /* Go to that function to follow the code flow through the simcall barrier */
1277 if (0) simcall_HANDLER_process_join(&self->simcall, process, timeout);
1278 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1280 self->simcall.call = SIMCALL_PROCESS_JOIN;
1281 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1282 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1283 self->simcall.args[0].dp = (void*) process;
1284 self->simcall.args[1].d = (double) timeout;
1285 if (self != simix_global->maestro_process) {
1286 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1287 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1288 SIMIX_process_yield(self);
1290 SIMIX_simcall_handle(&self->simcall, 0);
1292 return self->simcall.result.i;
1295 inline static int simcall_BODY_process_sleep(double duration) {
1296 smx_process_t self = SIMIX_process_self();
1298 /* Go to that function to follow the code flow through the simcall barrier */
1299 if (0) simcall_HANDLER_process_sleep(&self->simcall, duration);
1300 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1302 self->simcall.call = SIMCALL_PROCESS_SLEEP;
1303 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1304 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1305 self->simcall.args[0].d = (double) duration;
1306 if (self != simix_global->maestro_process) {
1307 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1308 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1309 SIMIX_process_yield(self);
1311 SIMIX_simcall_handle(&self->simcall, 0);
1313 return self->simcall.result.i;
1316 inline static void simcall_BODY_process_on_exit(smx_process_t process, int_f_pvoid_pvoid_t fun, void* data) {
1317 smx_process_t self = SIMIX_process_self();
1319 /* Go to that function to follow the code flow through the simcall barrier */
1320 if (0) SIMIX_process_on_exit(process, fun, data);
1321 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1323 self->simcall.call = SIMCALL_PROCESS_ON_EXIT;
1324 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1325 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1326 self->simcall.args[0].dp = (void*) process;
1327 self->simcall.args[1].fp = (FPtr) fun;
1328 self->simcall.args[2].dp = (void*) data;
1329 if (self != simix_global->maestro_process) {
1330 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1331 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1332 SIMIX_process_yield(self);
1334 SIMIX_simcall_handle(&self->simcall, 0);
1339 inline static void simcall_BODY_process_auto_restart_set(smx_process_t process, int auto_restart) {
1340 smx_process_t self = SIMIX_process_self();
1342 /* Go to that function to follow the code flow through the simcall barrier */
1343 if (0) SIMIX_process_auto_restart_set(process, auto_restart);
1344 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1346 self->simcall.call = SIMCALL_PROCESS_AUTO_RESTART_SET;
1347 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1348 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1349 self->simcall.args[0].dp = (void*) process;
1350 self->simcall.args[1].i = (int) auto_restart;
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);
1361 inline static smx_process_t simcall_BODY_process_restart(smx_process_t process) {
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_restart(&self->simcall, process);
1366 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1368 self->simcall.call = SIMCALL_PROCESS_RESTART;
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 if (self != simix_global->maestro_process) {
1373 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1374 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1375 SIMIX_process_yield(self);
1377 SIMIX_simcall_handle(&self->simcall, 0);
1379 return self->simcall.result.dp;
1382 inline static smx_rdv_t simcall_BODY_rdv_create(const char* name) {
1383 smx_process_t self = SIMIX_process_self();
1385 /* Go to that function to follow the code flow through the simcall barrier */
1386 if (0) SIMIX_rdv_create(name);
1387 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1389 self->simcall.call = SIMCALL_RDV_CREATE;
1390 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1391 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1392 self->simcall.args[0].cc = (const char*) name;
1393 if (self != simix_global->maestro_process) {
1394 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1395 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1396 SIMIX_process_yield(self);
1398 SIMIX_simcall_handle(&self->simcall, 0);
1400 return self->simcall.result.dp;
1403 inline static void simcall_BODY_rdv_destroy(smx_rdv_t rdv) {
1404 smx_process_t self = SIMIX_process_self();
1406 /* Go to that function to follow the code flow through the simcall barrier */
1407 if (0) SIMIX_rdv_destroy(rdv);
1408 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1410 self->simcall.call = SIMCALL_RDV_DESTROY;
1411 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1412 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1413 self->simcall.args[0].dp = (void*) rdv;
1414 if (self != simix_global->maestro_process) {
1415 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1416 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1417 SIMIX_process_yield(self);
1419 SIMIX_simcall_handle(&self->simcall, 0);
1424 inline static unsigned int simcall_BODY_rdv_comm_count_by_host(smx_rdv_t rdv, smx_host_t host) {
1425 smx_process_t self = SIMIX_process_self();
1427 /* Go to that function to follow the code flow through the simcall barrier */
1428 if (0) SIMIX_rdv_comm_count_by_host(rdv, host);
1429 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1431 self->simcall.call = SIMCALL_RDV_COMM_COUNT_BY_HOST;
1432 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1433 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1434 self->simcall.args[0].dp = (void*) rdv;
1435 self->simcall.args[1].dp = (void*) host;
1436 if (self != simix_global->maestro_process) {
1437 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1438 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1439 SIMIX_process_yield(self);
1441 SIMIX_simcall_handle(&self->simcall, 0);
1443 return self->simcall.result.ui;
1446 inline static smx_synchro_t simcall_BODY_rdv_get_head(smx_rdv_t rdv) {
1447 smx_process_t self = SIMIX_process_self();
1449 /* Go to that function to follow the code flow through the simcall barrier */
1450 if (0) SIMIX_rdv_get_head(rdv);
1451 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1453 self->simcall.call = SIMCALL_RDV_GET_HEAD;
1454 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1455 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1456 self->simcall.args[0].dp = (void*) rdv;
1457 if (self != simix_global->maestro_process) {
1458 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1459 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1460 SIMIX_process_yield(self);
1462 SIMIX_simcall_handle(&self->simcall, 0);
1464 return self->simcall.result.dp;
1467 inline static void simcall_BODY_rdv_set_receiver(smx_rdv_t rdv, smx_process_t receiver) {
1468 smx_process_t self = SIMIX_process_self();
1470 /* Go to that function to follow the code flow through the simcall barrier */
1471 if (0) SIMIX_rdv_set_receiver(rdv, receiver);
1472 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1474 self->simcall.call = SIMCALL_RDV_SET_RECEIVER;
1475 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1476 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1477 self->simcall.args[0].dp = (void*) rdv;
1478 self->simcall.args[1].dp = (void*) receiver;
1479 if (self != simix_global->maestro_process) {
1480 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1481 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1482 SIMIX_process_yield(self);
1484 SIMIX_simcall_handle(&self->simcall, 0);
1489 inline static smx_process_t simcall_BODY_rdv_get_receiver(smx_rdv_t rdv) {
1490 smx_process_t self = SIMIX_process_self();
1492 /* Go to that function to follow the code flow through the simcall barrier */
1493 if (0) SIMIX_rdv_get_receiver(rdv);
1494 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1496 self->simcall.call = SIMCALL_RDV_GET_RECEIVER;
1497 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1498 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1499 self->simcall.args[0].dp = (void*) rdv;
1500 if (self != simix_global->maestro_process) {
1501 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1502 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1503 SIMIX_process_yield(self);
1505 SIMIX_simcall_handle(&self->simcall, 0);
1507 return self->simcall.result.dp;
1510 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) {
1511 smx_process_t self = SIMIX_process_self();
1513 /* Go to that function to follow the code flow through the simcall barrier */
1514 if (0) simcall_HANDLER_comm_iprobe(&self->simcall, rdv, type, src, tag, match_fun, data);
1515 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1517 self->simcall.call = SIMCALL_COMM_IPROBE;
1518 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1519 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1520 self->simcall.args[0].dp = (void*) rdv;
1521 self->simcall.args[1].i = (int) type;
1522 self->simcall.args[2].i = (int) src;
1523 self->simcall.args[3].i = (int) tag;
1524 self->simcall.args[4].fp = (FPtr) match_fun;
1525 self->simcall.args[5].dp = (void*) data;
1526 if (self != simix_global->maestro_process) {
1527 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1528 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1529 SIMIX_process_yield(self);
1531 SIMIX_simcall_handle(&self->simcall, 0);
1533 return self->simcall.result.dp;
1536 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) {
1537 smx_process_t self = SIMIX_process_self();
1539 /* Go to that function to follow the code flow through the simcall barrier */
1540 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);
1541 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1543 self->simcall.call = SIMCALL_COMM_SEND;
1544 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1545 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1546 self->simcall.args[0].dp = (void*) src;
1547 self->simcall.args[1].dp = (void*) rdv;
1548 self->simcall.args[2].d = (double) task_size;
1549 self->simcall.args[3].d = (double) rate;
1550 self->simcall.args[4].dp = (void*) src_buff;
1551 self->simcall.args[5].sz = (size_t) src_buff_size;
1552 self->simcall.args[6].fp = (FPtr) match_fun;
1553 self->simcall.args[7].fp = (FPtr) copy_data_fun;
1554 self->simcall.args[8].dp = (void*) data;
1555 self->simcall.args[9].d = (double) timeout;
1556 if (self != simix_global->maestro_process) {
1557 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1558 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1559 SIMIX_process_yield(self);
1561 SIMIX_simcall_handle(&self->simcall, 0);
1566 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) {
1567 smx_process_t self = SIMIX_process_self();
1569 /* Go to that function to follow the code flow through the simcall barrier */
1570 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);
1571 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1573 self->simcall.call = SIMCALL_COMM_ISEND;
1574 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1575 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1576 self->simcall.args[0].dp = (void*) src;
1577 self->simcall.args[1].dp = (void*) rdv;
1578 self->simcall.args[2].d = (double) task_size;
1579 self->simcall.args[3].d = (double) rate;
1580 self->simcall.args[4].dp = (void*) src_buff;
1581 self->simcall.args[5].sz = (size_t) src_buff_size;
1582 self->simcall.args[6].fp = (FPtr) match_fun;
1583 self->simcall.args[7].fp = (FPtr) clean_fun;
1584 self->simcall.args[8].fp = (FPtr) copy_data_fun;
1585 self->simcall.args[9].dp = (void*) data;
1586 self->simcall.args[10].i = (int) detached;
1587 if (self != simix_global->maestro_process) {
1588 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1589 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1590 SIMIX_process_yield(self);
1592 SIMIX_simcall_handle(&self->simcall, 0);
1594 return self->simcall.result.dp;
1597 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) {
1598 smx_process_t self = SIMIX_process_self();
1600 /* Go to that function to follow the code flow through the simcall barrier */
1601 if (0) simcall_HANDLER_comm_recv(&self->simcall, rdv, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, timeout, rate);
1602 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1604 self->simcall.call = SIMCALL_COMM_RECV;
1605 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1606 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1607 self->simcall.args[0].dp = (void*) rdv;
1608 self->simcall.args[1].dp = (void*) dst_buff;
1609 self->simcall.args[2].dp = (void*) dst_buff_size;
1610 self->simcall.args[3].fp = (FPtr) match_fun;
1611 self->simcall.args[4].fp = (FPtr) copy_data_fun;
1612 self->simcall.args[5].dp = (void*) data;
1613 self->simcall.args[6].d = (double) timeout;
1614 self->simcall.args[7].d = (double) rate;
1615 if (self != simix_global->maestro_process) {
1616 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1617 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1618 SIMIX_process_yield(self);
1620 SIMIX_simcall_handle(&self->simcall, 0);
1625 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) {
1626 smx_process_t self = SIMIX_process_self();
1628 /* Go to that function to follow the code flow through the simcall barrier */
1629 if (0) simcall_HANDLER_comm_irecv(&self->simcall, rdv, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, rate);
1630 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1632 self->simcall.call = SIMCALL_COMM_IRECV;
1633 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1634 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1635 self->simcall.args[0].dp = (void*) rdv;
1636 self->simcall.args[1].dp = (void*) dst_buff;
1637 self->simcall.args[2].dp = (void*) dst_buff_size;
1638 self->simcall.args[3].fp = (FPtr) match_fun;
1639 self->simcall.args[4].fp = (FPtr) copy_data_fun;
1640 self->simcall.args[5].dp = (void*) data;
1641 self->simcall.args[6].d = (double) rate;
1642 if (self != simix_global->maestro_process) {
1643 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1644 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1645 SIMIX_process_yield(self);
1647 SIMIX_simcall_handle(&self->simcall, 0);
1649 return self->simcall.result.dp;
1652 inline static void simcall_BODY_comm_cancel(smx_synchro_t comm) {
1653 smx_process_t self = SIMIX_process_self();
1655 /* Go to that function to follow the code flow through the simcall barrier */
1656 if (0) SIMIX_comm_cancel(comm);
1657 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1659 self->simcall.call = SIMCALL_COMM_CANCEL;
1660 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1661 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1662 self->simcall.args[0].dp = (void*) comm;
1663 if (self != simix_global->maestro_process) {
1664 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1665 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1666 SIMIX_process_yield(self);
1668 SIMIX_simcall_handle(&self->simcall, 0);
1673 inline static int simcall_BODY_comm_waitany(xbt_dynar_t comms) {
1674 smx_process_t self = SIMIX_process_self();
1676 /* Go to that function to follow the code flow through the simcall barrier */
1677 if (0) simcall_HANDLER_comm_waitany(&self->simcall, comms);
1678 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1680 self->simcall.call = SIMCALL_COMM_WAITANY;
1681 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1682 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1683 self->simcall.args[0].dp = (void*) comms;
1684 if (self != simix_global->maestro_process) {
1685 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1686 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1687 SIMIX_process_yield(self);
1689 SIMIX_simcall_handle(&self->simcall, 0);
1691 return self->simcall.result.i;
1694 inline static void simcall_BODY_comm_wait(smx_synchro_t comm, double timeout) {
1695 smx_process_t self = SIMIX_process_self();
1697 /* Go to that function to follow the code flow through the simcall barrier */
1698 if (0) simcall_HANDLER_comm_wait(&self->simcall, comm, timeout);
1699 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1701 self->simcall.call = SIMCALL_COMM_WAIT;
1702 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1703 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1704 self->simcall.args[0].dp = (void*) comm;
1705 self->simcall.args[1].d = (double) timeout;
1706 if (self != simix_global->maestro_process) {
1707 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1708 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1709 SIMIX_process_yield(self);
1711 SIMIX_simcall_handle(&self->simcall, 0);
1716 inline static int simcall_BODY_comm_test(smx_synchro_t comm) {
1717 smx_process_t self = SIMIX_process_self();
1719 /* Go to that function to follow the code flow through the simcall barrier */
1720 if (0) simcall_HANDLER_comm_test(&self->simcall, comm);
1721 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1723 self->simcall.call = SIMCALL_COMM_TEST;
1724 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1725 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1726 self->simcall.args[0].dp = (void*) comm;
1727 if (self != simix_global->maestro_process) {
1728 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1729 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1730 SIMIX_process_yield(self);
1732 SIMIX_simcall_handle(&self->simcall, 0);
1734 return self->simcall.result.i;
1737 inline static int simcall_BODY_comm_testany(xbt_dynar_t comms) {
1738 smx_process_t self = SIMIX_process_self();
1740 /* Go to that function to follow the code flow through the simcall barrier */
1741 if (0) simcall_HANDLER_comm_testany(&self->simcall, comms);
1742 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1744 self->simcall.call = SIMCALL_COMM_TESTANY;
1745 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1746 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1747 self->simcall.args[0].dp = (void*) comms;
1748 if (self != simix_global->maestro_process) {
1749 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1750 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1751 SIMIX_process_yield(self);
1753 SIMIX_simcall_handle(&self->simcall, 0);
1755 return self->simcall.result.i;
1758 inline static double simcall_BODY_comm_get_remains(smx_synchro_t comm) {
1759 smx_process_t self = SIMIX_process_self();
1761 /* Go to that function to follow the code flow through the simcall barrier */
1762 if (0) SIMIX_comm_get_remains(comm);
1763 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1765 self->simcall.call = SIMCALL_COMM_GET_REMAINS;
1766 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1767 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1768 self->simcall.args[0].dp = (void*) comm;
1769 if (self != simix_global->maestro_process) {
1770 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1771 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1772 SIMIX_process_yield(self);
1774 SIMIX_simcall_handle(&self->simcall, 0);
1776 return self->simcall.result.d;
1779 inline static e_smx_state_t simcall_BODY_comm_get_state(smx_synchro_t comm) {
1780 smx_process_t self = SIMIX_process_self();
1782 /* Go to that function to follow the code flow through the simcall barrier */
1783 if (0) SIMIX_comm_get_state(comm);
1784 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1786 self->simcall.call = SIMCALL_COMM_GET_STATE;
1787 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1788 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1789 self->simcall.args[0].dp = (void*) comm;
1790 if (self != simix_global->maestro_process) {
1791 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1792 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1793 SIMIX_process_yield(self);
1795 SIMIX_simcall_handle(&self->simcall, 0);
1797 return self->simcall.result.i;
1800 inline static void* simcall_BODY_comm_get_src_data(smx_synchro_t comm) {
1801 smx_process_t self = SIMIX_process_self();
1803 /* Go to that function to follow the code flow through the simcall barrier */
1804 if (0) SIMIX_comm_get_src_data(comm);
1805 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1807 self->simcall.call = SIMCALL_COMM_GET_SRC_DATA;
1808 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1809 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1810 self->simcall.args[0].dp = (void*) comm;
1811 if (self != simix_global->maestro_process) {
1812 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1813 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1814 SIMIX_process_yield(self);
1816 SIMIX_simcall_handle(&self->simcall, 0);
1818 return self->simcall.result.dp;
1821 inline static void* simcall_BODY_comm_get_dst_data(smx_synchro_t comm) {
1822 smx_process_t self = SIMIX_process_self();
1824 /* Go to that function to follow the code flow through the simcall barrier */
1825 if (0) SIMIX_comm_get_dst_data(comm);
1826 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1828 self->simcall.call = SIMCALL_COMM_GET_DST_DATA;
1829 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1830 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1831 self->simcall.args[0].dp = (void*) comm;
1832 if (self != simix_global->maestro_process) {
1833 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1834 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1835 SIMIX_process_yield(self);
1837 SIMIX_simcall_handle(&self->simcall, 0);
1839 return self->simcall.result.dp;
1842 inline static smx_process_t simcall_BODY_comm_get_src_proc(smx_synchro_t comm) {
1843 smx_process_t self = SIMIX_process_self();
1845 /* Go to that function to follow the code flow through the simcall barrier */
1846 if (0) SIMIX_comm_get_src_proc(comm);
1847 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1849 self->simcall.call = SIMCALL_COMM_GET_SRC_PROC;
1850 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1851 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1852 self->simcall.args[0].dp = (void*) comm;
1853 if (self != simix_global->maestro_process) {
1854 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1855 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1856 SIMIX_process_yield(self);
1858 SIMIX_simcall_handle(&self->simcall, 0);
1860 return self->simcall.result.dp;
1863 inline static smx_process_t simcall_BODY_comm_get_dst_proc(smx_synchro_t comm) {
1864 smx_process_t self = SIMIX_process_self();
1866 /* Go to that function to follow the code flow through the simcall barrier */
1867 if (0) SIMIX_comm_get_dst_proc(comm);
1868 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1870 self->simcall.call = SIMCALL_COMM_GET_DST_PROC;
1871 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1872 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1873 self->simcall.args[0].dp = (void*) comm;
1874 if (self != simix_global->maestro_process) {
1875 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1876 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1877 SIMIX_process_yield(self);
1879 SIMIX_simcall_handle(&self->simcall, 0);
1881 return self->simcall.result.dp;
1884 inline static smx_mutex_t simcall_BODY_mutex_init() {
1885 smx_process_t self = SIMIX_process_self();
1887 /* Go to that function to follow the code flow through the simcall barrier */
1888 if (0) simcall_HANDLER_mutex_init(&self->simcall);
1889 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1891 self->simcall.call = SIMCALL_MUTEX_INIT;
1892 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1893 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1895 if (self != simix_global->maestro_process) {
1896 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1897 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1898 SIMIX_process_yield(self);
1900 SIMIX_simcall_handle(&self->simcall, 0);
1902 return self->simcall.result.dp;
1905 inline static void simcall_BODY_mutex_destroy(smx_mutex_t mutex) {
1906 smx_process_t self = SIMIX_process_self();
1908 /* Go to that function to follow the code flow through the simcall barrier */
1909 if (0) SIMIX_mutex_destroy(mutex);
1910 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1912 self->simcall.call = SIMCALL_MUTEX_DESTROY;
1913 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1914 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1915 self->simcall.args[0].dp = (void*) mutex;
1916 if (self != simix_global->maestro_process) {
1917 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1918 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1919 SIMIX_process_yield(self);
1921 SIMIX_simcall_handle(&self->simcall, 0);
1926 inline static void simcall_BODY_mutex_lock(smx_mutex_t mutex) {
1927 smx_process_t self = SIMIX_process_self();
1929 /* Go to that function to follow the code flow through the simcall barrier */
1930 if (0) simcall_HANDLER_mutex_lock(&self->simcall, mutex);
1931 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1933 self->simcall.call = SIMCALL_MUTEX_LOCK;
1934 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1935 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1936 self->simcall.args[0].dp = (void*) mutex;
1937 if (self != simix_global->maestro_process) {
1938 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1939 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1940 SIMIX_process_yield(self);
1942 SIMIX_simcall_handle(&self->simcall, 0);
1947 inline static int simcall_BODY_mutex_trylock(smx_mutex_t mutex) {
1948 smx_process_t self = SIMIX_process_self();
1950 /* Go to that function to follow the code flow through the simcall barrier */
1951 if (0) simcall_HANDLER_mutex_trylock(&self->simcall, mutex);
1952 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1954 self->simcall.call = SIMCALL_MUTEX_TRYLOCK;
1955 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1956 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1957 self->simcall.args[0].dp = (void*) mutex;
1958 if (self != simix_global->maestro_process) {
1959 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1960 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1961 SIMIX_process_yield(self);
1963 SIMIX_simcall_handle(&self->simcall, 0);
1965 return self->simcall.result.i;
1968 inline static void simcall_BODY_mutex_unlock(smx_mutex_t mutex) {
1969 smx_process_t self = SIMIX_process_self();
1971 /* Go to that function to follow the code flow through the simcall barrier */
1972 if (0) simcall_HANDLER_mutex_unlock(&self->simcall, mutex);
1973 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1975 self->simcall.call = SIMCALL_MUTEX_UNLOCK;
1976 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1977 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1978 self->simcall.args[0].dp = (void*) mutex;
1979 if (self != simix_global->maestro_process) {
1980 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1981 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1982 SIMIX_process_yield(self);
1984 SIMIX_simcall_handle(&self->simcall, 0);
1989 inline static smx_cond_t simcall_BODY_cond_init() {
1990 smx_process_t self = SIMIX_process_self();
1992 /* Go to that function to follow the code flow through the simcall barrier */
1993 if (0) SIMIX_cond_init();
1994 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1996 self->simcall.call = SIMCALL_COND_INIT;
1997 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1998 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2000 if (self != simix_global->maestro_process) {
2001 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2002 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2003 SIMIX_process_yield(self);
2005 SIMIX_simcall_handle(&self->simcall, 0);
2007 return self->simcall.result.dp;
2010 inline static void simcall_BODY_cond_destroy(smx_cond_t cond) {
2011 smx_process_t self = SIMIX_process_self();
2013 /* Go to that function to follow the code flow through the simcall barrier */
2014 if (0) SIMIX_cond_destroy(cond);
2015 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2017 self->simcall.call = SIMCALL_COND_DESTROY;
2018 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2019 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2020 self->simcall.args[0].dp = (void*) cond;
2021 if (self != simix_global->maestro_process) {
2022 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2023 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2024 SIMIX_process_yield(self);
2026 SIMIX_simcall_handle(&self->simcall, 0);
2031 inline static void simcall_BODY_cond_signal(smx_cond_t cond) {
2032 smx_process_t self = SIMIX_process_self();
2034 /* Go to that function to follow the code flow through the simcall barrier */
2035 if (0) SIMIX_cond_signal(cond);
2036 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2038 self->simcall.call = SIMCALL_COND_SIGNAL;
2039 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2040 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2041 self->simcall.args[0].dp = (void*) cond;
2042 if (self != simix_global->maestro_process) {
2043 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2044 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2045 SIMIX_process_yield(self);
2047 SIMIX_simcall_handle(&self->simcall, 0);
2052 inline static void simcall_BODY_cond_wait(smx_cond_t cond, smx_mutex_t mutex) {
2053 smx_process_t self = SIMIX_process_self();
2055 /* Go to that function to follow the code flow through the simcall barrier */
2056 if (0) simcall_HANDLER_cond_wait(&self->simcall, cond, mutex);
2057 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2059 self->simcall.call = SIMCALL_COND_WAIT;
2060 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2061 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2062 self->simcall.args[0].dp = (void*) cond;
2063 self->simcall.args[1].dp = (void*) mutex;
2064 if (self != simix_global->maestro_process) {
2065 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2066 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2067 SIMIX_process_yield(self);
2069 SIMIX_simcall_handle(&self->simcall, 0);
2074 inline static void simcall_BODY_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double timeout) {
2075 smx_process_t self = SIMIX_process_self();
2077 /* Go to that function to follow the code flow through the simcall barrier */
2078 if (0) simcall_HANDLER_cond_wait_timeout(&self->simcall, cond, mutex, timeout);
2079 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2081 self->simcall.call = SIMCALL_COND_WAIT_TIMEOUT;
2082 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2083 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2084 self->simcall.args[0].dp = (void*) cond;
2085 self->simcall.args[1].dp = (void*) mutex;
2086 self->simcall.args[2].d = (double) timeout;
2087 if (self != simix_global->maestro_process) {
2088 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2089 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2090 SIMIX_process_yield(self);
2092 SIMIX_simcall_handle(&self->simcall, 0);
2097 inline static void simcall_BODY_cond_broadcast(smx_cond_t cond) {
2098 smx_process_t self = SIMIX_process_self();
2100 /* Go to that function to follow the code flow through the simcall barrier */
2101 if (0) SIMIX_cond_broadcast(cond);
2102 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2104 self->simcall.call = SIMCALL_COND_BROADCAST;
2105 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2106 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2107 self->simcall.args[0].dp = (void*) cond;
2108 if (self != simix_global->maestro_process) {
2109 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2110 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2111 SIMIX_process_yield(self);
2113 SIMIX_simcall_handle(&self->simcall, 0);
2118 inline static smx_sem_t simcall_BODY_sem_init(unsigned int capacity) {
2119 smx_process_t self = SIMIX_process_self();
2121 /* Go to that function to follow the code flow through the simcall barrier */
2122 if (0) SIMIX_sem_init(capacity);
2123 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2125 self->simcall.call = SIMCALL_SEM_INIT;
2126 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2127 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2128 self->simcall.args[0].ui = (unsigned int) capacity;
2129 if (self != simix_global->maestro_process) {
2130 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2131 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2132 SIMIX_process_yield(self);
2134 SIMIX_simcall_handle(&self->simcall, 0);
2136 return self->simcall.result.dp;
2139 inline static void simcall_BODY_sem_destroy(smx_sem_t sem) {
2140 smx_process_t self = SIMIX_process_self();
2142 /* Go to that function to follow the code flow through the simcall barrier */
2143 if (0) SIMIX_sem_destroy(sem);
2144 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2146 self->simcall.call = SIMCALL_SEM_DESTROY;
2147 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2148 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2149 self->simcall.args[0].dp = (void*) sem;
2150 if (self != simix_global->maestro_process) {
2151 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2152 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2153 SIMIX_process_yield(self);
2155 SIMIX_simcall_handle(&self->simcall, 0);
2160 inline static void simcall_BODY_sem_release(smx_sem_t sem) {
2161 smx_process_t self = SIMIX_process_self();
2163 /* Go to that function to follow the code flow through the simcall barrier */
2164 if (0) simcall_HANDLER_sem_release(&self->simcall, sem);
2165 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2167 self->simcall.call = SIMCALL_SEM_RELEASE;
2168 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2169 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2170 self->simcall.args[0].dp = (void*) sem;
2171 if (self != simix_global->maestro_process) {
2172 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2173 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2174 SIMIX_process_yield(self);
2176 SIMIX_simcall_handle(&self->simcall, 0);
2181 inline static int simcall_BODY_sem_would_block(smx_sem_t sem) {
2182 smx_process_t self = SIMIX_process_self();
2184 /* Go to that function to follow the code flow through the simcall barrier */
2185 if (0) simcall_HANDLER_sem_would_block(&self->simcall, sem);
2186 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2188 self->simcall.call = SIMCALL_SEM_WOULD_BLOCK;
2189 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2190 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2191 self->simcall.args[0].dp = (void*) sem;
2192 if (self != simix_global->maestro_process) {
2193 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2194 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2195 SIMIX_process_yield(self);
2197 SIMIX_simcall_handle(&self->simcall, 0);
2199 return self->simcall.result.i;
2202 inline static void simcall_BODY_sem_acquire(smx_sem_t sem) {
2203 smx_process_t self = SIMIX_process_self();
2205 /* Go to that function to follow the code flow through the simcall barrier */
2206 if (0) simcall_HANDLER_sem_acquire(&self->simcall, sem);
2207 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2209 self->simcall.call = SIMCALL_SEM_ACQUIRE;
2210 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2211 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2212 self->simcall.args[0].dp = (void*) sem;
2213 if (self != simix_global->maestro_process) {
2214 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2215 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2216 SIMIX_process_yield(self);
2218 SIMIX_simcall_handle(&self->simcall, 0);
2223 inline static void simcall_BODY_sem_acquire_timeout(smx_sem_t sem, double timeout) {
2224 smx_process_t self = SIMIX_process_self();
2226 /* Go to that function to follow the code flow through the simcall barrier */
2227 if (0) simcall_HANDLER_sem_acquire_timeout(&self->simcall, sem, timeout);
2228 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2230 self->simcall.call = SIMCALL_SEM_ACQUIRE_TIMEOUT;
2231 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2232 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2233 self->simcall.args[0].dp = (void*) sem;
2234 self->simcall.args[1].d = (double) timeout;
2235 if (self != simix_global->maestro_process) {
2236 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2237 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2238 SIMIX_process_yield(self);
2240 SIMIX_simcall_handle(&self->simcall, 0);
2245 inline static int simcall_BODY_sem_get_capacity(smx_sem_t sem) {
2246 smx_process_t self = SIMIX_process_self();
2248 /* Go to that function to follow the code flow through the simcall barrier */
2249 if (0) simcall_HANDLER_sem_get_capacity(&self->simcall, sem);
2250 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2252 self->simcall.call = SIMCALL_SEM_GET_CAPACITY;
2253 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2254 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2255 self->simcall.args[0].dp = (void*) sem;
2256 if (self != simix_global->maestro_process) {
2257 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2258 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2259 SIMIX_process_yield(self);
2261 SIMIX_simcall_handle(&self->simcall, 0);
2263 return self->simcall.result.i;
2266 inline static sg_size_t simcall_BODY_file_read(smx_file_t fd, sg_size_t size, smx_host_t host) {
2267 smx_process_t self = SIMIX_process_self();
2269 /* Go to that function to follow the code flow through the simcall barrier */
2270 if (0) simcall_HANDLER_file_read(&self->simcall, fd, size, host);
2271 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2273 self->simcall.call = SIMCALL_FILE_READ;
2274 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2275 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2276 self->simcall.args[0].dp = (void*) fd;
2277 self->simcall.args[1].sgsz = (sg_size_t) size;
2278 self->simcall.args[2].dp = (void*) host;
2279 if (self != simix_global->maestro_process) {
2280 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2281 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2282 SIMIX_process_yield(self);
2284 SIMIX_simcall_handle(&self->simcall, 0);
2286 return self->simcall.result.sgsz;
2289 inline static sg_size_t simcall_BODY_file_write(smx_file_t fd, sg_size_t size, smx_host_t host) {
2290 smx_process_t self = SIMIX_process_self();
2292 /* Go to that function to follow the code flow through the simcall barrier */
2293 if (0) simcall_HANDLER_file_write(&self->simcall, fd, size, host);
2294 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2296 self->simcall.call = SIMCALL_FILE_WRITE;
2297 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2298 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2299 self->simcall.args[0].dp = (void*) fd;
2300 self->simcall.args[1].sgsz = (sg_size_t) size;
2301 self->simcall.args[2].dp = (void*) host;
2302 if (self != simix_global->maestro_process) {
2303 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2304 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2305 SIMIX_process_yield(self);
2307 SIMIX_simcall_handle(&self->simcall, 0);
2309 return self->simcall.result.sgsz;
2312 inline static smx_file_t simcall_BODY_file_open(const char* fullpath, smx_host_t host) {
2313 smx_process_t self = SIMIX_process_self();
2315 /* Go to that function to follow the code flow through the simcall barrier */
2316 if (0) simcall_HANDLER_file_open(&self->simcall, fullpath, host);
2317 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2319 self->simcall.call = SIMCALL_FILE_OPEN;
2320 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2321 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2322 self->simcall.args[0].cc = (const char*) fullpath;
2323 self->simcall.args[1].dp = (void*) host;
2324 if (self != simix_global->maestro_process) {
2325 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2326 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2327 SIMIX_process_yield(self);
2329 SIMIX_simcall_handle(&self->simcall, 0);
2331 return self->simcall.result.dp;
2334 inline static int simcall_BODY_file_close(smx_file_t fd, smx_host_t host) {
2335 smx_process_t self = SIMIX_process_self();
2337 /* Go to that function to follow the code flow through the simcall barrier */
2338 if (0) simcall_HANDLER_file_close(&self->simcall, fd, host);
2339 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2341 self->simcall.call = SIMCALL_FILE_CLOSE;
2342 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2343 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2344 self->simcall.args[0].dp = (void*) fd;
2345 self->simcall.args[1].dp = (void*) host;
2346 if (self != simix_global->maestro_process) {
2347 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2348 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2349 SIMIX_process_yield(self);
2351 SIMIX_simcall_handle(&self->simcall, 0);
2353 return self->simcall.result.i;
2356 inline static int simcall_BODY_file_unlink(smx_file_t fd, smx_host_t host) {
2357 smx_process_t self = SIMIX_process_self();
2359 /* Go to that function to follow the code flow through the simcall barrier */
2360 if (0) SIMIX_file_unlink(fd, host);
2361 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2363 self->simcall.call = SIMCALL_FILE_UNLINK;
2364 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2365 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2366 self->simcall.args[0].dp = (void*) fd;
2367 self->simcall.args[1].dp = (void*) host;
2368 if (self != simix_global->maestro_process) {
2369 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2370 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2371 SIMIX_process_yield(self);
2373 SIMIX_simcall_handle(&self->simcall, 0);
2375 return self->simcall.result.i;
2378 inline static sg_size_t simcall_BODY_file_get_size(smx_file_t fd) {
2379 smx_process_t self = SIMIX_process_self();
2381 /* Go to that function to follow the code flow through the simcall barrier */
2382 if (0) simcall_HANDLER_file_get_size(&self->simcall, fd);
2383 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2385 self->simcall.call = SIMCALL_FILE_GET_SIZE;
2386 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2387 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2388 self->simcall.args[0].dp = (void*) fd;
2389 if (self != simix_global->maestro_process) {
2390 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2391 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2392 SIMIX_process_yield(self);
2394 SIMIX_simcall_handle(&self->simcall, 0);
2396 return self->simcall.result.sgsz;
2399 inline static sg_size_t simcall_BODY_file_tell(smx_file_t fd) {
2400 smx_process_t self = SIMIX_process_self();
2402 /* Go to that function to follow the code flow through the simcall barrier */
2403 if (0) simcall_HANDLER_file_tell(&self->simcall, fd);
2404 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2406 self->simcall.call = SIMCALL_FILE_TELL;
2407 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2408 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2409 self->simcall.args[0].dp = (void*) fd;
2410 if (self != simix_global->maestro_process) {
2411 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2412 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2413 SIMIX_process_yield(self);
2415 SIMIX_simcall_handle(&self->simcall, 0);
2417 return self->simcall.result.sgsz;
2420 inline static int simcall_BODY_file_seek(smx_file_t fd, sg_offset_t offset, int origin) {
2421 smx_process_t self = SIMIX_process_self();
2423 /* Go to that function to follow the code flow through the simcall barrier */
2424 if (0) simcall_HANDLER_file_seek(&self->simcall, fd, offset, origin);
2425 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2427 self->simcall.call = SIMCALL_FILE_SEEK;
2428 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2429 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2430 self->simcall.args[0].dp = (void*) fd;
2431 self->simcall.args[1].sgoff = (sg_offset_t) offset;
2432 self->simcall.args[2].i = (int) origin;
2433 if (self != simix_global->maestro_process) {
2434 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2435 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2436 SIMIX_process_yield(self);
2438 SIMIX_simcall_handle(&self->simcall, 0);
2440 return self->simcall.result.i;
2443 inline static xbt_dynar_t simcall_BODY_file_get_info(smx_file_t fd) {
2444 smx_process_t self = SIMIX_process_self();
2446 /* Go to that function to follow the code flow through the simcall barrier */
2447 if (0) simcall_HANDLER_file_get_info(&self->simcall, fd);
2448 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2450 self->simcall.call = SIMCALL_FILE_GET_INFO;
2451 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2452 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2453 self->simcall.args[0].dp = (void*) fd;
2454 if (self != simix_global->maestro_process) {
2455 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2456 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2457 SIMIX_process_yield(self);
2459 SIMIX_simcall_handle(&self->simcall, 0);
2461 return self->simcall.result.dp;
2464 inline static int simcall_BODY_file_move(smx_file_t fd, const char* fullpath) {
2465 smx_process_t self = SIMIX_process_self();
2467 /* Go to that function to follow the code flow through the simcall barrier */
2468 if (0) simcall_HANDLER_file_move(&self->simcall, fd, fullpath);
2469 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2471 self->simcall.call = SIMCALL_FILE_MOVE;
2472 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2473 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2474 self->simcall.args[0].dp = (void*) fd;
2475 self->simcall.args[1].cc = (const char*) fullpath;
2476 if (self != simix_global->maestro_process) {
2477 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2478 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2479 SIMIX_process_yield(self);
2481 SIMIX_simcall_handle(&self->simcall, 0);
2483 return self->simcall.result.i;
2486 inline static sg_size_t simcall_BODY_storage_get_free_size(smx_storage_t storage) {
2487 smx_process_t self = SIMIX_process_self();
2489 /* Go to that function to follow the code flow through the simcall barrier */
2490 if (0) simcall_HANDLER_storage_get_free_size(&self->simcall, storage);
2491 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2493 self->simcall.call = SIMCALL_STORAGE_GET_FREE_SIZE;
2494 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2495 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2496 self->simcall.args[0].dp = (void*) storage;
2497 if (self != simix_global->maestro_process) {
2498 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2499 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2500 SIMIX_process_yield(self);
2502 SIMIX_simcall_handle(&self->simcall, 0);
2504 return self->simcall.result.sgsz;
2507 inline static sg_size_t simcall_BODY_storage_get_used_size(smx_storage_t name) {
2508 smx_process_t self = SIMIX_process_self();
2510 /* Go to that function to follow the code flow through the simcall barrier */
2511 if (0) simcall_HANDLER_storage_get_used_size(&self->simcall, name);
2512 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2514 self->simcall.call = SIMCALL_STORAGE_GET_USED_SIZE;
2515 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2516 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2517 self->simcall.args[0].dp = (void*) name;
2518 if (self != simix_global->maestro_process) {
2519 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2520 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2521 SIMIX_process_yield(self);
2523 SIMIX_simcall_handle(&self->simcall, 0);
2525 return self->simcall.result.sgsz;
2528 inline static xbt_dict_t simcall_BODY_storage_get_properties(smx_storage_t storage) {
2529 smx_process_t self = SIMIX_process_self();
2531 /* Go to that function to follow the code flow through the simcall barrier */
2532 if (0) SIMIX_storage_get_properties(storage);
2533 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2535 self->simcall.call = SIMCALL_STORAGE_GET_PROPERTIES;
2536 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2537 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2538 self->simcall.args[0].dp = (void*) storage;
2539 if (self != simix_global->maestro_process) {
2540 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2541 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2542 SIMIX_process_yield(self);
2544 SIMIX_simcall_handle(&self->simcall, 0);
2546 return self->simcall.result.dp;
2549 inline static xbt_dict_t simcall_BODY_storage_get_content(smx_storage_t storage) {
2550 smx_process_t self = SIMIX_process_self();
2552 /* Go to that function to follow the code flow through the simcall barrier */
2553 if (0) SIMIX_storage_get_content(storage);
2554 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2556 self->simcall.call = SIMCALL_STORAGE_GET_CONTENT;
2557 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2558 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2559 self->simcall.args[0].dp = (void*) storage;
2560 if (self != simix_global->maestro_process) {
2561 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2562 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2563 SIMIX_process_yield(self);
2565 SIMIX_simcall_handle(&self->simcall, 0);
2567 return self->simcall.result.dp;
2570 inline static xbt_dict_t simcall_BODY_asr_get_properties(const char* name) {
2571 smx_process_t self = SIMIX_process_self();
2573 /* Go to that function to follow the code flow through the simcall barrier */
2574 if (0) simcall_HANDLER_asr_get_properties(&self->simcall, name);
2575 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2577 self->simcall.call = SIMCALL_ASR_GET_PROPERTIES;
2578 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2579 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2580 self->simcall.args[0].cc = (const char*) name;
2581 if (self != simix_global->maestro_process) {
2582 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2583 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2584 SIMIX_process_yield(self);
2586 SIMIX_simcall_handle(&self->simcall, 0);
2588 return self->simcall.result.dp;
2591 inline static int simcall_BODY_mc_random(int min, int max) {
2592 smx_process_t self = SIMIX_process_self();
2594 /* Go to that function to follow the code flow through the simcall barrier */
2595 if (0) simcall_HANDLER_mc_random(&self->simcall, min, max);
2596 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2598 self->simcall.call = SIMCALL_MC_RANDOM;
2599 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2600 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2601 self->simcall.args[0].i = (int) min;
2602 self->simcall.args[1].i = (int) max;
2603 if (self != simix_global->maestro_process) {
2604 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2605 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2606 SIMIX_process_yield(self);
2608 SIMIX_simcall_handle(&self->simcall, 0);
2610 return self->simcall.result.i;
2613 inline static void simcall_BODY_set_category(smx_synchro_t synchro, const char* category) {
2614 smx_process_t self = SIMIX_process_self();
2616 /* Go to that function to follow the code flow through the simcall barrier */
2617 if (0) SIMIX_set_category(synchro, category);
2618 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2620 self->simcall.call = SIMCALL_SET_CATEGORY;
2621 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2622 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2623 self->simcall.args[0].dp = (void*) synchro;
2624 self->simcall.args[1].cc = (const char*) category;
2625 if (self != simix_global->maestro_process) {
2626 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2627 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2628 SIMIX_process_yield(self);
2630 SIMIX_simcall_handle(&self->simcall, 0);
2634 #ifdef HAVE_LATENCY_BOUND_TRACKING
2636 inline static int simcall_BODY_comm_is_latency_bounded(smx_synchro_t comm) {
2637 smx_process_t self = SIMIX_process_self();
2639 /* Go to that function to follow the code flow through the simcall barrier */
2640 if (0) SIMIX_comm_is_latency_bounded(comm);
2641 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2643 self->simcall.call = SIMCALL_COMM_IS_LATENCY_BOUNDED;
2644 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2645 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2646 self->simcall.args[0].dp = (void*) comm;
2647 if (self != simix_global->maestro_process) {
2648 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2649 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2650 SIMIX_process_yield(self);
2652 SIMIX_simcall_handle(&self->simcall, 0);
2654 return self->simcall.result.i;
2660 inline static mc_snapshot_t simcall_BODY_mc_snapshot() {
2661 smx_process_t self = SIMIX_process_self();
2663 /* Go to that function to follow the code flow through the simcall barrier */
2664 if (0) simcall_HANDLER_mc_snapshot(&self->simcall);
2665 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2667 self->simcall.call = SIMCALL_MC_SNAPSHOT;
2668 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2669 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2671 if (self != simix_global->maestro_process) {
2672 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2673 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2674 SIMIX_process_yield(self);
2676 SIMIX_simcall_handle(&self->simcall, 0);
2678 return self->simcall.result.dp;
2681 inline static int simcall_BODY_mc_compare_snapshots(mc_snapshot_t s1, mc_snapshot_t s2) {
2682 smx_process_t self = SIMIX_process_self();
2684 /* Go to that function to follow the code flow through the simcall barrier */
2685 if (0) simcall_HANDLER_mc_compare_snapshots(&self->simcall, s1, s2);
2686 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2688 self->simcall.call = SIMCALL_MC_COMPARE_SNAPSHOTS;
2689 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2690 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2691 self->simcall.args[0].dp = (void*) s1;
2692 self->simcall.args[1].dp = (void*) s2;
2693 if (self != simix_global->maestro_process) {
2694 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2695 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2696 SIMIX_process_yield(self);
2698 SIMIX_simcall_handle(&self->simcall, 0);
2700 return self->simcall.result.i;