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 "src/mc/mc_forward.h"
20 inline static void simcall_BODY_host_on(sg_host_t host) {
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_on(host);
25 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
27 self->simcall.call = SIMCALL_HOST_ON;
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].dp = (void*) host;
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);
41 inline static void simcall_BODY_host_off(sg_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) simcall_HANDLER_host_off(&self->simcall, host);
46 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
48 self->simcall.call = SIMCALL_HOST_OFF;
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);
62 inline static xbt_dict_t simcall_BODY_host_get_properties(sg_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_get_properties(host);
67 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
69 self->simcall.call = SIMCALL_HOST_GET_PROPERTIES;
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);
80 return self->simcall.result.dp;
83 inline static int simcall_BODY_host_get_core(sg_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) SIMIX_host_get_core(host);
88 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
90 self->simcall.call = SIMCALL_HOST_GET_CORE;
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);
101 return self->simcall.result.i;
104 inline static xbt_swag_t simcall_BODY_host_get_process_list(sg_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_process_list(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_PROCESS_LIST;
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_state(sg_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_state(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_STATE;
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 double simcall_BODY_host_get_current_power_peak(sg_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_current_power_peak(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_CURRENT_POWER_PEAK;
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.d;
167 inline static double simcall_BODY_host_get_power_peak_at(sg_host_t host, int pstate_index) {
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_power_peak_at(host, pstate_index);
172 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
174 self->simcall.call = SIMCALL_HOST_GET_POWER_PEAK_AT;
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 self->simcall.args[1].i = (int) pstate_index;
179 if (self != simix_global->maestro_process) {
180 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
181 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
182 SIMIX_process_yield(self);
184 SIMIX_simcall_handle(&self->simcall, 0);
186 return self->simcall.result.d;
189 inline static int simcall_BODY_host_get_nb_pstates(sg_host_t host) {
190 smx_process_t self = SIMIX_process_self();
192 /* Go to that function to follow the code flow through the simcall barrier */
193 if (0) SIMIX_host_get_nb_pstates(host);
194 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
196 self->simcall.call = SIMCALL_HOST_GET_NB_PSTATES;
197 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
198 memset(self->simcall.args, 0, sizeof(self->simcall.args));
199 self->simcall.args[0].dp = (void*) host;
200 if (self != simix_global->maestro_process) {
201 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
202 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
203 SIMIX_process_yield(self);
205 SIMIX_simcall_handle(&self->simcall, 0);
207 return self->simcall.result.i;
210 inline static double simcall_BODY_host_get_wattmin_at(sg_host_t host, int pstate_index) {
211 smx_process_t self = SIMIX_process_self();
213 /* Go to that function to follow the code flow through the simcall barrier */
214 if (0) SIMIX_host_get_wattmin_at(host, pstate_index);
215 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
217 self->simcall.call = SIMCALL_HOST_GET_WATTMIN_AT;
218 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
219 memset(self->simcall.args, 0, sizeof(self->simcall.args));
220 self->simcall.args[0].dp = (void*) host;
221 self->simcall.args[1].i = (int) pstate_index;
222 if (self != simix_global->maestro_process) {
223 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
224 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
225 SIMIX_process_yield(self);
227 SIMIX_simcall_handle(&self->simcall, 0);
229 return self->simcall.result.d;
232 inline static double simcall_BODY_host_get_wattmax_at(sg_host_t host, int pstate_index) {
233 smx_process_t self = SIMIX_process_self();
235 /* Go to that function to follow the code flow through the simcall barrier */
236 if (0) SIMIX_host_get_wattmax_at(host, pstate_index);
237 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
239 self->simcall.call = SIMCALL_HOST_GET_WATTMAX_AT;
240 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
241 memset(self->simcall.args, 0, sizeof(self->simcall.args));
242 self->simcall.args[0].dp = (void*) host;
243 self->simcall.args[1].i = (int) pstate_index;
244 if (self != simix_global->maestro_process) {
245 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
246 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
247 SIMIX_process_yield(self);
249 SIMIX_simcall_handle(&self->simcall, 0);
251 return self->simcall.result.d;
254 inline static void simcall_BODY_host_set_pstate(sg_host_t host, int pstate_index) {
255 smx_process_t self = SIMIX_process_self();
257 /* Go to that function to follow the code flow through the simcall barrier */
258 if (0) SIMIX_host_set_pstate(host, pstate_index);
259 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
261 self->simcall.call = SIMCALL_HOST_SET_PSTATE;
262 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
263 memset(self->simcall.args, 0, sizeof(self->simcall.args));
264 self->simcall.args[0].dp = (void*) host;
265 self->simcall.args[1].i = (int) pstate_index;
266 if (self != simix_global->maestro_process) {
267 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
268 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
269 SIMIX_process_yield(self);
271 SIMIX_simcall_handle(&self->simcall, 0);
276 inline static int simcall_BODY_host_get_pstate(sg_host_t host) {
277 smx_process_t self = SIMIX_process_self();
279 /* Go to that function to follow the code flow through the simcall barrier */
280 if (0) SIMIX_host_get_pstate(host);
281 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
283 self->simcall.call = SIMCALL_HOST_GET_PSTATE;
284 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
285 memset(self->simcall.args, 0, sizeof(self->simcall.args));
286 self->simcall.args[0].dp = (void*) host;
287 if (self != simix_global->maestro_process) {
288 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
289 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
290 SIMIX_process_yield(self);
292 SIMIX_simcall_handle(&self->simcall, 0);
294 return self->simcall.result.i;
297 inline static double simcall_BODY_host_get_consumed_energy(sg_host_t host) {
298 smx_process_t self = SIMIX_process_self();
300 /* Go to that function to follow the code flow through the simcall barrier */
301 if (0) SIMIX_host_get_consumed_energy(host);
302 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
304 self->simcall.call = SIMCALL_HOST_GET_CONSUMED_ENERGY;
305 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
306 memset(self->simcall.args, 0, sizeof(self->simcall.args));
307 self->simcall.args[0].dp = (void*) host;
308 if (self != simix_global->maestro_process) {
309 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
310 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
311 SIMIX_process_yield(self);
313 SIMIX_simcall_handle(&self->simcall, 0);
315 return self->simcall.result.d;
318 inline static xbt_dict_t simcall_BODY_host_get_mounted_storage_list(sg_host_t host) {
319 smx_process_t self = SIMIX_process_self();
321 /* Go to that function to follow the code flow through the simcall barrier */
322 if (0) SIMIX_host_get_mounted_storage_list(host);
323 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
325 self->simcall.call = SIMCALL_HOST_GET_MOUNTED_STORAGE_LIST;
326 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
327 memset(self->simcall.args, 0, sizeof(self->simcall.args));
328 self->simcall.args[0].dp = (void*) host;
329 if (self != simix_global->maestro_process) {
330 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
331 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
332 SIMIX_process_yield(self);
334 SIMIX_simcall_handle(&self->simcall, 0);
336 return self->simcall.result.dp;
339 inline static xbt_dynar_t simcall_BODY_host_get_attached_storage_list(sg_host_t host) {
340 smx_process_t self = SIMIX_process_self();
342 /* Go to that function to follow the code flow through the simcall barrier */
343 if (0) SIMIX_host_get_attached_storage_list(host);
344 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
346 self->simcall.call = SIMCALL_HOST_GET_ATTACHED_STORAGE_LIST;
347 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
348 memset(self->simcall.args, 0, sizeof(self->simcall.args));
349 self->simcall.args[0].dp = (void*) host;
350 if (self != simix_global->maestro_process) {
351 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
352 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
353 SIMIX_process_yield(self);
355 SIMIX_simcall_handle(&self->simcall, 0);
357 return self->simcall.result.dp;
360 inline static void simcall_BODY_host_get_params(sg_host_t ind_vm, vm_params_t params) {
361 smx_process_t self = SIMIX_process_self();
363 /* Go to that function to follow the code flow through the simcall barrier */
364 if (0) SIMIX_host_get_params(ind_vm, params);
365 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
367 self->simcall.call = SIMCALL_HOST_GET_PARAMS;
368 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
369 memset(self->simcall.args, 0, sizeof(self->simcall.args));
370 self->simcall.args[0].dp = (void*) ind_vm;
371 self->simcall.args[1].dp = (void*) params;
372 if (self != simix_global->maestro_process) {
373 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
374 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
375 SIMIX_process_yield(self);
377 SIMIX_simcall_handle(&self->simcall, 0);
382 inline static void simcall_BODY_host_set_params(sg_host_t ind_vm, vm_params_t params) {
383 smx_process_t self = SIMIX_process_self();
385 /* Go to that function to follow the code flow through the simcall barrier */
386 if (0) SIMIX_host_set_params(ind_vm, params);
387 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
389 self->simcall.call = SIMCALL_HOST_SET_PARAMS;
390 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
391 memset(self->simcall.args, 0, sizeof(self->simcall.args));
392 self->simcall.args[0].dp = (void*) ind_vm;
393 self->simcall.args[1].dp = (void*) params;
394 if (self != simix_global->maestro_process) {
395 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
396 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
397 SIMIX_process_yield(self);
399 SIMIX_simcall_handle(&self->simcall, 0);
404 inline static sg_host_t simcall_BODY_vm_create(const char* name, sg_host_t ind_pm) {
405 smx_process_t self = SIMIX_process_self();
407 /* Go to that function to follow the code flow through the simcall barrier */
408 if (0) SIMIX_vm_create(name, ind_pm);
409 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
411 self->simcall.call = SIMCALL_VM_CREATE;
412 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
413 memset(self->simcall.args, 0, sizeof(self->simcall.args));
414 self->simcall.args[0].cc = (const char*) name;
415 self->simcall.args[1].dp = (void*) ind_pm;
416 if (self != simix_global->maestro_process) {
417 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
418 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
419 SIMIX_process_yield(self);
421 SIMIX_simcall_handle(&self->simcall, 0);
423 return self->simcall.result.dp;
426 inline static void simcall_BODY_vm_start(sg_host_t ind_vm) {
427 smx_process_t self = SIMIX_process_self();
429 /* Go to that function to follow the code flow through the simcall barrier */
430 if (0) SIMIX_vm_start(ind_vm);
431 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
433 self->simcall.call = SIMCALL_VM_START;
434 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
435 memset(self->simcall.args, 0, sizeof(self->simcall.args));
436 self->simcall.args[0].dp = (void*) ind_vm;
437 if (self != simix_global->maestro_process) {
438 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
439 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
440 SIMIX_process_yield(self);
442 SIMIX_simcall_handle(&self->simcall, 0);
447 inline static int simcall_BODY_vm_get_state(sg_host_t ind_vm) {
448 smx_process_t self = SIMIX_process_self();
450 /* Go to that function to follow the code flow through the simcall barrier */
451 if (0) SIMIX_vm_get_state(ind_vm);
452 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
454 self->simcall.call = SIMCALL_VM_GET_STATE;
455 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
456 memset(self->simcall.args, 0, sizeof(self->simcall.args));
457 self->simcall.args[0].dp = (void*) ind_vm;
458 if (self != simix_global->maestro_process) {
459 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
460 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
461 SIMIX_process_yield(self);
463 SIMIX_simcall_handle(&self->simcall, 0);
465 return self->simcall.result.i;
468 inline static void simcall_BODY_vm_migrate(sg_host_t ind_vm, sg_host_t ind_dst_pm) {
469 smx_process_t self = SIMIX_process_self();
471 /* Go to that function to follow the code flow through the simcall barrier */
472 if (0) SIMIX_vm_migrate(ind_vm, ind_dst_pm);
473 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
475 self->simcall.call = SIMCALL_VM_MIGRATE;
476 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
477 memset(self->simcall.args, 0, sizeof(self->simcall.args));
478 self->simcall.args[0].dp = (void*) ind_vm;
479 self->simcall.args[1].dp = (void*) ind_dst_pm;
480 if (self != simix_global->maestro_process) {
481 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
482 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
483 SIMIX_process_yield(self);
485 SIMIX_simcall_handle(&self->simcall, 0);
490 inline static void* simcall_BODY_vm_get_pm(sg_host_t ind_vm) {
491 smx_process_t self = SIMIX_process_self();
493 /* Go to that function to follow the code flow through the simcall barrier */
494 if (0) SIMIX_vm_get_pm(ind_vm);
495 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
497 self->simcall.call = SIMCALL_VM_GET_PM;
498 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
499 memset(self->simcall.args, 0, sizeof(self->simcall.args));
500 self->simcall.args[0].dp = (void*) ind_vm;
501 if (self != simix_global->maestro_process) {
502 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
503 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
504 SIMIX_process_yield(self);
506 SIMIX_simcall_handle(&self->simcall, 0);
508 return self->simcall.result.dp;
511 inline static void simcall_BODY_vm_set_bound(sg_host_t ind_vm, double bound) {
512 smx_process_t self = SIMIX_process_self();
514 /* Go to that function to follow the code flow through the simcall barrier */
515 if (0) SIMIX_vm_set_bound(ind_vm, bound);
516 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
518 self->simcall.call = SIMCALL_VM_SET_BOUND;
519 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
520 memset(self->simcall.args, 0, sizeof(self->simcall.args));
521 self->simcall.args[0].dp = (void*) ind_vm;
522 self->simcall.args[1].d = (double) bound;
523 if (self != simix_global->maestro_process) {
524 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
525 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
526 SIMIX_process_yield(self);
528 SIMIX_simcall_handle(&self->simcall, 0);
533 inline static void simcall_BODY_vm_set_affinity(sg_host_t ind_vm, sg_host_t ind_pm, unsigned long mask) {
534 smx_process_t self = SIMIX_process_self();
536 /* Go to that function to follow the code flow through the simcall barrier */
537 if (0) SIMIX_vm_set_affinity(ind_vm, ind_pm, mask);
538 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
540 self->simcall.call = SIMCALL_VM_SET_AFFINITY;
541 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
542 memset(self->simcall.args, 0, sizeof(self->simcall.args));
543 self->simcall.args[0].dp = (void*) ind_vm;
544 self->simcall.args[1].dp = (void*) ind_pm;
545 self->simcall.args[2].ul = (unsigned long) mask;
546 if (self != simix_global->maestro_process) {
547 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
548 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
549 SIMIX_process_yield(self);
551 SIMIX_simcall_handle(&self->simcall, 0);
556 inline static void simcall_BODY_vm_destroy(sg_host_t ind_vm) {
557 smx_process_t self = SIMIX_process_self();
559 /* Go to that function to follow the code flow through the simcall barrier */
560 if (0) SIMIX_vm_destroy(ind_vm);
561 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
563 self->simcall.call = SIMCALL_VM_DESTROY;
564 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
565 memset(self->simcall.args, 0, sizeof(self->simcall.args));
566 self->simcall.args[0].dp = (void*) ind_vm;
567 if (self != simix_global->maestro_process) {
568 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
569 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
570 SIMIX_process_yield(self);
572 SIMIX_simcall_handle(&self->simcall, 0);
577 inline static void simcall_BODY_vm_suspend(sg_host_t ind_vm) {
578 smx_process_t self = SIMIX_process_self();
580 /* Go to that function to follow the code flow through the simcall barrier */
581 if (0) simcall_HANDLER_vm_suspend(&self->simcall, ind_vm);
582 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
584 self->simcall.call = SIMCALL_VM_SUSPEND;
585 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
586 memset(self->simcall.args, 0, sizeof(self->simcall.args));
587 self->simcall.args[0].dp = (void*) ind_vm;
588 if (self != simix_global->maestro_process) {
589 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
590 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
591 SIMIX_process_yield(self);
593 SIMIX_simcall_handle(&self->simcall, 0);
598 inline static void simcall_BODY_vm_resume(sg_host_t ind_vm) {
599 smx_process_t self = SIMIX_process_self();
601 /* Go to that function to follow the code flow through the simcall barrier */
602 if (0) simcall_HANDLER_vm_resume(&self->simcall, ind_vm);
603 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
605 self->simcall.call = SIMCALL_VM_RESUME;
606 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
607 memset(self->simcall.args, 0, sizeof(self->simcall.args));
608 self->simcall.args[0].dp = (void*) ind_vm;
609 if (self != simix_global->maestro_process) {
610 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
611 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
612 SIMIX_process_yield(self);
614 SIMIX_simcall_handle(&self->simcall, 0);
619 inline static void simcall_BODY_vm_shutdown(sg_host_t ind_vm) {
620 smx_process_t self = SIMIX_process_self();
622 /* Go to that function to follow the code flow through the simcall barrier */
623 if (0) simcall_HANDLER_vm_shutdown(&self->simcall, ind_vm);
624 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
626 self->simcall.call = SIMCALL_VM_SHUTDOWN;
627 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
628 memset(self->simcall.args, 0, sizeof(self->simcall.args));
629 self->simcall.args[0].dp = (void*) ind_vm;
630 if (self != simix_global->maestro_process) {
631 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
632 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
633 SIMIX_process_yield(self);
635 SIMIX_simcall_handle(&self->simcall, 0);
640 inline static void simcall_BODY_vm_save(sg_host_t ind_vm) {
641 smx_process_t self = SIMIX_process_self();
643 /* Go to that function to follow the code flow through the simcall barrier */
644 if (0) simcall_HANDLER_vm_save(&self->simcall, ind_vm);
645 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
647 self->simcall.call = SIMCALL_VM_SAVE;
648 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
649 memset(self->simcall.args, 0, sizeof(self->simcall.args));
650 self->simcall.args[0].dp = (void*) ind_vm;
651 if (self != simix_global->maestro_process) {
652 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
653 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
654 SIMIX_process_yield(self);
656 SIMIX_simcall_handle(&self->simcall, 0);
661 inline static void simcall_BODY_vm_restore(sg_host_t ind_vm) {
662 smx_process_t self = SIMIX_process_self();
664 /* Go to that function to follow the code flow through the simcall barrier */
665 if (0) simcall_HANDLER_vm_restore(&self->simcall, ind_vm);
666 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
668 self->simcall.call = SIMCALL_VM_RESTORE;
669 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
670 memset(self->simcall.args, 0, sizeof(self->simcall.args));
671 self->simcall.args[0].dp = (void*) ind_vm;
672 if (self != simix_global->maestro_process) {
673 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
674 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
675 SIMIX_process_yield(self);
677 SIMIX_simcall_handle(&self->simcall, 0);
682 inline static void simcall_BODY_vm_migratefrom_resumeto(sg_host_t vm, sg_host_t src_pm, sg_host_t dst_pm) {
683 smx_process_t self = SIMIX_process_self();
685 /* Go to that function to follow the code flow through the simcall barrier */
686 if (0) SIMIX_vm_migratefrom_resumeto(vm, src_pm, dst_pm);
687 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
689 self->simcall.call = SIMCALL_VM_MIGRATEFROM_RESUMETO;
690 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
691 memset(self->simcall.args, 0, sizeof(self->simcall.args));
692 self->simcall.args[0].dp = (void*) vm;
693 self->simcall.args[1].dp = (void*) src_pm;
694 self->simcall.args[2].dp = (void*) dst_pm;
695 if (self != simix_global->maestro_process) {
696 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
697 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
698 SIMIX_process_yield(self);
700 SIMIX_simcall_handle(&self->simcall, 0);
705 inline static void* simcall_BODY_process_create(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) {
706 smx_process_t self = SIMIX_process_self();
708 /* Go to that function to follow the code flow through the simcall barrier */
709 if (0) simcall_HANDLER_process_create(&self->simcall, name, code, data, hostname, kill_time, argc, argv, properties, auto_restart);
710 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
712 self->simcall.call = SIMCALL_PROCESS_CREATE;
713 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
714 memset(self->simcall.args, 0, sizeof(self->simcall.args));
715 self->simcall.args[0].cc = (const char*) name;
716 self->simcall.args[1].fp = (FPtr) code;
717 self->simcall.args[2].dp = (void*) data;
718 self->simcall.args[3].cc = (const char*) hostname;
719 self->simcall.args[4].d = (double) kill_time;
720 self->simcall.args[5].i = (int) argc;
721 self->simcall.args[6].dp = (void*) argv;
722 self->simcall.args[7].dp = (void*) properties;
723 self->simcall.args[8].i = (int) auto_restart;
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);
731 return self->simcall.result.dp;
734 inline static void simcall_BODY_process_kill(smx_process_t process) {
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) simcall_HANDLER_process_kill(&self->simcall, process);
739 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
741 self->simcall.call = SIMCALL_PROCESS_KILL;
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*) process;
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);
755 inline static void simcall_BODY_process_killall(int reset_pid) {
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) simcall_HANDLER_process_killall(&self->simcall, reset_pid);
760 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
762 self->simcall.call = SIMCALL_PROCESS_KILLALL;
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].i = (int) reset_pid;
766 if (self != simix_global->maestro_process) {
767 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
768 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
769 SIMIX_process_yield(self);
771 SIMIX_simcall_handle(&self->simcall, 0);
776 inline static void simcall_BODY_process_cleanup(smx_process_t process) {
777 smx_process_t self = SIMIX_process_self();
779 /* Go to that function to follow the code flow through the simcall barrier */
780 if (0) SIMIX_process_cleanup(process);
781 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
783 self->simcall.call = SIMCALL_PROCESS_CLEANUP;
784 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
785 memset(self->simcall.args, 0, sizeof(self->simcall.args));
786 self->simcall.args[0].dp = (void*) process;
787 if (self != simix_global->maestro_process) {
788 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
789 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
790 SIMIX_process_yield(self);
792 SIMIX_simcall_handle(&self->simcall, 0);
797 inline static void simcall_BODY_process_suspend(smx_process_t process) {
798 smx_process_t self = SIMIX_process_self();
800 /* Go to that function to follow the code flow through the simcall barrier */
801 if (0) simcall_HANDLER_process_suspend(&self->simcall, process);
802 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
804 self->simcall.call = SIMCALL_PROCESS_SUSPEND;
805 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
806 memset(self->simcall.args, 0, sizeof(self->simcall.args));
807 self->simcall.args[0].dp = (void*) process;
808 if (self != simix_global->maestro_process) {
809 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
810 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
811 SIMIX_process_yield(self);
813 SIMIX_simcall_handle(&self->simcall, 0);
818 inline static void simcall_BODY_process_resume(smx_process_t process) {
819 smx_process_t self = SIMIX_process_self();
821 /* Go to that function to follow the code flow through the simcall barrier */
822 if (0) simcall_HANDLER_process_resume(&self->simcall, process);
823 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
825 self->simcall.call = SIMCALL_PROCESS_RESUME;
826 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
827 memset(self->simcall.args, 0, sizeof(self->simcall.args));
828 self->simcall.args[0].dp = (void*) process;
829 if (self != simix_global->maestro_process) {
830 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
831 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
832 SIMIX_process_yield(self);
834 SIMIX_simcall_handle(&self->simcall, 0);
839 inline static int simcall_BODY_process_count() {
840 smx_process_t self = SIMIX_process_self();
842 /* Go to that function to follow the code flow through the simcall barrier */
843 if (0) SIMIX_process_count();
844 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
846 self->simcall.call = SIMCALL_PROCESS_COUNT;
847 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
848 memset(self->simcall.args, 0, sizeof(self->simcall.args));
850 if (self != simix_global->maestro_process) {
851 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
852 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
853 SIMIX_process_yield(self);
855 SIMIX_simcall_handle(&self->simcall, 0);
857 return self->simcall.result.i;
860 inline static int simcall_BODY_process_get_PID(smx_process_t process) {
861 smx_process_t self = SIMIX_process_self();
863 /* Go to that function to follow the code flow through the simcall barrier */
864 if (0) SIMIX_process_get_PID(process);
865 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
867 self->simcall.call = SIMCALL_PROCESS_GET_PID;
868 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
869 memset(self->simcall.args, 0, sizeof(self->simcall.args));
870 self->simcall.args[0].dp = (void*) process;
871 if (self != simix_global->maestro_process) {
872 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
873 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
874 SIMIX_process_yield(self);
876 SIMIX_simcall_handle(&self->simcall, 0);
878 return self->simcall.result.i;
881 inline static int simcall_BODY_process_get_PPID(smx_process_t process) {
882 smx_process_t self = SIMIX_process_self();
884 /* Go to that function to follow the code flow through the simcall barrier */
885 if (0) SIMIX_process_get_PPID(process);
886 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
888 self->simcall.call = SIMCALL_PROCESS_GET_PPID;
889 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
890 memset(self->simcall.args, 0, sizeof(self->simcall.args));
891 self->simcall.args[0].dp = (void*) process;
892 if (self != simix_global->maestro_process) {
893 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
894 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
895 SIMIX_process_yield(self);
897 SIMIX_simcall_handle(&self->simcall, 0);
899 return self->simcall.result.i;
902 inline static void* simcall_BODY_process_get_data(smx_process_t process) {
903 smx_process_t self = SIMIX_process_self();
905 /* Go to that function to follow the code flow through the simcall barrier */
906 if (0) SIMIX_process_get_data(process);
907 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
909 self->simcall.call = SIMCALL_PROCESS_GET_DATA;
910 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
911 memset(self->simcall.args, 0, sizeof(self->simcall.args));
912 self->simcall.args[0].dp = (void*) process;
913 if (self != simix_global->maestro_process) {
914 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
915 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
916 SIMIX_process_yield(self);
918 SIMIX_simcall_handle(&self->simcall, 0);
920 return self->simcall.result.dp;
923 inline static void simcall_BODY_process_set_data(smx_process_t process, void* data) {
924 smx_process_t self = SIMIX_process_self();
926 /* Go to that function to follow the code flow through the simcall barrier */
927 if (0) SIMIX_process_set_data(process, data);
928 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
930 self->simcall.call = SIMCALL_PROCESS_SET_DATA;
931 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
932 memset(self->simcall.args, 0, sizeof(self->simcall.args));
933 self->simcall.args[0].dp = (void*) process;
934 self->simcall.args[1].dp = (void*) data;
935 if (self != simix_global->maestro_process) {
936 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
937 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
938 SIMIX_process_yield(self);
940 SIMIX_simcall_handle(&self->simcall, 0);
945 inline static void simcall_BODY_process_set_host(smx_process_t process, sg_host_t dest) {
946 smx_process_t self = SIMIX_process_self();
948 /* Go to that function to follow the code flow through the simcall barrier */
949 if (0) simcall_HANDLER_process_set_host(&self->simcall, process, dest);
950 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
952 self->simcall.call = SIMCALL_PROCESS_SET_HOST;
953 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
954 memset(self->simcall.args, 0, sizeof(self->simcall.args));
955 self->simcall.args[0].dp = (void*) process;
956 self->simcall.args[1].dp = (void*) dest;
957 if (self != simix_global->maestro_process) {
958 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
959 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
960 SIMIX_process_yield(self);
962 SIMIX_simcall_handle(&self->simcall, 0);
967 inline static sg_host_t simcall_BODY_process_get_host(smx_process_t process) {
968 smx_process_t self = SIMIX_process_self();
970 /* Go to that function to follow the code flow through the simcall barrier */
971 if (0) SIMIX_process_get_host(process);
972 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
974 self->simcall.call = SIMCALL_PROCESS_GET_HOST;
975 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
976 memset(self->simcall.args, 0, sizeof(self->simcall.args));
977 self->simcall.args[0].dp = (void*) process;
978 if (self != simix_global->maestro_process) {
979 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
980 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
981 SIMIX_process_yield(self);
983 SIMIX_simcall_handle(&self->simcall, 0);
985 return self->simcall.result.dp;
988 inline static const char* simcall_BODY_process_get_name(smx_process_t process) {
989 smx_process_t self = SIMIX_process_self();
991 /* Go to that function to follow the code flow through the simcall barrier */
992 if (0) SIMIX_process_get_name(process);
993 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
995 self->simcall.call = SIMCALL_PROCESS_GET_NAME;
996 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
997 memset(self->simcall.args, 0, sizeof(self->simcall.args));
998 self->simcall.args[0].dp = (void*) process;
999 if (self != simix_global->maestro_process) {
1000 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1001 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1002 SIMIX_process_yield(self);
1004 SIMIX_simcall_handle(&self->simcall, 0);
1006 return self->simcall.result.cc;
1009 inline static int simcall_BODY_process_is_suspended(smx_process_t process) {
1010 smx_process_t self = SIMIX_process_self();
1012 /* Go to that function to follow the code flow through the simcall barrier */
1013 if (0) SIMIX_process_is_suspended(process);
1014 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1016 self->simcall.call = SIMCALL_PROCESS_IS_SUSPENDED;
1017 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1018 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1019 self->simcall.args[0].dp = (void*) process;
1020 if (self != simix_global->maestro_process) {
1021 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1022 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1023 SIMIX_process_yield(self);
1025 SIMIX_simcall_handle(&self->simcall, 0);
1027 return self->simcall.result.i;
1030 inline static xbt_dict_t simcall_BODY_process_get_properties(smx_process_t process) {
1031 smx_process_t self = SIMIX_process_self();
1033 /* Go to that function to follow the code flow through the simcall barrier */
1034 if (0) SIMIX_process_get_properties(process);
1035 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1037 self->simcall.call = SIMCALL_PROCESS_GET_PROPERTIES;
1038 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1039 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1040 self->simcall.args[0].dp = (void*) process;
1041 if (self != simix_global->maestro_process) {
1042 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1043 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1044 SIMIX_process_yield(self);
1046 SIMIX_simcall_handle(&self->simcall, 0);
1048 return self->simcall.result.dp;
1051 inline static int simcall_BODY_process_join(smx_process_t process, double timeout) {
1052 smx_process_t self = SIMIX_process_self();
1054 /* Go to that function to follow the code flow through the simcall barrier */
1055 if (0) simcall_HANDLER_process_join(&self->simcall, process, timeout);
1056 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1058 self->simcall.call = SIMCALL_PROCESS_JOIN;
1059 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1060 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1061 self->simcall.args[0].dp = (void*) process;
1062 self->simcall.args[1].d = (double) timeout;
1063 if (self != simix_global->maestro_process) {
1064 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1065 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1066 SIMIX_process_yield(self);
1068 SIMIX_simcall_handle(&self->simcall, 0);
1070 return self->simcall.result.i;
1073 inline static int simcall_BODY_process_sleep(double duration) {
1074 smx_process_t self = SIMIX_process_self();
1076 /* Go to that function to follow the code flow through the simcall barrier */
1077 if (0) simcall_HANDLER_process_sleep(&self->simcall, duration);
1078 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1080 self->simcall.call = SIMCALL_PROCESS_SLEEP;
1081 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1082 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1083 self->simcall.args[0].d = (double) duration;
1084 if (self != simix_global->maestro_process) {
1085 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1086 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1087 SIMIX_process_yield(self);
1089 SIMIX_simcall_handle(&self->simcall, 0);
1091 return self->simcall.result.i;
1094 inline static smx_synchro_t simcall_BODY_process_execute(const char* name, double flops_amount, double priority, double bound, unsigned long affinity_mask) {
1095 smx_process_t self = SIMIX_process_self();
1097 /* Go to that function to follow the code flow through the simcall barrier */
1098 if (0) simcall_HANDLER_process_execute(&self->simcall, name, flops_amount, priority, bound, affinity_mask);
1099 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1101 self->simcall.call = SIMCALL_PROCESS_EXECUTE;
1102 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1103 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1104 self->simcall.args[0].cc = (const char*) name;
1105 self->simcall.args[1].d = (double) flops_amount;
1106 self->simcall.args[2].d = (double) priority;
1107 self->simcall.args[3].d = (double) bound;
1108 self->simcall.args[4].ul = (unsigned long) affinity_mask;
1109 if (self != simix_global->maestro_process) {
1110 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1111 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1112 SIMIX_process_yield(self);
1114 SIMIX_simcall_handle(&self->simcall, 0);
1116 return self->simcall.result.dp;
1119 inline static smx_synchro_t simcall_BODY_process_parallel_execute(const char* name, int host_nb, sg_host_t* host_list, double* flops_amount, double* bytes_amount, double amount, double rate) {
1120 smx_process_t self = SIMIX_process_self();
1122 /* Go to that function to follow the code flow through the simcall barrier */
1123 if (0) SIMIX_process_parallel_execute(name, host_nb, host_list, flops_amount, bytes_amount, amount, rate);
1124 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1126 self->simcall.call = SIMCALL_PROCESS_PARALLEL_EXECUTE;
1127 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1128 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1129 self->simcall.args[0].cc = (const char*) name;
1130 self->simcall.args[1].i = (int) host_nb;
1131 self->simcall.args[2].dp = (void*) host_list;
1132 self->simcall.args[3].dp = (void*) flops_amount;
1133 self->simcall.args[4].dp = (void*) bytes_amount;
1134 self->simcall.args[5].d = (double) amount;
1135 self->simcall.args[6].d = (double) rate;
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.dp;
1146 inline static void simcall_BODY_process_execution_destroy(smx_synchro_t execution) {
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_execution_destroy(execution);
1151 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1153 self->simcall.call = SIMCALL_PROCESS_EXECUTION_DESTROY;
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*) execution;
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);
1167 inline static void simcall_BODY_process_execution_cancel(smx_synchro_t execution) {
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_execution_cancel(execution);
1172 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1174 self->simcall.call = SIMCALL_PROCESS_EXECUTION_CANCEL;
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*) execution;
1178 if (self != simix_global->maestro_process) {
1179 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1180 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1181 SIMIX_process_yield(self);
1183 SIMIX_simcall_handle(&self->simcall, 0);
1188 inline static double simcall_BODY_process_execution_get_remains(smx_synchro_t execution) {
1189 smx_process_t self = SIMIX_process_self();
1191 /* Go to that function to follow the code flow through the simcall barrier */
1192 if (0) SIMIX_process_execution_get_remains(execution);
1193 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1195 self->simcall.call = SIMCALL_PROCESS_EXECUTION_GET_REMAINS;
1196 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1197 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1198 self->simcall.args[0].dp = (void*) execution;
1199 if (self != simix_global->maestro_process) {
1200 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1201 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1202 SIMIX_process_yield(self);
1204 SIMIX_simcall_handle(&self->simcall, 0);
1206 return self->simcall.result.d;
1209 inline static e_smx_state_t simcall_BODY_process_execution_get_state(smx_synchro_t execution) {
1210 smx_process_t self = SIMIX_process_self();
1212 /* Go to that function to follow the code flow through the simcall barrier */
1213 if (0) SIMIX_process_execution_get_state(execution);
1214 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1216 self->simcall.call = SIMCALL_PROCESS_EXECUTION_GET_STATE;
1217 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1218 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1219 self->simcall.args[0].dp = (void*) execution;
1220 if (self != simix_global->maestro_process) {
1221 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1222 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1223 SIMIX_process_yield(self);
1225 SIMIX_simcall_handle(&self->simcall, 0);
1227 return self->simcall.result.i;
1230 inline static void simcall_BODY_process_execution_set_priority(smx_synchro_t execution, double priority) {
1231 smx_process_t self = SIMIX_process_self();
1233 /* Go to that function to follow the code flow through the simcall barrier */
1234 if (0) SIMIX_process_execution_set_priority(execution, priority);
1235 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1237 self->simcall.call = SIMCALL_PROCESS_EXECUTION_SET_PRIORITY;
1238 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1239 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1240 self->simcall.args[0].dp = (void*) execution;
1241 self->simcall.args[1].d = (double) priority;
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);
1252 inline static void simcall_BODY_process_execution_set_bound(smx_synchro_t execution, double bound) {
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_execution_set_bound(execution, bound);
1257 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1259 self->simcall.call = SIMCALL_PROCESS_EXECUTION_SET_BOUND;
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*) execution;
1263 self->simcall.args[1].d = (double) bound;
1264 if (self != simix_global->maestro_process) {
1265 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1266 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1267 SIMIX_process_yield(self);
1269 SIMIX_simcall_handle(&self->simcall, 0);
1274 inline static void simcall_BODY_process_execution_set_affinity(smx_synchro_t execution, sg_host_t ws, unsigned long mask) {
1275 smx_process_t self = SIMIX_process_self();
1277 /* Go to that function to follow the code flow through the simcall barrier */
1278 if (0) SIMIX_process_execution_set_affinity(execution, ws, mask);
1279 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1281 self->simcall.call = SIMCALL_PROCESS_EXECUTION_SET_AFFINITY;
1282 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1283 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1284 self->simcall.args[0].dp = (void*) execution;
1285 self->simcall.args[1].dp = (void*) ws;
1286 self->simcall.args[2].ul = (unsigned long) mask;
1287 if (self != simix_global->maestro_process) {
1288 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1289 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1290 SIMIX_process_yield(self);
1292 SIMIX_simcall_handle(&self->simcall, 0);
1297 inline static int simcall_BODY_process_execution_wait(smx_synchro_t execution) {
1298 smx_process_t self = SIMIX_process_self();
1300 /* Go to that function to follow the code flow through the simcall barrier */
1301 if (0) simcall_HANDLER_process_execution_wait(&self->simcall, execution);
1302 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1304 self->simcall.call = SIMCALL_PROCESS_EXECUTION_WAIT;
1305 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1306 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1307 self->simcall.args[0].dp = (void*) execution;
1308 if (self != simix_global->maestro_process) {
1309 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1310 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1311 SIMIX_process_yield(self);
1313 SIMIX_simcall_handle(&self->simcall, 0);
1315 return self->simcall.result.i;
1318 inline static void simcall_BODY_process_on_exit(smx_process_t process, int_f_pvoid_pvoid_t fun, void* data) {
1319 smx_process_t self = SIMIX_process_self();
1321 /* Go to that function to follow the code flow through the simcall barrier */
1322 if (0) SIMIX_process_on_exit(process, fun, data);
1323 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1325 self->simcall.call = SIMCALL_PROCESS_ON_EXIT;
1326 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1327 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1328 self->simcall.args[0].dp = (void*) process;
1329 self->simcall.args[1].fp = (FPtr) fun;
1330 self->simcall.args[2].dp = (void*) data;
1331 if (self != simix_global->maestro_process) {
1332 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1333 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1334 SIMIX_process_yield(self);
1336 SIMIX_simcall_handle(&self->simcall, 0);
1341 inline static void simcall_BODY_process_auto_restart_set(smx_process_t process, int auto_restart) {
1342 smx_process_t self = SIMIX_process_self();
1344 /* Go to that function to follow the code flow through the simcall barrier */
1345 if (0) SIMIX_process_auto_restart_set(process, auto_restart);
1346 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1348 self->simcall.call = SIMCALL_PROCESS_AUTO_RESTART_SET;
1349 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1350 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1351 self->simcall.args[0].dp = (void*) process;
1352 self->simcall.args[1].i = (int) auto_restart;
1353 if (self != simix_global->maestro_process) {
1354 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1355 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1356 SIMIX_process_yield(self);
1358 SIMIX_simcall_handle(&self->simcall, 0);
1363 inline static smx_process_t simcall_BODY_process_restart(smx_process_t process) {
1364 smx_process_t self = SIMIX_process_self();
1366 /* Go to that function to follow the code flow through the simcall barrier */
1367 if (0) simcall_HANDLER_process_restart(&self->simcall, process);
1368 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1370 self->simcall.call = SIMCALL_PROCESS_RESTART;
1371 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1372 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1373 self->simcall.args[0].dp = (void*) process;
1374 if (self != simix_global->maestro_process) {
1375 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1376 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1377 SIMIX_process_yield(self);
1379 SIMIX_simcall_handle(&self->simcall, 0);
1381 return self->simcall.result.dp;
1384 inline static smx_rdv_t simcall_BODY_rdv_create(const char* name) {
1385 smx_process_t self = SIMIX_process_self();
1387 /* Go to that function to follow the code flow through the simcall barrier */
1388 if (0) SIMIX_rdv_create(name);
1389 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1391 self->simcall.call = SIMCALL_RDV_CREATE;
1392 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1393 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1394 self->simcall.args[0].cc = (const char*) name;
1395 if (self != simix_global->maestro_process) {
1396 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1397 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1398 SIMIX_process_yield(self);
1400 SIMIX_simcall_handle(&self->simcall, 0);
1402 return self->simcall.result.dp;
1405 inline static void simcall_BODY_rdv_destroy(smx_rdv_t rdv) {
1406 smx_process_t self = SIMIX_process_self();
1408 /* Go to that function to follow the code flow through the simcall barrier */
1409 if (0) SIMIX_rdv_destroy(rdv);
1410 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1412 self->simcall.call = SIMCALL_RDV_DESTROY;
1413 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1414 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1415 self->simcall.args[0].dp = (void*) rdv;
1416 if (self != simix_global->maestro_process) {
1417 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1418 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1419 SIMIX_process_yield(self);
1421 SIMIX_simcall_handle(&self->simcall, 0);
1426 inline static unsigned int simcall_BODY_rdv_comm_count_by_host(smx_rdv_t rdv, sg_host_t host) {
1427 smx_process_t self = SIMIX_process_self();
1429 /* Go to that function to follow the code flow through the simcall barrier */
1430 if (0) SIMIX_rdv_comm_count_by_host(rdv, host);
1431 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1433 self->simcall.call = SIMCALL_RDV_COMM_COUNT_BY_HOST;
1434 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1435 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1436 self->simcall.args[0].dp = (void*) rdv;
1437 self->simcall.args[1].dp = (void*) host;
1438 if (self != simix_global->maestro_process) {
1439 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1440 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1441 SIMIX_process_yield(self);
1443 SIMIX_simcall_handle(&self->simcall, 0);
1445 return self->simcall.result.ui;
1448 inline static smx_synchro_t simcall_BODY_rdv_get_head(smx_rdv_t rdv) {
1449 smx_process_t self = SIMIX_process_self();
1451 /* Go to that function to follow the code flow through the simcall barrier */
1452 if (0) SIMIX_rdv_get_head(rdv);
1453 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1455 self->simcall.call = SIMCALL_RDV_GET_HEAD;
1456 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1457 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1458 self->simcall.args[0].dp = (void*) rdv;
1459 if (self != simix_global->maestro_process) {
1460 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1461 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1462 SIMIX_process_yield(self);
1464 SIMIX_simcall_handle(&self->simcall, 0);
1466 return self->simcall.result.dp;
1469 inline static void simcall_BODY_rdv_set_receiver(smx_rdv_t rdv, smx_process_t receiver) {
1470 smx_process_t self = SIMIX_process_self();
1472 /* Go to that function to follow the code flow through the simcall barrier */
1473 if (0) SIMIX_rdv_set_receiver(rdv, receiver);
1474 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1476 self->simcall.call = SIMCALL_RDV_SET_RECEIVER;
1477 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1478 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1479 self->simcall.args[0].dp = (void*) rdv;
1480 self->simcall.args[1].dp = (void*) receiver;
1481 if (self != simix_global->maestro_process) {
1482 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1483 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1484 SIMIX_process_yield(self);
1486 SIMIX_simcall_handle(&self->simcall, 0);
1491 inline static smx_process_t simcall_BODY_rdv_get_receiver(smx_rdv_t rdv) {
1492 smx_process_t self = SIMIX_process_self();
1494 /* Go to that function to follow the code flow through the simcall barrier */
1495 if (0) SIMIX_rdv_get_receiver(rdv);
1496 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1498 self->simcall.call = SIMCALL_RDV_GET_RECEIVER;
1499 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1500 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1501 self->simcall.args[0].dp = (void*) rdv;
1502 if (self != simix_global->maestro_process) {
1503 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1504 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1505 SIMIX_process_yield(self);
1507 SIMIX_simcall_handle(&self->simcall, 0);
1509 return self->simcall.result.dp;
1512 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) {
1513 smx_process_t self = SIMIX_process_self();
1515 /* Go to that function to follow the code flow through the simcall barrier */
1516 if (0) simcall_HANDLER_comm_iprobe(&self->simcall, rdv, type, src, tag, match_fun, data);
1517 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1519 self->simcall.call = SIMCALL_COMM_IPROBE;
1520 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1521 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1522 self->simcall.args[0].dp = (void*) rdv;
1523 self->simcall.args[1].i = (int) type;
1524 self->simcall.args[2].i = (int) src;
1525 self->simcall.args[3].i = (int) tag;
1526 self->simcall.args[4].fp = (FPtr) match_fun;
1527 self->simcall.args[5].dp = (void*) data;
1528 if (self != simix_global->maestro_process) {
1529 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1530 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1531 SIMIX_process_yield(self);
1533 SIMIX_simcall_handle(&self->simcall, 0);
1535 return self->simcall.result.dp;
1538 inline static void simcall_BODY_comm_send(smx_process_t sender, 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) {
1539 smx_process_t self = SIMIX_process_self();
1541 /* Go to that function to follow the code flow through the simcall barrier */
1542 if (0) simcall_HANDLER_comm_send(&self->simcall, sender, rdv, task_size, rate, src_buff, src_buff_size, match_fun, copy_data_fun, data, timeout);
1543 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1545 self->simcall.call = SIMCALL_COMM_SEND;
1546 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1547 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1548 self->simcall.args[0].dp = (void*) sender;
1549 self->simcall.args[1].dp = (void*) rdv;
1550 self->simcall.args[2].d = (double) task_size;
1551 self->simcall.args[3].d = (double) rate;
1552 self->simcall.args[4].dp = (void*) src_buff;
1553 self->simcall.args[5].sz = (size_t) src_buff_size;
1554 self->simcall.args[6].fp = (FPtr) match_fun;
1555 self->simcall.args[7].fp = (FPtr) copy_data_fun;
1556 self->simcall.args[8].dp = (void*) data;
1557 self->simcall.args[9].d = (double) timeout;
1558 if (self != simix_global->maestro_process) {
1559 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1560 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1561 SIMIX_process_yield(self);
1563 SIMIX_simcall_handle(&self->simcall, 0);
1568 inline static smx_synchro_t simcall_BODY_comm_isend(smx_process_t sender, 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) {
1569 smx_process_t self = SIMIX_process_self();
1571 /* Go to that function to follow the code flow through the simcall barrier */
1572 if (0) simcall_HANDLER_comm_isend(&self->simcall, sender, rdv, task_size, rate, src_buff, src_buff_size, match_fun, clean_fun, copy_data_fun, data, detached);
1573 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1575 self->simcall.call = SIMCALL_COMM_ISEND;
1576 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1577 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1578 self->simcall.args[0].dp = (void*) sender;
1579 self->simcall.args[1].dp = (void*) rdv;
1580 self->simcall.args[2].d = (double) task_size;
1581 self->simcall.args[3].d = (double) rate;
1582 self->simcall.args[4].dp = (void*) src_buff;
1583 self->simcall.args[5].sz = (size_t) src_buff_size;
1584 self->simcall.args[6].fp = (FPtr) match_fun;
1585 self->simcall.args[7].fp = (FPtr) clean_fun;
1586 self->simcall.args[8].fp = (FPtr) copy_data_fun;
1587 self->simcall.args[9].dp = (void*) data;
1588 self->simcall.args[10].i = (int) detached;
1589 if (self != simix_global->maestro_process) {
1590 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1591 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1592 SIMIX_process_yield(self);
1594 SIMIX_simcall_handle(&self->simcall, 0);
1596 return self->simcall.result.dp;
1599 inline static void simcall_BODY_comm_recv(smx_process_t receiver, 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) {
1600 smx_process_t self = SIMIX_process_self();
1602 /* Go to that function to follow the code flow through the simcall barrier */
1603 if (0) simcall_HANDLER_comm_recv(&self->simcall, receiver, rdv, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, timeout, rate);
1604 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1606 self->simcall.call = SIMCALL_COMM_RECV;
1607 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1608 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1609 self->simcall.args[0].dp = (void*) receiver;
1610 self->simcall.args[1].dp = (void*) rdv;
1611 self->simcall.args[2].dp = (void*) dst_buff;
1612 self->simcall.args[3].dp = (void*) dst_buff_size;
1613 self->simcall.args[4].fp = (FPtr) match_fun;
1614 self->simcall.args[5].fp = (FPtr) copy_data_fun;
1615 self->simcall.args[6].dp = (void*) data;
1616 self->simcall.args[7].d = (double) timeout;
1617 self->simcall.args[8].d = (double) rate;
1618 if (self != simix_global->maestro_process) {
1619 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1620 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1621 SIMIX_process_yield(self);
1623 SIMIX_simcall_handle(&self->simcall, 0);
1628 inline static smx_synchro_t simcall_BODY_comm_irecv(smx_process_t receiver, 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) {
1629 smx_process_t self = SIMIX_process_self();
1631 /* Go to that function to follow the code flow through the simcall barrier */
1632 if (0) simcall_HANDLER_comm_irecv(&self->simcall, receiver, rdv, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, rate);
1633 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1635 self->simcall.call = SIMCALL_COMM_IRECV;
1636 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1637 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1638 self->simcall.args[0].dp = (void*) receiver;
1639 self->simcall.args[1].dp = (void*) rdv;
1640 self->simcall.args[2].dp = (void*) dst_buff;
1641 self->simcall.args[3].dp = (void*) dst_buff_size;
1642 self->simcall.args[4].fp = (FPtr) match_fun;
1643 self->simcall.args[5].fp = (FPtr) copy_data_fun;
1644 self->simcall.args[6].dp = (void*) data;
1645 self->simcall.args[7].d = (double) rate;
1646 if (self != simix_global->maestro_process) {
1647 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1648 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1649 SIMIX_process_yield(self);
1651 SIMIX_simcall_handle(&self->simcall, 0);
1653 return self->simcall.result.dp;
1656 inline static void simcall_BODY_comm_cancel(smx_synchro_t comm) {
1657 smx_process_t self = SIMIX_process_self();
1659 /* Go to that function to follow the code flow through the simcall barrier */
1660 if (0) SIMIX_comm_cancel(comm);
1661 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1663 self->simcall.call = SIMCALL_COMM_CANCEL;
1664 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1665 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1666 self->simcall.args[0].dp = (void*) comm;
1667 if (self != simix_global->maestro_process) {
1668 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1669 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1670 SIMIX_process_yield(self);
1672 SIMIX_simcall_handle(&self->simcall, 0);
1677 inline static int simcall_BODY_comm_waitany(xbt_dynar_t comms) {
1678 smx_process_t self = SIMIX_process_self();
1680 /* Go to that function to follow the code flow through the simcall barrier */
1681 if (0) simcall_HANDLER_comm_waitany(&self->simcall, comms);
1682 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1684 self->simcall.call = SIMCALL_COMM_WAITANY;
1685 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1686 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1687 self->simcall.args[0].dp = (void*) comms;
1688 if (self != simix_global->maestro_process) {
1689 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1690 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1691 SIMIX_process_yield(self);
1693 SIMIX_simcall_handle(&self->simcall, 0);
1695 return self->simcall.result.i;
1698 inline static void simcall_BODY_comm_wait(smx_synchro_t comm, double timeout) {
1699 smx_process_t self = SIMIX_process_self();
1701 /* Go to that function to follow the code flow through the simcall barrier */
1702 if (0) simcall_HANDLER_comm_wait(&self->simcall, comm, timeout);
1703 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1705 self->simcall.call = SIMCALL_COMM_WAIT;
1706 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1707 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1708 self->simcall.args[0].dp = (void*) comm;
1709 self->simcall.args[1].d = (double) timeout;
1710 if (self != simix_global->maestro_process) {
1711 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1712 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1713 SIMIX_process_yield(self);
1715 SIMIX_simcall_handle(&self->simcall, 0);
1720 inline static int simcall_BODY_comm_test(smx_synchro_t comm) {
1721 smx_process_t self = SIMIX_process_self();
1723 /* Go to that function to follow the code flow through the simcall barrier */
1724 if (0) simcall_HANDLER_comm_test(&self->simcall, comm);
1725 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1727 self->simcall.call = SIMCALL_COMM_TEST;
1728 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1729 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1730 self->simcall.args[0].dp = (void*) comm;
1731 if (self != simix_global->maestro_process) {
1732 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1733 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1734 SIMIX_process_yield(self);
1736 SIMIX_simcall_handle(&self->simcall, 0);
1738 return self->simcall.result.i;
1741 inline static int simcall_BODY_comm_testany(xbt_dynar_t comms) {
1742 smx_process_t self = SIMIX_process_self();
1744 /* Go to that function to follow the code flow through the simcall barrier */
1745 if (0) simcall_HANDLER_comm_testany(&self->simcall, comms);
1746 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1748 self->simcall.call = SIMCALL_COMM_TESTANY;
1749 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1750 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1751 self->simcall.args[0].dp = (void*) comms;
1752 if (self != simix_global->maestro_process) {
1753 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1754 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1755 SIMIX_process_yield(self);
1757 SIMIX_simcall_handle(&self->simcall, 0);
1759 return self->simcall.result.i;
1762 inline static double simcall_BODY_comm_get_remains(smx_synchro_t comm) {
1763 smx_process_t self = SIMIX_process_self();
1765 /* Go to that function to follow the code flow through the simcall barrier */
1766 if (0) SIMIX_comm_get_remains(comm);
1767 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1769 self->simcall.call = SIMCALL_COMM_GET_REMAINS;
1770 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1771 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1772 self->simcall.args[0].dp = (void*) comm;
1773 if (self != simix_global->maestro_process) {
1774 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1775 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1776 SIMIX_process_yield(self);
1778 SIMIX_simcall_handle(&self->simcall, 0);
1780 return self->simcall.result.d;
1783 inline static e_smx_state_t simcall_BODY_comm_get_state(smx_synchro_t comm) {
1784 smx_process_t self = SIMIX_process_self();
1786 /* Go to that function to follow the code flow through the simcall barrier */
1787 if (0) SIMIX_comm_get_state(comm);
1788 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1790 self->simcall.call = SIMCALL_COMM_GET_STATE;
1791 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1792 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1793 self->simcall.args[0].dp = (void*) comm;
1794 if (self != simix_global->maestro_process) {
1795 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1796 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1797 SIMIX_process_yield(self);
1799 SIMIX_simcall_handle(&self->simcall, 0);
1801 return self->simcall.result.i;
1804 inline static void* simcall_BODY_comm_get_src_data(smx_synchro_t comm) {
1805 smx_process_t self = SIMIX_process_self();
1807 /* Go to that function to follow the code flow through the simcall barrier */
1808 if (0) SIMIX_comm_get_src_data(comm);
1809 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1811 self->simcall.call = SIMCALL_COMM_GET_SRC_DATA;
1812 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1813 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1814 self->simcall.args[0].dp = (void*) comm;
1815 if (self != simix_global->maestro_process) {
1816 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1817 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1818 SIMIX_process_yield(self);
1820 SIMIX_simcall_handle(&self->simcall, 0);
1822 return self->simcall.result.dp;
1825 inline static void* simcall_BODY_comm_get_dst_data(smx_synchro_t comm) {
1826 smx_process_t self = SIMIX_process_self();
1828 /* Go to that function to follow the code flow through the simcall barrier */
1829 if (0) SIMIX_comm_get_dst_data(comm);
1830 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1832 self->simcall.call = SIMCALL_COMM_GET_DST_DATA;
1833 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1834 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1835 self->simcall.args[0].dp = (void*) comm;
1836 if (self != simix_global->maestro_process) {
1837 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1838 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1839 SIMIX_process_yield(self);
1841 SIMIX_simcall_handle(&self->simcall, 0);
1843 return self->simcall.result.dp;
1846 inline static smx_process_t simcall_BODY_comm_get_src_proc(smx_synchro_t comm) {
1847 smx_process_t self = SIMIX_process_self();
1849 /* Go to that function to follow the code flow through the simcall barrier */
1850 if (0) SIMIX_comm_get_src_proc(comm);
1851 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1853 self->simcall.call = SIMCALL_COMM_GET_SRC_PROC;
1854 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1855 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1856 self->simcall.args[0].dp = (void*) comm;
1857 if (self != simix_global->maestro_process) {
1858 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1859 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1860 SIMIX_process_yield(self);
1862 SIMIX_simcall_handle(&self->simcall, 0);
1864 return self->simcall.result.dp;
1867 inline static smx_process_t simcall_BODY_comm_get_dst_proc(smx_synchro_t comm) {
1868 smx_process_t self = SIMIX_process_self();
1870 /* Go to that function to follow the code flow through the simcall barrier */
1871 if (0) SIMIX_comm_get_dst_proc(comm);
1872 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1874 self->simcall.call = SIMCALL_COMM_GET_DST_PROC;
1875 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1876 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1877 self->simcall.args[0].dp = (void*) comm;
1878 if (self != simix_global->maestro_process) {
1879 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1880 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1881 SIMIX_process_yield(self);
1883 SIMIX_simcall_handle(&self->simcall, 0);
1885 return self->simcall.result.dp;
1888 inline static smx_mutex_t simcall_BODY_mutex_init() {
1889 smx_process_t self = SIMIX_process_self();
1891 /* Go to that function to follow the code flow through the simcall barrier */
1892 if (0) simcall_HANDLER_mutex_init(&self->simcall);
1893 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1895 self->simcall.call = SIMCALL_MUTEX_INIT;
1896 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1897 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1899 if (self != simix_global->maestro_process) {
1900 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1901 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1902 SIMIX_process_yield(self);
1904 SIMIX_simcall_handle(&self->simcall, 0);
1906 return self->simcall.result.dp;
1909 inline static void simcall_BODY_mutex_destroy(smx_mutex_t mutex) {
1910 smx_process_t self = SIMIX_process_self();
1912 /* Go to that function to follow the code flow through the simcall barrier */
1913 if (0) SIMIX_mutex_destroy(mutex);
1914 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1916 self->simcall.call = SIMCALL_MUTEX_DESTROY;
1917 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1918 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1919 self->simcall.args[0].dp = (void*) mutex;
1920 if (self != simix_global->maestro_process) {
1921 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1922 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1923 SIMIX_process_yield(self);
1925 SIMIX_simcall_handle(&self->simcall, 0);
1930 inline static void simcall_BODY_mutex_lock(smx_mutex_t mutex) {
1931 smx_process_t self = SIMIX_process_self();
1933 /* Go to that function to follow the code flow through the simcall barrier */
1934 if (0) simcall_HANDLER_mutex_lock(&self->simcall, mutex);
1935 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1937 self->simcall.call = SIMCALL_MUTEX_LOCK;
1938 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1939 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1940 self->simcall.args[0].dp = (void*) mutex;
1941 if (self != simix_global->maestro_process) {
1942 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1943 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1944 SIMIX_process_yield(self);
1946 SIMIX_simcall_handle(&self->simcall, 0);
1951 inline static int simcall_BODY_mutex_trylock(smx_mutex_t mutex) {
1952 smx_process_t self = SIMIX_process_self();
1954 /* Go to that function to follow the code flow through the simcall barrier */
1955 if (0) simcall_HANDLER_mutex_trylock(&self->simcall, mutex);
1956 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1958 self->simcall.call = SIMCALL_MUTEX_TRYLOCK;
1959 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1960 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1961 self->simcall.args[0].dp = (void*) mutex;
1962 if (self != simix_global->maestro_process) {
1963 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1964 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1965 SIMIX_process_yield(self);
1967 SIMIX_simcall_handle(&self->simcall, 0);
1969 return self->simcall.result.i;
1972 inline static void simcall_BODY_mutex_unlock(smx_mutex_t mutex) {
1973 smx_process_t self = SIMIX_process_self();
1975 /* Go to that function to follow the code flow through the simcall barrier */
1976 if (0) simcall_HANDLER_mutex_unlock(&self->simcall, mutex);
1977 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1979 self->simcall.call = SIMCALL_MUTEX_UNLOCK;
1980 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1981 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1982 self->simcall.args[0].dp = (void*) mutex;
1983 if (self != simix_global->maestro_process) {
1984 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1985 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1986 SIMIX_process_yield(self);
1988 SIMIX_simcall_handle(&self->simcall, 0);
1993 inline static smx_cond_t simcall_BODY_cond_init() {
1994 smx_process_t self = SIMIX_process_self();
1996 /* Go to that function to follow the code flow through the simcall barrier */
1997 if (0) SIMIX_cond_init();
1998 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2000 self->simcall.call = SIMCALL_COND_INIT;
2001 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2002 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2004 if (self != simix_global->maestro_process) {
2005 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2006 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2007 SIMIX_process_yield(self);
2009 SIMIX_simcall_handle(&self->simcall, 0);
2011 return self->simcall.result.dp;
2014 inline static void simcall_BODY_cond_destroy(smx_cond_t cond) {
2015 smx_process_t self = SIMIX_process_self();
2017 /* Go to that function to follow the code flow through the simcall barrier */
2018 if (0) SIMIX_cond_destroy(cond);
2019 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2021 self->simcall.call = SIMCALL_COND_DESTROY;
2022 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2023 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2024 self->simcall.args[0].dp = (void*) cond;
2025 if (self != simix_global->maestro_process) {
2026 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2027 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2028 SIMIX_process_yield(self);
2030 SIMIX_simcall_handle(&self->simcall, 0);
2035 inline static void simcall_BODY_cond_signal(smx_cond_t cond) {
2036 smx_process_t self = SIMIX_process_self();
2038 /* Go to that function to follow the code flow through the simcall barrier */
2039 if (0) SIMIX_cond_signal(cond);
2040 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2042 self->simcall.call = SIMCALL_COND_SIGNAL;
2043 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2044 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2045 self->simcall.args[0].dp = (void*) cond;
2046 if (self != simix_global->maestro_process) {
2047 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2048 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2049 SIMIX_process_yield(self);
2051 SIMIX_simcall_handle(&self->simcall, 0);
2056 inline static void simcall_BODY_cond_wait(smx_cond_t cond, smx_mutex_t mutex) {
2057 smx_process_t self = SIMIX_process_self();
2059 /* Go to that function to follow the code flow through the simcall barrier */
2060 if (0) simcall_HANDLER_cond_wait(&self->simcall, cond, mutex);
2061 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2063 self->simcall.call = SIMCALL_COND_WAIT;
2064 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2065 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2066 self->simcall.args[0].dp = (void*) cond;
2067 self->simcall.args[1].dp = (void*) mutex;
2068 if (self != simix_global->maestro_process) {
2069 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2070 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2071 SIMIX_process_yield(self);
2073 SIMIX_simcall_handle(&self->simcall, 0);
2078 inline static void simcall_BODY_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double timeout) {
2079 smx_process_t self = SIMIX_process_self();
2081 /* Go to that function to follow the code flow through the simcall barrier */
2082 if (0) simcall_HANDLER_cond_wait_timeout(&self->simcall, cond, mutex, timeout);
2083 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2085 self->simcall.call = SIMCALL_COND_WAIT_TIMEOUT;
2086 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2087 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2088 self->simcall.args[0].dp = (void*) cond;
2089 self->simcall.args[1].dp = (void*) mutex;
2090 self->simcall.args[2].d = (double) timeout;
2091 if (self != simix_global->maestro_process) {
2092 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2093 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2094 SIMIX_process_yield(self);
2096 SIMIX_simcall_handle(&self->simcall, 0);
2101 inline static void simcall_BODY_cond_broadcast(smx_cond_t cond) {
2102 smx_process_t self = SIMIX_process_self();
2104 /* Go to that function to follow the code flow through the simcall barrier */
2105 if (0) SIMIX_cond_broadcast(cond);
2106 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2108 self->simcall.call = SIMCALL_COND_BROADCAST;
2109 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2110 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2111 self->simcall.args[0].dp = (void*) cond;
2112 if (self != simix_global->maestro_process) {
2113 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2114 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2115 SIMIX_process_yield(self);
2117 SIMIX_simcall_handle(&self->simcall, 0);
2122 inline static smx_sem_t simcall_BODY_sem_init(unsigned int capacity) {
2123 smx_process_t self = SIMIX_process_self();
2125 /* Go to that function to follow the code flow through the simcall barrier */
2126 if (0) SIMIX_sem_init(capacity);
2127 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2129 self->simcall.call = SIMCALL_SEM_INIT;
2130 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2131 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2132 self->simcall.args[0].ui = (unsigned int) capacity;
2133 if (self != simix_global->maestro_process) {
2134 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2135 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2136 SIMIX_process_yield(self);
2138 SIMIX_simcall_handle(&self->simcall, 0);
2140 return self->simcall.result.dp;
2143 inline static void simcall_BODY_sem_destroy(smx_sem_t sem) {
2144 smx_process_t self = SIMIX_process_self();
2146 /* Go to that function to follow the code flow through the simcall barrier */
2147 if (0) SIMIX_sem_destroy(sem);
2148 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2150 self->simcall.call = SIMCALL_SEM_DESTROY;
2151 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2152 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2153 self->simcall.args[0].dp = (void*) sem;
2154 if (self != simix_global->maestro_process) {
2155 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2156 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2157 SIMIX_process_yield(self);
2159 SIMIX_simcall_handle(&self->simcall, 0);
2164 inline static void simcall_BODY_sem_release(smx_sem_t sem) {
2165 smx_process_t self = SIMIX_process_self();
2167 /* Go to that function to follow the code flow through the simcall barrier */
2168 if (0) simcall_HANDLER_sem_release(&self->simcall, sem);
2169 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2171 self->simcall.call = SIMCALL_SEM_RELEASE;
2172 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2173 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2174 self->simcall.args[0].dp = (void*) sem;
2175 if (self != simix_global->maestro_process) {
2176 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2177 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2178 SIMIX_process_yield(self);
2180 SIMIX_simcall_handle(&self->simcall, 0);
2185 inline static int simcall_BODY_sem_would_block(smx_sem_t sem) {
2186 smx_process_t self = SIMIX_process_self();
2188 /* Go to that function to follow the code flow through the simcall barrier */
2189 if (0) simcall_HANDLER_sem_would_block(&self->simcall, sem);
2190 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2192 self->simcall.call = SIMCALL_SEM_WOULD_BLOCK;
2193 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2194 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2195 self->simcall.args[0].dp = (void*) sem;
2196 if (self != simix_global->maestro_process) {
2197 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2198 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2199 SIMIX_process_yield(self);
2201 SIMIX_simcall_handle(&self->simcall, 0);
2203 return self->simcall.result.i;
2206 inline static void simcall_BODY_sem_acquire(smx_sem_t sem) {
2207 smx_process_t self = SIMIX_process_self();
2209 /* Go to that function to follow the code flow through the simcall barrier */
2210 if (0) simcall_HANDLER_sem_acquire(&self->simcall, sem);
2211 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2213 self->simcall.call = SIMCALL_SEM_ACQUIRE;
2214 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2215 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2216 self->simcall.args[0].dp = (void*) sem;
2217 if (self != simix_global->maestro_process) {
2218 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2219 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2220 SIMIX_process_yield(self);
2222 SIMIX_simcall_handle(&self->simcall, 0);
2227 inline static void simcall_BODY_sem_acquire_timeout(smx_sem_t sem, double timeout) {
2228 smx_process_t self = SIMIX_process_self();
2230 /* Go to that function to follow the code flow through the simcall barrier */
2231 if (0) simcall_HANDLER_sem_acquire_timeout(&self->simcall, sem, timeout);
2232 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2234 self->simcall.call = SIMCALL_SEM_ACQUIRE_TIMEOUT;
2235 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2236 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2237 self->simcall.args[0].dp = (void*) sem;
2238 self->simcall.args[1].d = (double) timeout;
2239 if (self != simix_global->maestro_process) {
2240 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2241 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2242 SIMIX_process_yield(self);
2244 SIMIX_simcall_handle(&self->simcall, 0);
2249 inline static int simcall_BODY_sem_get_capacity(smx_sem_t sem) {
2250 smx_process_t self = SIMIX_process_self();
2252 /* Go to that function to follow the code flow through the simcall barrier */
2253 if (0) simcall_HANDLER_sem_get_capacity(&self->simcall, sem);
2254 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2256 self->simcall.call = SIMCALL_SEM_GET_CAPACITY;
2257 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2258 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2259 self->simcall.args[0].dp = (void*) sem;
2260 if (self != simix_global->maestro_process) {
2261 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2262 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2263 SIMIX_process_yield(self);
2265 SIMIX_simcall_handle(&self->simcall, 0);
2267 return self->simcall.result.i;
2270 inline static sg_size_t simcall_BODY_file_read(smx_file_t fd, sg_size_t size, sg_host_t host) {
2271 smx_process_t self = SIMIX_process_self();
2273 /* Go to that function to follow the code flow through the simcall barrier */
2274 if (0) simcall_HANDLER_file_read(&self->simcall, fd, size, host);
2275 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2277 self->simcall.call = SIMCALL_FILE_READ;
2278 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2279 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2280 self->simcall.args[0].dp = (void*) fd;
2281 self->simcall.args[1].sgsz = (sg_size_t) size;
2282 self->simcall.args[2].dp = (void*) host;
2283 if (self != simix_global->maestro_process) {
2284 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2285 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2286 SIMIX_process_yield(self);
2288 SIMIX_simcall_handle(&self->simcall, 0);
2290 return self->simcall.result.sgsz;
2293 inline static sg_size_t simcall_BODY_file_write(smx_file_t fd, sg_size_t size, sg_host_t host) {
2294 smx_process_t self = SIMIX_process_self();
2296 /* Go to that function to follow the code flow through the simcall barrier */
2297 if (0) simcall_HANDLER_file_write(&self->simcall, fd, size, host);
2298 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2300 self->simcall.call = SIMCALL_FILE_WRITE;
2301 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2302 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2303 self->simcall.args[0].dp = (void*) fd;
2304 self->simcall.args[1].sgsz = (sg_size_t) size;
2305 self->simcall.args[2].dp = (void*) host;
2306 if (self != simix_global->maestro_process) {
2307 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2308 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2309 SIMIX_process_yield(self);
2311 SIMIX_simcall_handle(&self->simcall, 0);
2313 return self->simcall.result.sgsz;
2316 inline static smx_file_t simcall_BODY_file_open(const char* fullpath, sg_host_t host) {
2317 smx_process_t self = SIMIX_process_self();
2319 /* Go to that function to follow the code flow through the simcall barrier */
2320 if (0) simcall_HANDLER_file_open(&self->simcall, fullpath, host);
2321 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2323 self->simcall.call = SIMCALL_FILE_OPEN;
2324 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2325 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2326 self->simcall.args[0].cc = (const char*) fullpath;
2327 self->simcall.args[1].dp = (void*) host;
2328 if (self != simix_global->maestro_process) {
2329 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2330 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2331 SIMIX_process_yield(self);
2333 SIMIX_simcall_handle(&self->simcall, 0);
2335 return self->simcall.result.dp;
2338 inline static int simcall_BODY_file_close(smx_file_t fd, sg_host_t host) {
2339 smx_process_t self = SIMIX_process_self();
2341 /* Go to that function to follow the code flow through the simcall barrier */
2342 if (0) simcall_HANDLER_file_close(&self->simcall, fd, host);
2343 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2345 self->simcall.call = SIMCALL_FILE_CLOSE;
2346 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2347 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2348 self->simcall.args[0].dp = (void*) fd;
2349 self->simcall.args[1].dp = (void*) host;
2350 if (self != simix_global->maestro_process) {
2351 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2352 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2353 SIMIX_process_yield(self);
2355 SIMIX_simcall_handle(&self->simcall, 0);
2357 return self->simcall.result.i;
2360 inline static int simcall_BODY_file_unlink(smx_file_t fd, sg_host_t host) {
2361 smx_process_t self = SIMIX_process_self();
2363 /* Go to that function to follow the code flow through the simcall barrier */
2364 if (0) SIMIX_file_unlink(fd, host);
2365 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2367 self->simcall.call = SIMCALL_FILE_UNLINK;
2368 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2369 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2370 self->simcall.args[0].dp = (void*) fd;
2371 self->simcall.args[1].dp = (void*) host;
2372 if (self != simix_global->maestro_process) {
2373 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2374 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2375 SIMIX_process_yield(self);
2377 SIMIX_simcall_handle(&self->simcall, 0);
2379 return self->simcall.result.i;
2382 inline static sg_size_t simcall_BODY_file_get_size(smx_file_t fd) {
2383 smx_process_t self = SIMIX_process_self();
2385 /* Go to that function to follow the code flow through the simcall barrier */
2386 if (0) simcall_HANDLER_file_get_size(&self->simcall, fd);
2387 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2389 self->simcall.call = SIMCALL_FILE_GET_SIZE;
2390 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2391 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2392 self->simcall.args[0].dp = (void*) fd;
2393 if (self != simix_global->maestro_process) {
2394 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2395 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2396 SIMIX_process_yield(self);
2398 SIMIX_simcall_handle(&self->simcall, 0);
2400 return self->simcall.result.sgsz;
2403 inline static sg_size_t simcall_BODY_file_tell(smx_file_t fd) {
2404 smx_process_t self = SIMIX_process_self();
2406 /* Go to that function to follow the code flow through the simcall barrier */
2407 if (0) simcall_HANDLER_file_tell(&self->simcall, fd);
2408 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2410 self->simcall.call = SIMCALL_FILE_TELL;
2411 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2412 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2413 self->simcall.args[0].dp = (void*) fd;
2414 if (self != simix_global->maestro_process) {
2415 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2416 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2417 SIMIX_process_yield(self);
2419 SIMIX_simcall_handle(&self->simcall, 0);
2421 return self->simcall.result.sgsz;
2424 inline static int simcall_BODY_file_seek(smx_file_t fd, sg_offset_t offset, int origin) {
2425 smx_process_t self = SIMIX_process_self();
2427 /* Go to that function to follow the code flow through the simcall barrier */
2428 if (0) simcall_HANDLER_file_seek(&self->simcall, fd, offset, origin);
2429 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2431 self->simcall.call = SIMCALL_FILE_SEEK;
2432 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2433 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2434 self->simcall.args[0].dp = (void*) fd;
2435 self->simcall.args[1].sgoff = (sg_offset_t) offset;
2436 self->simcall.args[2].i = (int) origin;
2437 if (self != simix_global->maestro_process) {
2438 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2439 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2440 SIMIX_process_yield(self);
2442 SIMIX_simcall_handle(&self->simcall, 0);
2444 return self->simcall.result.i;
2447 inline static xbt_dynar_t simcall_BODY_file_get_info(smx_file_t fd) {
2448 smx_process_t self = SIMIX_process_self();
2450 /* Go to that function to follow the code flow through the simcall barrier */
2451 if (0) simcall_HANDLER_file_get_info(&self->simcall, fd);
2452 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2454 self->simcall.call = SIMCALL_FILE_GET_INFO;
2455 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2456 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2457 self->simcall.args[0].dp = (void*) fd;
2458 if (self != simix_global->maestro_process) {
2459 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2460 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2461 SIMIX_process_yield(self);
2463 SIMIX_simcall_handle(&self->simcall, 0);
2465 return self->simcall.result.dp;
2468 inline static int simcall_BODY_file_move(smx_file_t fd, const char* fullpath) {
2469 smx_process_t self = SIMIX_process_self();
2471 /* Go to that function to follow the code flow through the simcall barrier */
2472 if (0) simcall_HANDLER_file_move(&self->simcall, fd, fullpath);
2473 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2475 self->simcall.call = SIMCALL_FILE_MOVE;
2476 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2477 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2478 self->simcall.args[0].dp = (void*) fd;
2479 self->simcall.args[1].cc = (const char*) fullpath;
2480 if (self != simix_global->maestro_process) {
2481 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2482 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2483 SIMIX_process_yield(self);
2485 SIMIX_simcall_handle(&self->simcall, 0);
2487 return self->simcall.result.i;
2490 inline static sg_size_t simcall_BODY_storage_get_free_size(smx_storage_t storage) {
2491 smx_process_t self = SIMIX_process_self();
2493 /* Go to that function to follow the code flow through the simcall barrier */
2494 if (0) simcall_HANDLER_storage_get_free_size(&self->simcall, storage);
2495 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2497 self->simcall.call = SIMCALL_STORAGE_GET_FREE_SIZE;
2498 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2499 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2500 self->simcall.args[0].dp = (void*) storage;
2501 if (self != simix_global->maestro_process) {
2502 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2503 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2504 SIMIX_process_yield(self);
2506 SIMIX_simcall_handle(&self->simcall, 0);
2508 return self->simcall.result.sgsz;
2511 inline static sg_size_t simcall_BODY_storage_get_used_size(smx_storage_t name) {
2512 smx_process_t self = SIMIX_process_self();
2514 /* Go to that function to follow the code flow through the simcall barrier */
2515 if (0) simcall_HANDLER_storage_get_used_size(&self->simcall, name);
2516 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2518 self->simcall.call = SIMCALL_STORAGE_GET_USED_SIZE;
2519 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2520 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2521 self->simcall.args[0].dp = (void*) name;
2522 if (self != simix_global->maestro_process) {
2523 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2524 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2525 SIMIX_process_yield(self);
2527 SIMIX_simcall_handle(&self->simcall, 0);
2529 return self->simcall.result.sgsz;
2532 inline static xbt_dict_t simcall_BODY_storage_get_properties(smx_storage_t storage) {
2533 smx_process_t self = SIMIX_process_self();
2535 /* Go to that function to follow the code flow through the simcall barrier */
2536 if (0) SIMIX_storage_get_properties(storage);
2537 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2539 self->simcall.call = SIMCALL_STORAGE_GET_PROPERTIES;
2540 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2541 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2542 self->simcall.args[0].dp = (void*) storage;
2543 if (self != simix_global->maestro_process) {
2544 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2545 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2546 SIMIX_process_yield(self);
2548 SIMIX_simcall_handle(&self->simcall, 0);
2550 return self->simcall.result.dp;
2553 inline static xbt_dict_t simcall_BODY_storage_get_content(smx_storage_t storage) {
2554 smx_process_t self = SIMIX_process_self();
2556 /* Go to that function to follow the code flow through the simcall barrier */
2557 if (0) SIMIX_storage_get_content(storage);
2558 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2560 self->simcall.call = SIMCALL_STORAGE_GET_CONTENT;
2561 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2562 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2563 self->simcall.args[0].dp = (void*) storage;
2564 if (self != simix_global->maestro_process) {
2565 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2566 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2567 SIMIX_process_yield(self);
2569 SIMIX_simcall_handle(&self->simcall, 0);
2571 return self->simcall.result.dp;
2574 inline static xbt_dict_t simcall_BODY_asr_get_properties(const char* name) {
2575 smx_process_t self = SIMIX_process_self();
2577 /* Go to that function to follow the code flow through the simcall barrier */
2578 if (0) simcall_HANDLER_asr_get_properties(&self->simcall, name);
2579 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2581 self->simcall.call = SIMCALL_ASR_GET_PROPERTIES;
2582 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2583 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2584 self->simcall.args[0].cc = (const char*) name;
2585 if (self != simix_global->maestro_process) {
2586 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2587 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2588 SIMIX_process_yield(self);
2590 SIMIX_simcall_handle(&self->simcall, 0);
2592 return self->simcall.result.dp;
2595 inline static int simcall_BODY_mc_random(int min, int max) {
2596 smx_process_t self = SIMIX_process_self();
2598 /* Go to that function to follow the code flow through the simcall barrier */
2599 if (0) simcall_HANDLER_mc_random(&self->simcall, min, max);
2600 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2602 self->simcall.call = SIMCALL_MC_RANDOM;
2603 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2604 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2605 self->simcall.args[0].i = (int) min;
2606 self->simcall.args[1].i = (int) max;
2607 if (self != simix_global->maestro_process) {
2608 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2609 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2610 SIMIX_process_yield(self);
2612 SIMIX_simcall_handle(&self->simcall, 0);
2614 return self->simcall.result.i;
2617 inline static void simcall_BODY_set_category(smx_synchro_t synchro, const char* category) {
2618 smx_process_t self = SIMIX_process_self();
2620 /* Go to that function to follow the code flow through the simcall barrier */
2621 if (0) SIMIX_set_category(synchro, category);
2622 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2624 self->simcall.call = SIMCALL_SET_CATEGORY;
2625 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2626 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2627 self->simcall.args[0].dp = (void*) synchro;
2628 self->simcall.args[1].cc = (const char*) category;
2629 if (self != simix_global->maestro_process) {
2630 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2631 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2632 SIMIX_process_yield(self);
2634 SIMIX_simcall_handle(&self->simcall, 0);
2638 #ifdef HAVE_LATENCY_BOUND_TRACKING
2640 inline static int simcall_BODY_comm_is_latency_bounded(smx_synchro_t comm) {
2641 smx_process_t self = SIMIX_process_self();
2643 /* Go to that function to follow the code flow through the simcall barrier */
2644 if (0) SIMIX_comm_is_latency_bounded(comm);
2645 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2647 self->simcall.call = SIMCALL_COMM_IS_LATENCY_BOUNDED;
2648 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2649 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2650 self->simcall.args[0].dp = (void*) comm;
2651 if (self != simix_global->maestro_process) {
2652 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2653 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2654 SIMIX_process_yield(self);
2656 SIMIX_simcall_handle(&self->simcall, 0);
2658 return self->simcall.result.i;
2664 inline static mc_snapshot_t simcall_BODY_mc_snapshot() {
2665 smx_process_t self = SIMIX_process_self();
2667 /* Go to that function to follow the code flow through the simcall barrier */
2668 if (0) simcall_HANDLER_mc_snapshot(&self->simcall);
2669 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2671 self->simcall.call = SIMCALL_MC_SNAPSHOT;
2672 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2673 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2675 if (self != simix_global->maestro_process) {
2676 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2677 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2678 SIMIX_process_yield(self);
2680 SIMIX_simcall_handle(&self->simcall, 0);
2682 return self->simcall.result.dp;
2685 inline static int simcall_BODY_mc_compare_snapshots(mc_snapshot_t s1, mc_snapshot_t s2) {
2686 smx_process_t self = SIMIX_process_self();
2688 /* Go to that function to follow the code flow through the simcall barrier */
2689 if (0) simcall_HANDLER_mc_compare_snapshots(&self->simcall, s1, s2);
2690 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
2692 self->simcall.call = SIMCALL_MC_COMPARE_SNAPSHOTS;
2693 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
2694 memset(self->simcall.args, 0, sizeof(self->simcall.args));
2695 self->simcall.args[0].dp = (void*) s1;
2696 self->simcall.args[1].dp = (void*) s2;
2697 if (self != simix_global->maestro_process) {
2698 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
2699 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
2700 SIMIX_process_yield(self);
2702 SIMIX_simcall_handle(&self->simcall, 0);
2704 return self->simcall.result.i;