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.hpp"
19 #include <simgrid/simix.hpp>
21 inline static void simcall_BODY_vm_suspend(sg_host_t ind_vm) {
22 smx_process_t self = SIMIX_process_self();
24 /* Go to that function to follow the code flow through the simcall barrier */
25 if (0) simcall_HANDLER_vm_suspend(&self->simcall, ind_vm);
26 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
28 self->simcall.call = SIMCALL_VM_SUSPEND;
29 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
30 memset(self->simcall.args, 0, sizeof(self->simcall.args));
31 self->simcall.args[0].dp = (void*) ind_vm;
32 if (self != simix_global->maestro_process) {
33 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
34 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
35 SIMIX_process_yield(self);
37 SIMIX_simcall_handle(&self->simcall, 0);
42 inline static void simcall_BODY_vm_resume(sg_host_t ind_vm) {
43 smx_process_t self = SIMIX_process_self();
45 /* Go to that function to follow the code flow through the simcall barrier */
46 if (0) simcall_HANDLER_vm_resume(&self->simcall, ind_vm);
47 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
49 self->simcall.call = SIMCALL_VM_RESUME;
50 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
51 memset(self->simcall.args, 0, sizeof(self->simcall.args));
52 self->simcall.args[0].dp = (void*) ind_vm;
53 if (self != simix_global->maestro_process) {
54 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
55 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
56 SIMIX_process_yield(self);
58 SIMIX_simcall_handle(&self->simcall, 0);
63 inline static void simcall_BODY_vm_shutdown(sg_host_t ind_vm) {
64 smx_process_t self = SIMIX_process_self();
66 /* Go to that function to follow the code flow through the simcall barrier */
67 if (0) simcall_HANDLER_vm_shutdown(&self->simcall, ind_vm);
68 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
70 self->simcall.call = SIMCALL_VM_SHUTDOWN;
71 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
72 memset(self->simcall.args, 0, sizeof(self->simcall.args));
73 self->simcall.args[0].dp = (void*) ind_vm;
74 if (self != simix_global->maestro_process) {
75 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
76 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
77 SIMIX_process_yield(self);
79 SIMIX_simcall_handle(&self->simcall, 0);
84 inline static void simcall_BODY_vm_save(sg_host_t ind_vm) {
85 smx_process_t self = SIMIX_process_self();
87 /* Go to that function to follow the code flow through the simcall barrier */
88 if (0) simcall_HANDLER_vm_save(&self->simcall, ind_vm);
89 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
91 self->simcall.call = SIMCALL_VM_SAVE;
92 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
93 memset(self->simcall.args, 0, sizeof(self->simcall.args));
94 self->simcall.args[0].dp = (void*) ind_vm;
95 if (self != simix_global->maestro_process) {
96 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
97 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
98 SIMIX_process_yield(self);
100 SIMIX_simcall_handle(&self->simcall, 0);
105 inline static void simcall_BODY_vm_restore(sg_host_t ind_vm) {
106 smx_process_t self = SIMIX_process_self();
108 /* Go to that function to follow the code flow through the simcall barrier */
109 if (0) simcall_HANDLER_vm_restore(&self->simcall, ind_vm);
110 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
112 self->simcall.call = SIMCALL_VM_RESTORE;
113 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
114 memset(self->simcall.args, 0, sizeof(self->simcall.args));
115 self->simcall.args[0].dp = (void*) ind_vm;
116 if (self != simix_global->maestro_process) {
117 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
118 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
119 SIMIX_process_yield(self);
121 SIMIX_simcall_handle(&self->simcall, 0);
126 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) {
127 smx_process_t self = SIMIX_process_self();
129 /* Go to that function to follow the code flow through the simcall barrier */
130 if (0) simcall_HANDLER_process_create(&self->simcall, name, code, data, hostname, kill_time, argc, argv, properties, auto_restart);
131 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
133 self->simcall.call = SIMCALL_PROCESS_CREATE;
134 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
135 memset(self->simcall.args, 0, sizeof(self->simcall.args));
136 self->simcall.args[0].cc = (const char*) name;
137 self->simcall.args[1].fp = (FPtr) code;
138 self->simcall.args[2].dp = (void*) data;
139 self->simcall.args[3].cc = (const char*) hostname;
140 self->simcall.args[4].d = (double) kill_time;
141 self->simcall.args[5].i = (int) argc;
142 self->simcall.args[6].dp = (void*) argv;
143 self->simcall.args[7].dp = (void*) properties;
144 self->simcall.args[8].i = (int) auto_restart;
145 if (self != simix_global->maestro_process) {
146 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
147 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
148 SIMIX_process_yield(self);
150 SIMIX_simcall_handle(&self->simcall, 0);
152 return (void*) self->simcall.result.dp;
155 inline static void simcall_BODY_process_kill(smx_process_t process) {
156 smx_process_t self = SIMIX_process_self();
158 /* Go to that function to follow the code flow through the simcall barrier */
159 if (0) simcall_HANDLER_process_kill(&self->simcall, process);
160 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
162 self->simcall.call = SIMCALL_PROCESS_KILL;
163 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
164 memset(self->simcall.args, 0, sizeof(self->simcall.args));
165 self->simcall.args[0].dp = (void*) process;
166 if (self != simix_global->maestro_process) {
167 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
168 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
169 SIMIX_process_yield(self);
171 SIMIX_simcall_handle(&self->simcall, 0);
176 inline static void simcall_BODY_process_killall(int reset_pid) {
177 smx_process_t self = SIMIX_process_self();
179 /* Go to that function to follow the code flow through the simcall barrier */
180 if (0) simcall_HANDLER_process_killall(&self->simcall, reset_pid);
181 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
183 self->simcall.call = SIMCALL_PROCESS_KILLALL;
184 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
185 memset(self->simcall.args, 0, sizeof(self->simcall.args));
186 self->simcall.args[0].i = (int) reset_pid;
187 if (self != simix_global->maestro_process) {
188 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
189 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
190 SIMIX_process_yield(self);
192 SIMIX_simcall_handle(&self->simcall, 0);
197 inline static void simcall_BODY_process_cleanup(smx_process_t process) {
198 smx_process_t self = SIMIX_process_self();
200 /* Go to that function to follow the code flow through the simcall barrier */
201 if (0) SIMIX_process_cleanup(process);
202 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
204 self->simcall.call = SIMCALL_PROCESS_CLEANUP;
205 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
206 memset(self->simcall.args, 0, sizeof(self->simcall.args));
207 self->simcall.args[0].dp = (void*) process;
208 if (self != simix_global->maestro_process) {
209 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
210 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
211 SIMIX_process_yield(self);
213 SIMIX_simcall_handle(&self->simcall, 0);
218 inline static void simcall_BODY_process_suspend(smx_process_t process) {
219 smx_process_t self = SIMIX_process_self();
221 /* Go to that function to follow the code flow through the simcall barrier */
222 if (0) simcall_HANDLER_process_suspend(&self->simcall, process);
223 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
225 self->simcall.call = SIMCALL_PROCESS_SUSPEND;
226 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
227 memset(self->simcall.args, 0, sizeof(self->simcall.args));
228 self->simcall.args[0].dp = (void*) process;
229 if (self != simix_global->maestro_process) {
230 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
231 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
232 SIMIX_process_yield(self);
234 SIMIX_simcall_handle(&self->simcall, 0);
239 inline static void simcall_BODY_process_resume(smx_process_t process) {
240 smx_process_t self = SIMIX_process_self();
242 /* Go to that function to follow the code flow through the simcall barrier */
243 if (0) simcall_HANDLER_process_resume(&self->simcall, process);
244 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
246 self->simcall.call = SIMCALL_PROCESS_RESUME;
247 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
248 memset(self->simcall.args, 0, sizeof(self->simcall.args));
249 self->simcall.args[0].dp = (void*) process;
250 if (self != simix_global->maestro_process) {
251 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
252 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
253 SIMIX_process_yield(self);
255 SIMIX_simcall_handle(&self->simcall, 0);
260 inline static void simcall_BODY_process_set_host(smx_process_t process, sg_host_t dest) {
261 smx_process_t self = SIMIX_process_self();
263 /* Go to that function to follow the code flow through the simcall barrier */
264 if (0) simcall_HANDLER_process_set_host(&self->simcall, process, dest);
265 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
267 self->simcall.call = SIMCALL_PROCESS_SET_HOST;
268 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
269 memset(self->simcall.args, 0, sizeof(self->simcall.args));
270 self->simcall.args[0].dp = (void*) process;
271 self->simcall.args[1].dp = (void*) dest;
272 if (self != simix_global->maestro_process) {
273 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
274 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
275 SIMIX_process_yield(self);
277 SIMIX_simcall_handle(&self->simcall, 0);
282 inline static int simcall_BODY_process_is_suspended(smx_process_t process) {
283 smx_process_t self = SIMIX_process_self();
285 /* Go to that function to follow the code flow through the simcall barrier */
286 if (0) SIMIX_process_is_suspended(process);
287 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
289 self->simcall.call = SIMCALL_PROCESS_IS_SUSPENDED;
290 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
291 memset(self->simcall.args, 0, sizeof(self->simcall.args));
292 self->simcall.args[0].dp = (void*) process;
293 if (self != simix_global->maestro_process) {
294 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
295 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
296 SIMIX_process_yield(self);
298 SIMIX_simcall_handle(&self->simcall, 0);
300 return (int) self->simcall.result.i;
303 inline static int simcall_BODY_process_join(smx_process_t process, double timeout) {
304 smx_process_t self = SIMIX_process_self();
306 /* Go to that function to follow the code flow through the simcall barrier */
307 if (0) simcall_HANDLER_process_join(&self->simcall, process, timeout);
308 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
310 self->simcall.call = SIMCALL_PROCESS_JOIN;
311 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
312 memset(self->simcall.args, 0, sizeof(self->simcall.args));
313 self->simcall.args[0].dp = (void*) process;
314 self->simcall.args[1].d = (double) timeout;
315 if (self != simix_global->maestro_process) {
316 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
317 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
318 SIMIX_process_yield(self);
320 SIMIX_simcall_handle(&self->simcall, 0);
322 return (int) self->simcall.result.i;
325 inline static int simcall_BODY_process_sleep(double duration) {
326 smx_process_t self = SIMIX_process_self();
328 /* Go to that function to follow the code flow through the simcall barrier */
329 if (0) simcall_HANDLER_process_sleep(&self->simcall, duration);
330 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
332 self->simcall.call = SIMCALL_PROCESS_SLEEP;
333 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
334 memset(self->simcall.args, 0, sizeof(self->simcall.args));
335 self->simcall.args[0].d = (double) duration;
336 if (self != simix_global->maestro_process) {
337 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
338 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
339 SIMIX_process_yield(self);
341 SIMIX_simcall_handle(&self->simcall, 0);
343 return (int) self->simcall.result.i;
346 inline static smx_synchro_t simcall_BODY_execution_start(const char* name, double flops_amount, double priority, double bound, unsigned long affinity_mask) {
347 smx_process_t self = SIMIX_process_self();
349 /* Go to that function to follow the code flow through the simcall barrier */
350 if (0) simcall_HANDLER_execution_start(&self->simcall, name, flops_amount, priority, bound, affinity_mask);
351 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
353 self->simcall.call = SIMCALL_EXECUTION_START;
354 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
355 memset(self->simcall.args, 0, sizeof(self->simcall.args));
356 self->simcall.args[0].cc = (const char*) name;
357 self->simcall.args[1].d = (double) flops_amount;
358 self->simcall.args[2].d = (double) priority;
359 self->simcall.args[3].d = (double) bound;
360 self->simcall.args[4].ul = (unsigned long) affinity_mask;
361 if (self != simix_global->maestro_process) {
362 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
363 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
364 SIMIX_process_yield(self);
366 SIMIX_simcall_handle(&self->simcall, 0);
368 return (smx_synchro_t) self->simcall.result.dp;
371 inline static smx_synchro_t simcall_BODY_execution_parallel_start(const char* name, int host_nb, sg_host_t* host_list, double* flops_amount, double* bytes_amount, double amount, double rate) {
372 smx_process_t self = SIMIX_process_self();
374 /* Go to that function to follow the code flow through the simcall barrier */
375 if (0) SIMIX_execution_parallel_start(name, host_nb, host_list, flops_amount, bytes_amount, amount, rate);
376 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
378 self->simcall.call = SIMCALL_EXECUTION_PARALLEL_START;
379 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
380 memset(self->simcall.args, 0, sizeof(self->simcall.args));
381 self->simcall.args[0].cc = (const char*) name;
382 self->simcall.args[1].i = (int) host_nb;
383 self->simcall.args[2].dp = (void*) host_list;
384 self->simcall.args[3].dp = (void*) flops_amount;
385 self->simcall.args[4].dp = (void*) bytes_amount;
386 self->simcall.args[5].d = (double) amount;
387 self->simcall.args[6].d = (double) rate;
388 if (self != simix_global->maestro_process) {
389 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
390 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
391 SIMIX_process_yield(self);
393 SIMIX_simcall_handle(&self->simcall, 0);
395 return (smx_synchro_t) self->simcall.result.dp;
398 inline static void simcall_BODY_execution_destroy(smx_synchro_t execution) {
399 smx_process_t self = SIMIX_process_self();
401 /* Go to that function to follow the code flow through the simcall barrier */
402 if (0) SIMIX_execution_destroy(execution);
403 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
405 self->simcall.call = SIMCALL_EXECUTION_DESTROY;
406 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
407 memset(self->simcall.args, 0, sizeof(self->simcall.args));
408 self->simcall.args[0].dp = (void*) execution;
409 if (self != simix_global->maestro_process) {
410 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
411 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
412 SIMIX_process_yield(self);
414 SIMIX_simcall_handle(&self->simcall, 0);
419 inline static void simcall_BODY_execution_cancel(smx_synchro_t execution) {
420 smx_process_t self = SIMIX_process_self();
422 /* Go to that function to follow the code flow through the simcall barrier */
423 if (0) SIMIX_execution_cancel(execution);
424 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
426 self->simcall.call = SIMCALL_EXECUTION_CANCEL;
427 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
428 memset(self->simcall.args, 0, sizeof(self->simcall.args));
429 self->simcall.args[0].dp = (void*) execution;
430 if (self != simix_global->maestro_process) {
431 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
432 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
433 SIMIX_process_yield(self);
435 SIMIX_simcall_handle(&self->simcall, 0);
440 inline static void simcall_BODY_execution_set_priority(smx_synchro_t execution, double priority) {
441 smx_process_t self = SIMIX_process_self();
443 /* Go to that function to follow the code flow through the simcall barrier */
444 if (0) SIMIX_execution_set_priority(execution, priority);
445 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
447 self->simcall.call = SIMCALL_EXECUTION_SET_PRIORITY;
448 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
449 memset(self->simcall.args, 0, sizeof(self->simcall.args));
450 self->simcall.args[0].dp = (void*) execution;
451 self->simcall.args[1].d = (double) priority;
452 if (self != simix_global->maestro_process) {
453 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
454 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
455 SIMIX_process_yield(self);
457 SIMIX_simcall_handle(&self->simcall, 0);
462 inline static void simcall_BODY_execution_set_bound(smx_synchro_t execution, double bound) {
463 smx_process_t self = SIMIX_process_self();
465 /* Go to that function to follow the code flow through the simcall barrier */
466 if (0) SIMIX_execution_set_bound(execution, bound);
467 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
469 self->simcall.call = SIMCALL_EXECUTION_SET_BOUND;
470 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
471 memset(self->simcall.args, 0, sizeof(self->simcall.args));
472 self->simcall.args[0].dp = (void*) execution;
473 self->simcall.args[1].d = (double) bound;
474 if (self != simix_global->maestro_process) {
475 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
476 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
477 SIMIX_process_yield(self);
479 SIMIX_simcall_handle(&self->simcall, 0);
484 inline static void simcall_BODY_execution_set_affinity(smx_synchro_t execution, sg_host_t ws, unsigned long mask) {
485 smx_process_t self = SIMIX_process_self();
487 /* Go to that function to follow the code flow through the simcall barrier */
488 if (0) SIMIX_execution_set_affinity(execution, ws, mask);
489 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
491 self->simcall.call = SIMCALL_EXECUTION_SET_AFFINITY;
492 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
493 memset(self->simcall.args, 0, sizeof(self->simcall.args));
494 self->simcall.args[0].dp = (void*) execution;
495 self->simcall.args[1].dp = (void*) ws;
496 self->simcall.args[2].ul = (unsigned long) mask;
497 if (self != simix_global->maestro_process) {
498 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
499 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
500 SIMIX_process_yield(self);
502 SIMIX_simcall_handle(&self->simcall, 0);
507 inline static int simcall_BODY_execution_wait(smx_synchro_t execution) {
508 smx_process_t self = SIMIX_process_self();
510 /* Go to that function to follow the code flow through the simcall barrier */
511 if (0) simcall_HANDLER_execution_wait(&self->simcall, execution);
512 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
514 self->simcall.call = SIMCALL_EXECUTION_WAIT;
515 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
516 memset(self->simcall.args, 0, sizeof(self->simcall.args));
517 self->simcall.args[0].dp = (void*) execution;
518 if (self != simix_global->maestro_process) {
519 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
520 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
521 SIMIX_process_yield(self);
523 SIMIX_simcall_handle(&self->simcall, 0);
525 return (int) self->simcall.result.i;
528 inline static void simcall_BODY_process_on_exit(smx_process_t process, int_f_pvoid_pvoid_t fun, void* data) {
529 smx_process_t self = SIMIX_process_self();
531 /* Go to that function to follow the code flow through the simcall barrier */
532 if (0) SIMIX_process_on_exit(process, fun, data);
533 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
535 self->simcall.call = SIMCALL_PROCESS_ON_EXIT;
536 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
537 memset(self->simcall.args, 0, sizeof(self->simcall.args));
538 self->simcall.args[0].dp = (void*) process;
539 self->simcall.args[1].fp = (FPtr) fun;
540 self->simcall.args[2].dp = (void*) data;
541 if (self != simix_global->maestro_process) {
542 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
543 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
544 SIMIX_process_yield(self);
546 SIMIX_simcall_handle(&self->simcall, 0);
551 inline static void simcall_BODY_process_auto_restart_set(smx_process_t process, int auto_restart) {
552 smx_process_t self = SIMIX_process_self();
554 /* Go to that function to follow the code flow through the simcall barrier */
555 if (0) SIMIX_process_auto_restart_set(process, auto_restart);
556 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
558 self->simcall.call = SIMCALL_PROCESS_AUTO_RESTART_SET;
559 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
560 memset(self->simcall.args, 0, sizeof(self->simcall.args));
561 self->simcall.args[0].dp = (void*) process;
562 self->simcall.args[1].i = (int) auto_restart;
563 if (self != simix_global->maestro_process) {
564 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
565 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
566 SIMIX_process_yield(self);
568 SIMIX_simcall_handle(&self->simcall, 0);
573 inline static smx_process_t simcall_BODY_process_restart(smx_process_t process) {
574 smx_process_t self = SIMIX_process_self();
576 /* Go to that function to follow the code flow through the simcall barrier */
577 if (0) simcall_HANDLER_process_restart(&self->simcall, process);
578 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
580 self->simcall.call = SIMCALL_PROCESS_RESTART;
581 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
582 memset(self->simcall.args, 0, sizeof(self->simcall.args));
583 self->simcall.args[0].dp = (void*) process;
584 if (self != simix_global->maestro_process) {
585 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
586 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
587 SIMIX_process_yield(self);
589 SIMIX_simcall_handle(&self->simcall, 0);
591 return (smx_process_t) self->simcall.result.dp;
594 inline static smx_mailbox_t simcall_BODY_mbox_create(const char* name) {
595 smx_process_t self = SIMIX_process_self();
597 /* Go to that function to follow the code flow through the simcall barrier */
598 if (0) SIMIX_mbox_create(name);
599 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
601 self->simcall.call = SIMCALL_MBOX_CREATE;
602 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
603 memset(self->simcall.args, 0, sizeof(self->simcall.args));
604 self->simcall.args[0].cc = (const char*) name;
605 if (self != simix_global->maestro_process) {
606 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
607 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
608 SIMIX_process_yield(self);
610 SIMIX_simcall_handle(&self->simcall, 0);
612 return (smx_mailbox_t) self->simcall.result.dp;
615 inline static void simcall_BODY_mbox_set_receiver(smx_mailbox_t mbox, smx_process_t receiver) {
616 smx_process_t self = SIMIX_process_self();
618 /* Go to that function to follow the code flow through the simcall barrier */
619 if (0) SIMIX_mbox_set_receiver(mbox, receiver);
620 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
622 self->simcall.call = SIMCALL_MBOX_SET_RECEIVER;
623 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
624 memset(self->simcall.args, 0, sizeof(self->simcall.args));
625 self->simcall.args[0].dp = (void*) mbox;
626 self->simcall.args[1].dp = (void*) receiver;
627 if (self != simix_global->maestro_process) {
628 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
629 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
630 SIMIX_process_yield(self);
632 SIMIX_simcall_handle(&self->simcall, 0);
637 inline static smx_synchro_t simcall_BODY_comm_iprobe(smx_mailbox_t mbox, int type, int src, int tag, simix_match_func_t match_fun, void* data) {
638 smx_process_t self = SIMIX_process_self();
640 /* Go to that function to follow the code flow through the simcall barrier */
641 if (0) simcall_HANDLER_comm_iprobe(&self->simcall, mbox, type, src, tag, match_fun, data);
642 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
644 self->simcall.call = SIMCALL_COMM_IPROBE;
645 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
646 memset(self->simcall.args, 0, sizeof(self->simcall.args));
647 self->simcall.args[0].dp = (void*) mbox;
648 self->simcall.args[1].i = (int) type;
649 self->simcall.args[2].i = (int) src;
650 self->simcall.args[3].i = (int) tag;
651 self->simcall.args[4].fp = (FPtr) match_fun;
652 self->simcall.args[5].dp = (void*) data;
653 if (self != simix_global->maestro_process) {
654 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
655 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
656 SIMIX_process_yield(self);
658 SIMIX_simcall_handle(&self->simcall, 0);
660 return (smx_synchro_t) self->simcall.result.dp;
663 inline static void simcall_BODY_comm_send(smx_process_t sender, smx_mailbox_t mbox, 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) {
664 smx_process_t self = SIMIX_process_self();
666 /* Go to that function to follow the code flow through the simcall barrier */
667 if (0) simcall_HANDLER_comm_send(&self->simcall, sender, mbox, task_size, rate, src_buff, src_buff_size, match_fun, copy_data_fun, data, timeout);
668 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
670 self->simcall.call = SIMCALL_COMM_SEND;
671 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
672 memset(self->simcall.args, 0, sizeof(self->simcall.args));
673 self->simcall.args[0].dp = (void*) sender;
674 self->simcall.args[1].dp = (void*) mbox;
675 self->simcall.args[2].d = (double) task_size;
676 self->simcall.args[3].d = (double) rate;
677 self->simcall.args[4].dp = (void*) src_buff;
678 self->simcall.args[5].sz = (size_t) src_buff_size;
679 self->simcall.args[6].fp = (FPtr) match_fun;
680 self->simcall.args[7].fp = (FPtr) copy_data_fun;
681 self->simcall.args[8].dp = (void*) data;
682 self->simcall.args[9].d = (double) timeout;
683 if (self != simix_global->maestro_process) {
684 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
685 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
686 SIMIX_process_yield(self);
688 SIMIX_simcall_handle(&self->simcall, 0);
693 inline static smx_synchro_t simcall_BODY_comm_isend(smx_process_t sender, smx_mailbox_t mbox, 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) {
694 smx_process_t self = SIMIX_process_self();
696 /* Go to that function to follow the code flow through the simcall barrier */
697 if (0) simcall_HANDLER_comm_isend(&self->simcall, sender, mbox, task_size, rate, src_buff, src_buff_size, match_fun, clean_fun, copy_data_fun, data, detached);
698 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
700 self->simcall.call = SIMCALL_COMM_ISEND;
701 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
702 memset(self->simcall.args, 0, sizeof(self->simcall.args));
703 self->simcall.args[0].dp = (void*) sender;
704 self->simcall.args[1].dp = (void*) mbox;
705 self->simcall.args[2].d = (double) task_size;
706 self->simcall.args[3].d = (double) rate;
707 self->simcall.args[4].dp = (void*) src_buff;
708 self->simcall.args[5].sz = (size_t) src_buff_size;
709 self->simcall.args[6].fp = (FPtr) match_fun;
710 self->simcall.args[7].fp = (FPtr) clean_fun;
711 self->simcall.args[8].fp = (FPtr) copy_data_fun;
712 self->simcall.args[9].dp = (void*) data;
713 self->simcall.args[10].i = (int) detached;
714 if (self != simix_global->maestro_process) {
715 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
716 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
717 SIMIX_process_yield(self);
719 SIMIX_simcall_handle(&self->simcall, 0);
721 return (smx_synchro_t) self->simcall.result.dp;
724 inline static void simcall_BODY_comm_recv(smx_process_t receiver, smx_mailbox_t mbox, 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) {
725 smx_process_t self = SIMIX_process_self();
727 /* Go to that function to follow the code flow through the simcall barrier */
728 if (0) simcall_HANDLER_comm_recv(&self->simcall, receiver, mbox, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, timeout, rate);
729 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
731 self->simcall.call = SIMCALL_COMM_RECV;
732 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
733 memset(self->simcall.args, 0, sizeof(self->simcall.args));
734 self->simcall.args[0].dp = (void*) receiver;
735 self->simcall.args[1].dp = (void*) mbox;
736 self->simcall.args[2].dp = (void*) dst_buff;
737 self->simcall.args[3].dp = (void*) dst_buff_size;
738 self->simcall.args[4].fp = (FPtr) match_fun;
739 self->simcall.args[5].fp = (FPtr) copy_data_fun;
740 self->simcall.args[6].dp = (void*) data;
741 self->simcall.args[7].d = (double) timeout;
742 self->simcall.args[8].d = (double) rate;
743 if (self != simix_global->maestro_process) {
744 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
745 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
746 SIMIX_process_yield(self);
748 SIMIX_simcall_handle(&self->simcall, 0);
753 inline static smx_synchro_t simcall_BODY_comm_irecv(smx_process_t receiver, smx_mailbox_t mbox, 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) {
754 smx_process_t self = SIMIX_process_self();
756 /* Go to that function to follow the code flow through the simcall barrier */
757 if (0) simcall_HANDLER_comm_irecv(&self->simcall, receiver, mbox, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, rate);
758 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
760 self->simcall.call = SIMCALL_COMM_IRECV;
761 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
762 memset(self->simcall.args, 0, sizeof(self->simcall.args));
763 self->simcall.args[0].dp = (void*) receiver;
764 self->simcall.args[1].dp = (void*) mbox;
765 self->simcall.args[2].dp = (void*) dst_buff;
766 self->simcall.args[3].dp = (void*) dst_buff_size;
767 self->simcall.args[4].fp = (FPtr) match_fun;
768 self->simcall.args[5].fp = (FPtr) copy_data_fun;
769 self->simcall.args[6].dp = (void*) data;
770 self->simcall.args[7].d = (double) rate;
771 if (self != simix_global->maestro_process) {
772 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
773 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
774 SIMIX_process_yield(self);
776 SIMIX_simcall_handle(&self->simcall, 0);
778 return (smx_synchro_t) self->simcall.result.dp;
781 inline static int simcall_BODY_comm_waitany(xbt_dynar_t comms) {
782 smx_process_t self = SIMIX_process_self();
784 /* Go to that function to follow the code flow through the simcall barrier */
785 if (0) simcall_HANDLER_comm_waitany(&self->simcall, comms);
786 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
788 self->simcall.call = SIMCALL_COMM_WAITANY;
789 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
790 memset(self->simcall.args, 0, sizeof(self->simcall.args));
791 self->simcall.args[0].dp = (void*) comms;
792 if (self != simix_global->maestro_process) {
793 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
794 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
795 SIMIX_process_yield(self);
797 SIMIX_simcall_handle(&self->simcall, 0);
799 return (int) self->simcall.result.i;
802 inline static void simcall_BODY_comm_wait(smx_synchro_t comm, double timeout) {
803 smx_process_t self = SIMIX_process_self();
805 /* Go to that function to follow the code flow through the simcall barrier */
806 if (0) simcall_HANDLER_comm_wait(&self->simcall, comm, timeout);
807 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
809 self->simcall.call = SIMCALL_COMM_WAIT;
810 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
811 memset(self->simcall.args, 0, sizeof(self->simcall.args));
812 self->simcall.args[0].dp = (void*) comm;
813 self->simcall.args[1].d = (double) timeout;
814 if (self != simix_global->maestro_process) {
815 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
816 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
817 SIMIX_process_yield(self);
819 SIMIX_simcall_handle(&self->simcall, 0);
824 inline static int simcall_BODY_comm_test(smx_synchro_t comm) {
825 smx_process_t self = SIMIX_process_self();
827 /* Go to that function to follow the code flow through the simcall barrier */
828 if (0) simcall_HANDLER_comm_test(&self->simcall, comm);
829 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
831 self->simcall.call = SIMCALL_COMM_TEST;
832 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
833 memset(self->simcall.args, 0, sizeof(self->simcall.args));
834 self->simcall.args[0].dp = (void*) comm;
835 if (self != simix_global->maestro_process) {
836 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
837 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
838 SIMIX_process_yield(self);
840 SIMIX_simcall_handle(&self->simcall, 0);
842 return (int) self->simcall.result.i;
845 inline static int simcall_BODY_comm_testany(xbt_dynar_t comms) {
846 smx_process_t self = SIMIX_process_self();
848 /* Go to that function to follow the code flow through the simcall barrier */
849 if (0) simcall_HANDLER_comm_testany(&self->simcall, comms);
850 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
852 self->simcall.call = SIMCALL_COMM_TESTANY;
853 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
854 memset(self->simcall.args, 0, sizeof(self->simcall.args));
855 self->simcall.args[0].dp = (void*) comms;
856 if (self != simix_global->maestro_process) {
857 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
858 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
859 SIMIX_process_yield(self);
861 SIMIX_simcall_handle(&self->simcall, 0);
863 return (int) self->simcall.result.i;
866 inline static smx_mutex_t simcall_BODY_mutex_init() {
867 smx_process_t self = SIMIX_process_self();
869 /* Go to that function to follow the code flow through the simcall barrier */
870 if (0) simcall_HANDLER_mutex_init(&self->simcall);
871 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
873 self->simcall.call = SIMCALL_MUTEX_INIT;
874 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
875 memset(self->simcall.args, 0, sizeof(self->simcall.args));
877 if (self != simix_global->maestro_process) {
878 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
879 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
880 SIMIX_process_yield(self);
882 SIMIX_simcall_handle(&self->simcall, 0);
884 return (smx_mutex_t) self->simcall.result.dp;
887 inline static void simcall_BODY_mutex_lock(smx_mutex_t mutex) {
888 smx_process_t self = SIMIX_process_self();
890 /* Go to that function to follow the code flow through the simcall barrier */
891 if (0) simcall_HANDLER_mutex_lock(&self->simcall, mutex);
892 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
894 self->simcall.call = SIMCALL_MUTEX_LOCK;
895 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
896 memset(self->simcall.args, 0, sizeof(self->simcall.args));
897 self->simcall.args[0].dp = (void*) mutex;
898 if (self != simix_global->maestro_process) {
899 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
900 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
901 SIMIX_process_yield(self);
903 SIMIX_simcall_handle(&self->simcall, 0);
908 inline static int simcall_BODY_mutex_trylock(smx_mutex_t mutex) {
909 smx_process_t self = SIMIX_process_self();
911 /* Go to that function to follow the code flow through the simcall barrier */
912 if (0) simcall_HANDLER_mutex_trylock(&self->simcall, mutex);
913 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
915 self->simcall.call = SIMCALL_MUTEX_TRYLOCK;
916 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
917 memset(self->simcall.args, 0, sizeof(self->simcall.args));
918 self->simcall.args[0].dp = (void*) mutex;
919 if (self != simix_global->maestro_process) {
920 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
921 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
922 SIMIX_process_yield(self);
924 SIMIX_simcall_handle(&self->simcall, 0);
926 return (int) self->simcall.result.i;
929 inline static void simcall_BODY_mutex_unlock(smx_mutex_t mutex) {
930 smx_process_t self = SIMIX_process_self();
932 /* Go to that function to follow the code flow through the simcall barrier */
933 if (0) simcall_HANDLER_mutex_unlock(&self->simcall, mutex);
934 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
936 self->simcall.call = SIMCALL_MUTEX_UNLOCK;
937 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
938 memset(self->simcall.args, 0, sizeof(self->simcall.args));
939 self->simcall.args[0].dp = (void*) mutex;
940 if (self != simix_global->maestro_process) {
941 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
942 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
943 SIMIX_process_yield(self);
945 SIMIX_simcall_handle(&self->simcall, 0);
950 inline static smx_cond_t simcall_BODY_cond_init() {
951 smx_process_t self = SIMIX_process_self();
953 /* Go to that function to follow the code flow through the simcall barrier */
954 if (0) SIMIX_cond_init();
955 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
957 self->simcall.call = SIMCALL_COND_INIT;
958 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
959 memset(self->simcall.args, 0, sizeof(self->simcall.args));
961 if (self != simix_global->maestro_process) {
962 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
963 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
964 SIMIX_process_yield(self);
966 SIMIX_simcall_handle(&self->simcall, 0);
968 return (smx_cond_t) self->simcall.result.dp;
971 inline static void simcall_BODY_cond_signal(smx_cond_t cond) {
972 smx_process_t self = SIMIX_process_self();
974 /* Go to that function to follow the code flow through the simcall barrier */
975 if (0) SIMIX_cond_signal(cond);
976 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
978 self->simcall.call = SIMCALL_COND_SIGNAL;
979 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
980 memset(self->simcall.args, 0, sizeof(self->simcall.args));
981 self->simcall.args[0].dp = (void*) cond;
982 if (self != simix_global->maestro_process) {
983 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
984 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
985 SIMIX_process_yield(self);
987 SIMIX_simcall_handle(&self->simcall, 0);
992 inline static void simcall_BODY_cond_wait(smx_cond_t cond, smx_mutex_t mutex) {
993 smx_process_t self = SIMIX_process_self();
995 /* Go to that function to follow the code flow through the simcall barrier */
996 if (0) simcall_HANDLER_cond_wait(&self->simcall, cond, mutex);
997 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
999 self->simcall.call = SIMCALL_COND_WAIT;
1000 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1001 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1002 self->simcall.args[0].dp = (void*) cond;
1003 self->simcall.args[1].dp = (void*) mutex;
1004 if (self != simix_global->maestro_process) {
1005 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1006 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1007 SIMIX_process_yield(self);
1009 SIMIX_simcall_handle(&self->simcall, 0);
1014 inline static void simcall_BODY_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double timeout) {
1015 smx_process_t self = SIMIX_process_self();
1017 /* Go to that function to follow the code flow through the simcall barrier */
1018 if (0) simcall_HANDLER_cond_wait_timeout(&self->simcall, cond, mutex, timeout);
1019 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1021 self->simcall.call = SIMCALL_COND_WAIT_TIMEOUT;
1022 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1023 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1024 self->simcall.args[0].dp = (void*) cond;
1025 self->simcall.args[1].dp = (void*) mutex;
1026 self->simcall.args[2].d = (double) timeout;
1027 if (self != simix_global->maestro_process) {
1028 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1029 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1030 SIMIX_process_yield(self);
1032 SIMIX_simcall_handle(&self->simcall, 0);
1037 inline static void simcall_BODY_cond_broadcast(smx_cond_t cond) {
1038 smx_process_t self = SIMIX_process_self();
1040 /* Go to that function to follow the code flow through the simcall barrier */
1041 if (0) SIMIX_cond_broadcast(cond);
1042 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1044 self->simcall.call = SIMCALL_COND_BROADCAST;
1045 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1046 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1047 self->simcall.args[0].dp = (void*) cond;
1048 if (self != simix_global->maestro_process) {
1049 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1050 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1051 SIMIX_process_yield(self);
1053 SIMIX_simcall_handle(&self->simcall, 0);
1058 inline static smx_sem_t simcall_BODY_sem_init(unsigned int capacity) {
1059 smx_process_t self = SIMIX_process_self();
1061 /* Go to that function to follow the code flow through the simcall barrier */
1062 if (0) SIMIX_sem_init(capacity);
1063 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1065 self->simcall.call = SIMCALL_SEM_INIT;
1066 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1067 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1068 self->simcall.args[0].ui = (unsigned int) capacity;
1069 if (self != simix_global->maestro_process) {
1070 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1071 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1072 SIMIX_process_yield(self);
1074 SIMIX_simcall_handle(&self->simcall, 0);
1076 return (smx_sem_t) self->simcall.result.dp;
1079 inline static void simcall_BODY_sem_release(smx_sem_t sem) {
1080 smx_process_t self = SIMIX_process_self();
1082 /* Go to that function to follow the code flow through the simcall barrier */
1083 if (0) simcall_HANDLER_sem_release(&self->simcall, sem);
1084 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1086 self->simcall.call = SIMCALL_SEM_RELEASE;
1087 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1088 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1089 self->simcall.args[0].dp = (void*) sem;
1090 if (self != simix_global->maestro_process) {
1091 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1092 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1093 SIMIX_process_yield(self);
1095 SIMIX_simcall_handle(&self->simcall, 0);
1100 inline static int simcall_BODY_sem_would_block(smx_sem_t sem) {
1101 smx_process_t self = SIMIX_process_self();
1103 /* Go to that function to follow the code flow through the simcall barrier */
1104 if (0) simcall_HANDLER_sem_would_block(&self->simcall, sem);
1105 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1107 self->simcall.call = SIMCALL_SEM_WOULD_BLOCK;
1108 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1109 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1110 self->simcall.args[0].dp = (void*) sem;
1111 if (self != simix_global->maestro_process) {
1112 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1113 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1114 SIMIX_process_yield(self);
1116 SIMIX_simcall_handle(&self->simcall, 0);
1118 return (int) self->simcall.result.i;
1121 inline static void simcall_BODY_sem_acquire(smx_sem_t sem) {
1122 smx_process_t self = SIMIX_process_self();
1124 /* Go to that function to follow the code flow through the simcall barrier */
1125 if (0) simcall_HANDLER_sem_acquire(&self->simcall, sem);
1126 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1128 self->simcall.call = SIMCALL_SEM_ACQUIRE;
1129 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1130 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1131 self->simcall.args[0].dp = (void*) sem;
1132 if (self != simix_global->maestro_process) {
1133 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1134 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1135 SIMIX_process_yield(self);
1137 SIMIX_simcall_handle(&self->simcall, 0);
1142 inline static void simcall_BODY_sem_acquire_timeout(smx_sem_t sem, double timeout) {
1143 smx_process_t self = SIMIX_process_self();
1145 /* Go to that function to follow the code flow through the simcall barrier */
1146 if (0) simcall_HANDLER_sem_acquire_timeout(&self->simcall, sem, timeout);
1147 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1149 self->simcall.call = SIMCALL_SEM_ACQUIRE_TIMEOUT;
1150 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1151 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1152 self->simcall.args[0].dp = (void*) sem;
1153 self->simcall.args[1].d = (double) timeout;
1154 if (self != simix_global->maestro_process) {
1155 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1156 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1157 SIMIX_process_yield(self);
1159 SIMIX_simcall_handle(&self->simcall, 0);
1164 inline static int simcall_BODY_sem_get_capacity(smx_sem_t sem) {
1165 smx_process_t self = SIMIX_process_self();
1167 /* Go to that function to follow the code flow through the simcall barrier */
1168 if (0) simcall_HANDLER_sem_get_capacity(&self->simcall, sem);
1169 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1171 self->simcall.call = SIMCALL_SEM_GET_CAPACITY;
1172 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1173 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1174 self->simcall.args[0].dp = (void*) sem;
1175 if (self != simix_global->maestro_process) {
1176 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1177 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1178 SIMIX_process_yield(self);
1180 SIMIX_simcall_handle(&self->simcall, 0);
1182 return (int) self->simcall.result.i;
1185 inline static sg_size_t simcall_BODY_file_read(smx_file_t fd, sg_size_t size, sg_host_t host) {
1186 smx_process_t self = SIMIX_process_self();
1188 /* Go to that function to follow the code flow through the simcall barrier */
1189 if (0) simcall_HANDLER_file_read(&self->simcall, fd, size, host);
1190 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1192 self->simcall.call = SIMCALL_FILE_READ;
1193 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1194 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1195 self->simcall.args[0].dp = (void*) fd;
1196 self->simcall.args[1].sgsz = (sg_size_t) size;
1197 self->simcall.args[2].dp = (void*) host;
1198 if (self != simix_global->maestro_process) {
1199 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1200 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1201 SIMIX_process_yield(self);
1203 SIMIX_simcall_handle(&self->simcall, 0);
1205 return (sg_size_t) self->simcall.result.sgsz;
1208 inline static sg_size_t simcall_BODY_file_write(smx_file_t fd, sg_size_t size, sg_host_t host) {
1209 smx_process_t self = SIMIX_process_self();
1211 /* Go to that function to follow the code flow through the simcall barrier */
1212 if (0) simcall_HANDLER_file_write(&self->simcall, fd, size, host);
1213 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1215 self->simcall.call = SIMCALL_FILE_WRITE;
1216 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1217 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1218 self->simcall.args[0].dp = (void*) fd;
1219 self->simcall.args[1].sgsz = (sg_size_t) size;
1220 self->simcall.args[2].dp = (void*) host;
1221 if (self != simix_global->maestro_process) {
1222 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1223 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1224 SIMIX_process_yield(self);
1226 SIMIX_simcall_handle(&self->simcall, 0);
1228 return (sg_size_t) self->simcall.result.sgsz;
1231 inline static smx_file_t simcall_BODY_file_open(const char* fullpath, sg_host_t host) {
1232 smx_process_t self = SIMIX_process_self();
1234 /* Go to that function to follow the code flow through the simcall barrier */
1235 if (0) simcall_HANDLER_file_open(&self->simcall, fullpath, host);
1236 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1238 self->simcall.call = SIMCALL_FILE_OPEN;
1239 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1240 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1241 self->simcall.args[0].cc = (const char*) fullpath;
1242 self->simcall.args[1].dp = (void*) host;
1243 if (self != simix_global->maestro_process) {
1244 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1245 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1246 SIMIX_process_yield(self);
1248 SIMIX_simcall_handle(&self->simcall, 0);
1250 return (smx_file_t) self->simcall.result.dp;
1253 inline static int simcall_BODY_file_close(smx_file_t fd, sg_host_t host) {
1254 smx_process_t self = SIMIX_process_self();
1256 /* Go to that function to follow the code flow through the simcall barrier */
1257 if (0) simcall_HANDLER_file_close(&self->simcall, fd, host);
1258 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1260 self->simcall.call = SIMCALL_FILE_CLOSE;
1261 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1262 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1263 self->simcall.args[0].dp = (void*) fd;
1264 self->simcall.args[1].dp = (void*) host;
1265 if (self != simix_global->maestro_process) {
1266 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1267 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1268 SIMIX_process_yield(self);
1270 SIMIX_simcall_handle(&self->simcall, 0);
1272 return (int) self->simcall.result.i;
1275 inline static int simcall_BODY_file_unlink(smx_file_t fd, sg_host_t host) {
1276 smx_process_t self = SIMIX_process_self();
1278 /* Go to that function to follow the code flow through the simcall barrier */
1279 if (0) SIMIX_file_unlink(fd, host);
1280 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1282 self->simcall.call = SIMCALL_FILE_UNLINK;
1283 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1284 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1285 self->simcall.args[0].dp = (void*) fd;
1286 self->simcall.args[1].dp = (void*) host;
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);
1294 return (int) self->simcall.result.i;
1297 inline static sg_size_t simcall_BODY_file_get_size(smx_file_t fd) {
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_file_get_size(&self->simcall, fd);
1302 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1304 self->simcall.call = SIMCALL_FILE_GET_SIZE;
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*) fd;
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 (sg_size_t) self->simcall.result.sgsz;
1318 inline static sg_size_t simcall_BODY_file_tell(smx_file_t fd) {
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) simcall_HANDLER_file_tell(&self->simcall, fd);
1323 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1325 self->simcall.call = SIMCALL_FILE_TELL;
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*) fd;
1329 if (self != simix_global->maestro_process) {
1330 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1331 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1332 SIMIX_process_yield(self);
1334 SIMIX_simcall_handle(&self->simcall, 0);
1336 return (sg_size_t) self->simcall.result.sgsz;
1339 inline static int simcall_BODY_file_seek(smx_file_t fd, sg_offset_t offset, int origin) {
1340 smx_process_t self = SIMIX_process_self();
1342 /* Go to that function to follow the code flow through the simcall barrier */
1343 if (0) simcall_HANDLER_file_seek(&self->simcall, fd, offset, origin);
1344 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1346 self->simcall.call = SIMCALL_FILE_SEEK;
1347 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1348 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1349 self->simcall.args[0].dp = (void*) fd;
1350 self->simcall.args[1].sgoff = (sg_offset_t) offset;
1351 self->simcall.args[2].i = (int) origin;
1352 if (self != simix_global->maestro_process) {
1353 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1354 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1355 SIMIX_process_yield(self);
1357 SIMIX_simcall_handle(&self->simcall, 0);
1359 return (int) self->simcall.result.i;
1362 inline static xbt_dynar_t simcall_BODY_file_get_info(smx_file_t fd) {
1363 smx_process_t self = SIMIX_process_self();
1365 /* Go to that function to follow the code flow through the simcall barrier */
1366 if (0) simcall_HANDLER_file_get_info(&self->simcall, fd);
1367 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1369 self->simcall.call = SIMCALL_FILE_GET_INFO;
1370 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1371 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1372 self->simcall.args[0].dp = (void*) fd;
1373 if (self != simix_global->maestro_process) {
1374 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1375 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1376 SIMIX_process_yield(self);
1378 SIMIX_simcall_handle(&self->simcall, 0);
1380 return (xbt_dynar_t) self->simcall.result.dp;
1383 inline static int simcall_BODY_file_move(smx_file_t fd, const char* fullpath) {
1384 smx_process_t self = SIMIX_process_self();
1386 /* Go to that function to follow the code flow through the simcall barrier */
1387 if (0) simcall_HANDLER_file_move(&self->simcall, fd, fullpath);
1388 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1390 self->simcall.call = SIMCALL_FILE_MOVE;
1391 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1392 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1393 self->simcall.args[0].dp = (void*) fd;
1394 self->simcall.args[1].cc = (const char*) fullpath;
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 (int) self->simcall.result.i;
1405 inline static sg_size_t simcall_BODY_storage_get_free_size(smx_storage_t storage) {
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) simcall_HANDLER_storage_get_free_size(&self->simcall, storage);
1410 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1412 self->simcall.call = SIMCALL_STORAGE_GET_FREE_SIZE;
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*) storage;
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);
1423 return (sg_size_t) self->simcall.result.sgsz;
1426 inline static sg_size_t simcall_BODY_storage_get_used_size(smx_storage_t name) {
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) simcall_HANDLER_storage_get_used_size(&self->simcall, name);
1431 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1433 self->simcall.call = SIMCALL_STORAGE_GET_USED_SIZE;
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*) name;
1437 if (self != simix_global->maestro_process) {
1438 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1439 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1440 SIMIX_process_yield(self);
1442 SIMIX_simcall_handle(&self->simcall, 0);
1444 return (sg_size_t) self->simcall.result.sgsz;
1447 inline static xbt_dict_t simcall_BODY_storage_get_properties(smx_storage_t storage) {
1448 smx_process_t self = SIMIX_process_self();
1450 /* Go to that function to follow the code flow through the simcall barrier */
1451 if (0) SIMIX_storage_get_properties(storage);
1452 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1454 self->simcall.call = SIMCALL_STORAGE_GET_PROPERTIES;
1455 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1456 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1457 self->simcall.args[0].dp = (void*) storage;
1458 if (self != simix_global->maestro_process) {
1459 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1460 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1461 SIMIX_process_yield(self);
1463 SIMIX_simcall_handle(&self->simcall, 0);
1465 return (xbt_dict_t) self->simcall.result.dp;
1468 inline static xbt_dict_t simcall_BODY_storage_get_content(smx_storage_t storage) {
1469 smx_process_t self = SIMIX_process_self();
1471 /* Go to that function to follow the code flow through the simcall barrier */
1472 if (0) SIMIX_storage_get_content(storage);
1473 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1475 self->simcall.call = SIMCALL_STORAGE_GET_CONTENT;
1476 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1477 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1478 self->simcall.args[0].dp = (void*) storage;
1479 if (self != simix_global->maestro_process) {
1480 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1481 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1482 SIMIX_process_yield(self);
1484 SIMIX_simcall_handle(&self->simcall, 0);
1486 return (xbt_dict_t) self->simcall.result.dp;
1489 inline static xbt_dict_t simcall_BODY_asr_get_properties(const char* name) {
1490 smx_process_t self = SIMIX_process_self();
1492 /* Go to that function to follow the code flow through the simcall barrier */
1493 if (0) simcall_HANDLER_asr_get_properties(&self->simcall, name);
1494 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1496 self->simcall.call = SIMCALL_ASR_GET_PROPERTIES;
1497 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1498 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1499 self->simcall.args[0].cc = (const char*) name;
1500 if (self != simix_global->maestro_process) {
1501 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1502 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1503 SIMIX_process_yield(self);
1505 SIMIX_simcall_handle(&self->simcall, 0);
1507 return (xbt_dict_t) self->simcall.result.dp;
1510 inline static int simcall_BODY_mc_random(int min, int max) {
1511 smx_process_t self = SIMIX_process_self();
1513 /* Go to that function to follow the code flow through the simcall barrier */
1514 if (0) simcall_HANDLER_mc_random(&self->simcall, min, max);
1515 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1517 self->simcall.call = SIMCALL_MC_RANDOM;
1518 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1519 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1520 self->simcall.args[0].i = (int) min;
1521 self->simcall.args[1].i = (int) max;
1522 if (self != simix_global->maestro_process) {
1523 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1524 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1525 SIMIX_process_yield(self);
1527 SIMIX_simcall_handle(&self->simcall, 0);
1529 return (int) self->simcall.result.i;
1532 inline static void simcall_BODY_set_category(smx_synchro_t synchro, const char* category) {
1533 smx_process_t self = SIMIX_process_self();
1535 /* Go to that function to follow the code flow through the simcall barrier */
1536 if (0) SIMIX_set_category(synchro, category);
1537 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1539 self->simcall.call = SIMCALL_SET_CATEGORY;
1540 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1541 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1542 self->simcall.args[0].dp = (void*) synchro;
1543 self->simcall.args[1].cc = (const char*) category;
1544 if (self != simix_global->maestro_process) {
1545 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1546 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1547 SIMIX_process_yield(self);
1549 SIMIX_simcall_handle(&self->simcall, 0);
1554 inline static void simcall_BODY_run_kernel(void* code) {
1555 smx_process_t self = SIMIX_process_self();
1557 /* Go to that function to follow the code flow through the simcall barrier */
1558 if (0) SIMIX_run_kernel(code);
1559 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1561 self->simcall.call = SIMCALL_RUN_KERNEL;
1562 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1563 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1564 self->simcall.args[0].dp = (void*) code;
1565 if (self != simix_global->maestro_process) {
1566 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1567 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1568 SIMIX_process_yield(self);
1570 SIMIX_simcall_handle(&self->simcall, 0);