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 double simcall_BODY_execution_get_remains(smx_synchro_t execution) {
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_get_remains(execution);
445 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
447 self->simcall.call = SIMCALL_EXECUTION_GET_REMAINS;
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 if (self != simix_global->maestro_process) {
452 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
453 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
454 SIMIX_process_yield(self);
456 SIMIX_simcall_handle(&self->simcall, 0);
458 return (double) self->simcall.result.d;
461 inline static e_smx_state_t simcall_BODY_execution_get_state(smx_synchro_t execution) {
462 smx_process_t self = SIMIX_process_self();
464 /* Go to that function to follow the code flow through the simcall barrier */
465 if (0) SIMIX_execution_get_state(execution);
466 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
468 self->simcall.call = SIMCALL_EXECUTION_GET_STATE;
469 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
470 memset(self->simcall.args, 0, sizeof(self->simcall.args));
471 self->simcall.args[0].dp = (void*) execution;
472 if (self != simix_global->maestro_process) {
473 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
474 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
475 SIMIX_process_yield(self);
477 SIMIX_simcall_handle(&self->simcall, 0);
479 return (e_smx_state_t) self->simcall.result.i;
482 inline static void simcall_BODY_execution_set_priority(smx_synchro_t execution, double priority) {
483 smx_process_t self = SIMIX_process_self();
485 /* Go to that function to follow the code flow through the simcall barrier */
486 if (0) SIMIX_execution_set_priority(execution, priority);
487 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
489 self->simcall.call = SIMCALL_EXECUTION_SET_PRIORITY;
490 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
491 memset(self->simcall.args, 0, sizeof(self->simcall.args));
492 self->simcall.args[0].dp = (void*) execution;
493 self->simcall.args[1].d = (double) priority;
494 if (self != simix_global->maestro_process) {
495 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
496 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
497 SIMIX_process_yield(self);
499 SIMIX_simcall_handle(&self->simcall, 0);
504 inline static void simcall_BODY_execution_set_bound(smx_synchro_t execution, double bound) {
505 smx_process_t self = SIMIX_process_self();
507 /* Go to that function to follow the code flow through the simcall barrier */
508 if (0) SIMIX_execution_set_bound(execution, bound);
509 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
511 self->simcall.call = SIMCALL_EXECUTION_SET_BOUND;
512 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
513 memset(self->simcall.args, 0, sizeof(self->simcall.args));
514 self->simcall.args[0].dp = (void*) execution;
515 self->simcall.args[1].d = (double) bound;
516 if (self != simix_global->maestro_process) {
517 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
518 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
519 SIMIX_process_yield(self);
521 SIMIX_simcall_handle(&self->simcall, 0);
526 inline static void simcall_BODY_execution_set_affinity(smx_synchro_t execution, sg_host_t ws, unsigned long mask) {
527 smx_process_t self = SIMIX_process_self();
529 /* Go to that function to follow the code flow through the simcall barrier */
530 if (0) SIMIX_execution_set_affinity(execution, ws, mask);
531 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
533 self->simcall.call = SIMCALL_EXECUTION_SET_AFFINITY;
534 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
535 memset(self->simcall.args, 0, sizeof(self->simcall.args));
536 self->simcall.args[0].dp = (void*) execution;
537 self->simcall.args[1].dp = (void*) ws;
538 self->simcall.args[2].ul = (unsigned long) mask;
539 if (self != simix_global->maestro_process) {
540 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
541 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
542 SIMIX_process_yield(self);
544 SIMIX_simcall_handle(&self->simcall, 0);
549 inline static int simcall_BODY_execution_wait(smx_synchro_t execution) {
550 smx_process_t self = SIMIX_process_self();
552 /* Go to that function to follow the code flow through the simcall barrier */
553 if (0) simcall_HANDLER_execution_wait(&self->simcall, execution);
554 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
556 self->simcall.call = SIMCALL_EXECUTION_WAIT;
557 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
558 memset(self->simcall.args, 0, sizeof(self->simcall.args));
559 self->simcall.args[0].dp = (void*) execution;
560 if (self != simix_global->maestro_process) {
561 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
562 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
563 SIMIX_process_yield(self);
565 SIMIX_simcall_handle(&self->simcall, 0);
567 return (int) self->simcall.result.i;
570 inline static void simcall_BODY_process_on_exit(smx_process_t process, int_f_pvoid_pvoid_t fun, void* data) {
571 smx_process_t self = SIMIX_process_self();
573 /* Go to that function to follow the code flow through the simcall barrier */
574 if (0) SIMIX_process_on_exit(process, fun, data);
575 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
577 self->simcall.call = SIMCALL_PROCESS_ON_EXIT;
578 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
579 memset(self->simcall.args, 0, sizeof(self->simcall.args));
580 self->simcall.args[0].dp = (void*) process;
581 self->simcall.args[1].fp = (FPtr) fun;
582 self->simcall.args[2].dp = (void*) data;
583 if (self != simix_global->maestro_process) {
584 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
585 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
586 SIMIX_process_yield(self);
588 SIMIX_simcall_handle(&self->simcall, 0);
593 inline static void simcall_BODY_process_auto_restart_set(smx_process_t process, int auto_restart) {
594 smx_process_t self = SIMIX_process_self();
596 /* Go to that function to follow the code flow through the simcall barrier */
597 if (0) SIMIX_process_auto_restart_set(process, auto_restart);
598 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
600 self->simcall.call = SIMCALL_PROCESS_AUTO_RESTART_SET;
601 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
602 memset(self->simcall.args, 0, sizeof(self->simcall.args));
603 self->simcall.args[0].dp = (void*) process;
604 self->simcall.args[1].i = (int) auto_restart;
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);
615 inline static smx_process_t simcall_BODY_process_restart(smx_process_t process) {
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) simcall_HANDLER_process_restart(&self->simcall, process);
620 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
622 self->simcall.call = SIMCALL_PROCESS_RESTART;
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*) process;
626 if (self != simix_global->maestro_process) {
627 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
628 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
629 SIMIX_process_yield(self);
631 SIMIX_simcall_handle(&self->simcall, 0);
633 return (smx_process_t) self->simcall.result.dp;
636 inline static smx_mailbox_t simcall_BODY_mbox_create(const char* name) {
637 smx_process_t self = SIMIX_process_self();
639 /* Go to that function to follow the code flow through the simcall barrier */
640 if (0) SIMIX_mbox_create(name);
641 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
643 self->simcall.call = SIMCALL_MBOX_CREATE;
644 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
645 memset(self->simcall.args, 0, sizeof(self->simcall.args));
646 self->simcall.args[0].cc = (const char*) name;
647 if (self != simix_global->maestro_process) {
648 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
649 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
650 SIMIX_process_yield(self);
652 SIMIX_simcall_handle(&self->simcall, 0);
654 return (smx_mailbox_t) self->simcall.result.dp;
657 inline static unsigned int simcall_BODY_mbox_comm_count_by_host(smx_mailbox_t mbox, sg_host_t host) {
658 smx_process_t self = SIMIX_process_self();
660 /* Go to that function to follow the code flow through the simcall barrier */
661 if (0) SIMIX_mbox_comm_count_by_host(mbox, host);
662 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
664 self->simcall.call = SIMCALL_MBOX_COMM_COUNT_BY_HOST;
665 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
666 memset(self->simcall.args, 0, sizeof(self->simcall.args));
667 self->simcall.args[0].dp = (void*) mbox;
668 self->simcall.args[1].dp = (void*) host;
669 if (self != simix_global->maestro_process) {
670 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
671 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
672 SIMIX_process_yield(self);
674 SIMIX_simcall_handle(&self->simcall, 0);
676 return (unsigned int) self->simcall.result.ui;
679 inline static smx_synchro_t simcall_BODY_mbox_get_head(smx_mailbox_t mbox) {
680 smx_process_t self = SIMIX_process_self();
682 /* Go to that function to follow the code flow through the simcall barrier */
683 if (0) SIMIX_mbox_get_head(mbox);
684 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
686 self->simcall.call = SIMCALL_MBOX_GET_HEAD;
687 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
688 memset(self->simcall.args, 0, sizeof(self->simcall.args));
689 self->simcall.args[0].dp = (void*) mbox;
690 if (self != simix_global->maestro_process) {
691 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
692 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
693 SIMIX_process_yield(self);
695 SIMIX_simcall_handle(&self->simcall, 0);
697 return (smx_synchro_t) self->simcall.result.dp;
700 inline static void simcall_BODY_mbox_set_receiver(smx_mailbox_t mbox, smx_process_t receiver) {
701 smx_process_t self = SIMIX_process_self();
703 /* Go to that function to follow the code flow through the simcall barrier */
704 if (0) SIMIX_mbox_set_receiver(mbox, receiver);
705 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
707 self->simcall.call = SIMCALL_MBOX_SET_RECEIVER;
708 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
709 memset(self->simcall.args, 0, sizeof(self->simcall.args));
710 self->simcall.args[0].dp = (void*) mbox;
711 self->simcall.args[1].dp = (void*) receiver;
712 if (self != simix_global->maestro_process) {
713 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
714 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
715 SIMIX_process_yield(self);
717 SIMIX_simcall_handle(&self->simcall, 0);
722 inline static smx_process_t simcall_BODY_mbox_get_receiver(smx_mailbox_t mbox) {
723 smx_process_t self = SIMIX_process_self();
725 /* Go to that function to follow the code flow through the simcall barrier */
726 if (0) SIMIX_mbox_get_receiver(mbox);
727 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
729 self->simcall.call = SIMCALL_MBOX_GET_RECEIVER;
730 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
731 memset(self->simcall.args, 0, sizeof(self->simcall.args));
732 self->simcall.args[0].dp = (void*) mbox;
733 if (self != simix_global->maestro_process) {
734 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
735 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
736 SIMIX_process_yield(self);
738 SIMIX_simcall_handle(&self->simcall, 0);
740 return (smx_process_t) self->simcall.result.dp;
743 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) {
744 smx_process_t self = SIMIX_process_self();
746 /* Go to that function to follow the code flow through the simcall barrier */
747 if (0) simcall_HANDLER_comm_iprobe(&self->simcall, mbox, type, src, tag, match_fun, data);
748 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
750 self->simcall.call = SIMCALL_COMM_IPROBE;
751 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
752 memset(self->simcall.args, 0, sizeof(self->simcall.args));
753 self->simcall.args[0].dp = (void*) mbox;
754 self->simcall.args[1].i = (int) type;
755 self->simcall.args[2].i = (int) src;
756 self->simcall.args[3].i = (int) tag;
757 self->simcall.args[4].fp = (FPtr) match_fun;
758 self->simcall.args[5].dp = (void*) data;
759 if (self != simix_global->maestro_process) {
760 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
761 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
762 SIMIX_process_yield(self);
764 SIMIX_simcall_handle(&self->simcall, 0);
766 return (smx_synchro_t) self->simcall.result.dp;
769 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) {
770 smx_process_t self = SIMIX_process_self();
772 /* Go to that function to follow the code flow through the simcall barrier */
773 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);
774 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
776 self->simcall.call = SIMCALL_COMM_SEND;
777 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
778 memset(self->simcall.args, 0, sizeof(self->simcall.args));
779 self->simcall.args[0].dp = (void*) sender;
780 self->simcall.args[1].dp = (void*) mbox;
781 self->simcall.args[2].d = (double) task_size;
782 self->simcall.args[3].d = (double) rate;
783 self->simcall.args[4].dp = (void*) src_buff;
784 self->simcall.args[5].sz = (size_t) src_buff_size;
785 self->simcall.args[6].fp = (FPtr) match_fun;
786 self->simcall.args[7].fp = (FPtr) copy_data_fun;
787 self->simcall.args[8].dp = (void*) data;
788 self->simcall.args[9].d = (double) timeout;
789 if (self != simix_global->maestro_process) {
790 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
791 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
792 SIMIX_process_yield(self);
794 SIMIX_simcall_handle(&self->simcall, 0);
799 inline static 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) {
800 smx_process_t self = SIMIX_process_self();
802 /* Go to that function to follow the code flow through the simcall barrier */
803 if (0) 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);
804 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
806 self->simcall.call = SIMCALL_COMM_ISEND;
807 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
808 memset(self->simcall.args, 0, sizeof(self->simcall.args));
809 self->simcall.args[0].dp = (void*) sender;
810 self->simcall.args[1].dp = (void*) mbox;
811 self->simcall.args[2].d = (double) task_size;
812 self->simcall.args[3].d = (double) rate;
813 self->simcall.args[4].dp = (void*) src_buff;
814 self->simcall.args[5].sz = (size_t) src_buff_size;
815 self->simcall.args[6].fp = (FPtr) match_fun;
816 self->simcall.args[7].fp = (FPtr) clean_fun;
817 self->simcall.args[8].fp = (FPtr) copy_data_fun;
818 self->simcall.args[9].dp = (void*) data;
819 self->simcall.args[10].i = (int) detached;
820 if (self != simix_global->maestro_process) {
821 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
822 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
823 SIMIX_process_yield(self);
825 SIMIX_simcall_handle(&self->simcall, 0);
827 return (smx_synchro_t) self->simcall.result.dp;
830 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) {
831 smx_process_t self = SIMIX_process_self();
833 /* Go to that function to follow the code flow through the simcall barrier */
834 if (0) simcall_HANDLER_comm_recv(&self->simcall, receiver, mbox, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, timeout, rate);
835 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
837 self->simcall.call = SIMCALL_COMM_RECV;
838 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
839 memset(self->simcall.args, 0, sizeof(self->simcall.args));
840 self->simcall.args[0].dp = (void*) receiver;
841 self->simcall.args[1].dp = (void*) mbox;
842 self->simcall.args[2].dp = (void*) dst_buff;
843 self->simcall.args[3].dp = (void*) dst_buff_size;
844 self->simcall.args[4].fp = (FPtr) match_fun;
845 self->simcall.args[5].fp = (FPtr) copy_data_fun;
846 self->simcall.args[6].dp = (void*) data;
847 self->simcall.args[7].d = (double) timeout;
848 self->simcall.args[8].d = (double) rate;
849 if (self != simix_global->maestro_process) {
850 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
851 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
852 SIMIX_process_yield(self);
854 SIMIX_simcall_handle(&self->simcall, 0);
859 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) {
860 smx_process_t self = SIMIX_process_self();
862 /* Go to that function to follow the code flow through the simcall barrier */
863 if (0) simcall_HANDLER_comm_irecv(&self->simcall, receiver, mbox, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, rate);
864 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
866 self->simcall.call = SIMCALL_COMM_IRECV;
867 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
868 memset(self->simcall.args, 0, sizeof(self->simcall.args));
869 self->simcall.args[0].dp = (void*) receiver;
870 self->simcall.args[1].dp = (void*) mbox;
871 self->simcall.args[2].dp = (void*) dst_buff;
872 self->simcall.args[3].dp = (void*) dst_buff_size;
873 self->simcall.args[4].fp = (FPtr) match_fun;
874 self->simcall.args[5].fp = (FPtr) copy_data_fun;
875 self->simcall.args[6].dp = (void*) data;
876 self->simcall.args[7].d = (double) rate;
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_synchro_t) self->simcall.result.dp;
887 inline static void simcall_BODY_comm_cancel(smx_synchro_t comm) {
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) SIMIX_comm_cancel(comm);
892 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
894 self->simcall.call = SIMCALL_COMM_CANCEL;
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*) comm;
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_comm_waitany(xbt_dynar_t comms) {
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_comm_waitany(&self->simcall, comms);
913 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
915 self->simcall.call = SIMCALL_COMM_WAITANY;
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*) comms;
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_comm_wait(smx_synchro_t comm, double timeout) {
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_comm_wait(&self->simcall, comm, timeout);
934 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
936 self->simcall.call = SIMCALL_COMM_WAIT;
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*) comm;
940 self->simcall.args[1].d = (double) timeout;
941 if (self != simix_global->maestro_process) {
942 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
943 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
944 SIMIX_process_yield(self);
946 SIMIX_simcall_handle(&self->simcall, 0);
951 inline static int simcall_BODY_comm_test(smx_synchro_t comm) {
952 smx_process_t self = SIMIX_process_self();
954 /* Go to that function to follow the code flow through the simcall barrier */
955 if (0) simcall_HANDLER_comm_test(&self->simcall, comm);
956 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
958 self->simcall.call = SIMCALL_COMM_TEST;
959 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
960 memset(self->simcall.args, 0, sizeof(self->simcall.args));
961 self->simcall.args[0].dp = (void*) comm;
962 if (self != simix_global->maestro_process) {
963 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
964 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
965 SIMIX_process_yield(self);
967 SIMIX_simcall_handle(&self->simcall, 0);
969 return (int) self->simcall.result.i;
972 inline static int simcall_BODY_comm_testany(xbt_dynar_t comms) {
973 smx_process_t self = SIMIX_process_self();
975 /* Go to that function to follow the code flow through the simcall barrier */
976 if (0) simcall_HANDLER_comm_testany(&self->simcall, comms);
977 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
979 self->simcall.call = SIMCALL_COMM_TESTANY;
980 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
981 memset(self->simcall.args, 0, sizeof(self->simcall.args));
982 self->simcall.args[0].dp = (void*) comms;
983 if (self != simix_global->maestro_process) {
984 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
985 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
986 SIMIX_process_yield(self);
988 SIMIX_simcall_handle(&self->simcall, 0);
990 return (int) self->simcall.result.i;
993 inline static double simcall_BODY_comm_get_remains(smx_synchro_t comm) {
994 smx_process_t self = SIMIX_process_self();
996 /* Go to that function to follow the code flow through the simcall barrier */
997 if (0) SIMIX_comm_get_remains(comm);
998 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1000 self->simcall.call = SIMCALL_COMM_GET_REMAINS;
1001 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1002 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1003 self->simcall.args[0].dp = (void*) comm;
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);
1011 return (double) self->simcall.result.d;
1014 inline static e_smx_state_t simcall_BODY_comm_get_state(smx_synchro_t comm) {
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) SIMIX_comm_get_state(comm);
1019 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1021 self->simcall.call = SIMCALL_COMM_GET_STATE;
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*) comm;
1025 if (self != simix_global->maestro_process) {
1026 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1027 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1028 SIMIX_process_yield(self);
1030 SIMIX_simcall_handle(&self->simcall, 0);
1032 return (e_smx_state_t) self->simcall.result.i;
1035 inline static void* simcall_BODY_comm_get_src_data(smx_synchro_t comm) {
1036 smx_process_t self = SIMIX_process_self();
1038 /* Go to that function to follow the code flow through the simcall barrier */
1039 if (0) SIMIX_comm_get_src_data(comm);
1040 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1042 self->simcall.call = SIMCALL_COMM_GET_SRC_DATA;
1043 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1044 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1045 self->simcall.args[0].dp = (void*) comm;
1046 if (self != simix_global->maestro_process) {
1047 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1048 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1049 SIMIX_process_yield(self);
1051 SIMIX_simcall_handle(&self->simcall, 0);
1053 return (void*) self->simcall.result.dp;
1056 inline static void* simcall_BODY_comm_get_dst_data(smx_synchro_t comm) {
1057 smx_process_t self = SIMIX_process_self();
1059 /* Go to that function to follow the code flow through the simcall barrier */
1060 if (0) SIMIX_comm_get_dst_data(comm);
1061 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1063 self->simcall.call = SIMCALL_COMM_GET_DST_DATA;
1064 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1065 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1066 self->simcall.args[0].dp = (void*) comm;
1067 if (self != simix_global->maestro_process) {
1068 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1069 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1070 SIMIX_process_yield(self);
1072 SIMIX_simcall_handle(&self->simcall, 0);
1074 return (void*) self->simcall.result.dp;
1077 inline static smx_process_t simcall_BODY_comm_get_src_proc(smx_synchro_t comm) {
1078 smx_process_t self = SIMIX_process_self();
1080 /* Go to that function to follow the code flow through the simcall barrier */
1081 if (0) SIMIX_comm_get_src_proc(comm);
1082 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1084 self->simcall.call = SIMCALL_COMM_GET_SRC_PROC;
1085 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1086 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1087 self->simcall.args[0].dp = (void*) comm;
1088 if (self != simix_global->maestro_process) {
1089 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1090 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1091 SIMIX_process_yield(self);
1093 SIMIX_simcall_handle(&self->simcall, 0);
1095 return (smx_process_t) self->simcall.result.dp;
1098 inline static smx_process_t simcall_BODY_comm_get_dst_proc(smx_synchro_t comm) {
1099 smx_process_t self = SIMIX_process_self();
1101 /* Go to that function to follow the code flow through the simcall barrier */
1102 if (0) SIMIX_comm_get_dst_proc(comm);
1103 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1105 self->simcall.call = SIMCALL_COMM_GET_DST_PROC;
1106 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1107 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1108 self->simcall.args[0].dp = (void*) comm;
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 (smx_process_t) self->simcall.result.dp;
1119 inline static smx_mutex_t simcall_BODY_mutex_init() {
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) simcall_HANDLER_mutex_init(&self->simcall);
1124 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1126 self->simcall.call = SIMCALL_MUTEX_INIT;
1127 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1128 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1130 if (self != simix_global->maestro_process) {
1131 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1132 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1133 SIMIX_process_yield(self);
1135 SIMIX_simcall_handle(&self->simcall, 0);
1137 return (smx_mutex_t) self->simcall.result.dp;
1140 inline static void simcall_BODY_mutex_lock(smx_mutex_t mutex) {
1141 smx_process_t self = SIMIX_process_self();
1143 /* Go to that function to follow the code flow through the simcall barrier */
1144 if (0) simcall_HANDLER_mutex_lock(&self->simcall, mutex);
1145 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1147 self->simcall.call = SIMCALL_MUTEX_LOCK;
1148 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1149 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1150 self->simcall.args[0].dp = (void*) mutex;
1151 if (self != simix_global->maestro_process) {
1152 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1153 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1154 SIMIX_process_yield(self);
1156 SIMIX_simcall_handle(&self->simcall, 0);
1161 inline static int simcall_BODY_mutex_trylock(smx_mutex_t mutex) {
1162 smx_process_t self = SIMIX_process_self();
1164 /* Go to that function to follow the code flow through the simcall barrier */
1165 if (0) simcall_HANDLER_mutex_trylock(&self->simcall, mutex);
1166 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1168 self->simcall.call = SIMCALL_MUTEX_TRYLOCK;
1169 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1170 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1171 self->simcall.args[0].dp = (void*) mutex;
1172 if (self != simix_global->maestro_process) {
1173 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1174 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1175 SIMIX_process_yield(self);
1177 SIMIX_simcall_handle(&self->simcall, 0);
1179 return (int) self->simcall.result.i;
1182 inline static void simcall_BODY_mutex_unlock(smx_mutex_t mutex) {
1183 smx_process_t self = SIMIX_process_self();
1185 /* Go to that function to follow the code flow through the simcall barrier */
1186 if (0) simcall_HANDLER_mutex_unlock(&self->simcall, mutex);
1187 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1189 self->simcall.call = SIMCALL_MUTEX_UNLOCK;
1190 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1191 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1192 self->simcall.args[0].dp = (void*) mutex;
1193 if (self != simix_global->maestro_process) {
1194 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1195 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1196 SIMIX_process_yield(self);
1198 SIMIX_simcall_handle(&self->simcall, 0);
1203 inline static smx_cond_t simcall_BODY_cond_init() {
1204 smx_process_t self = SIMIX_process_self();
1206 /* Go to that function to follow the code flow through the simcall barrier */
1207 if (0) SIMIX_cond_init();
1208 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1210 self->simcall.call = SIMCALL_COND_INIT;
1211 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1212 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1214 if (self != simix_global->maestro_process) {
1215 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1216 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1217 SIMIX_process_yield(self);
1219 SIMIX_simcall_handle(&self->simcall, 0);
1221 return (smx_cond_t) self->simcall.result.dp;
1224 inline static void simcall_BODY_cond_signal(smx_cond_t cond) {
1225 smx_process_t self = SIMIX_process_self();
1227 /* Go to that function to follow the code flow through the simcall barrier */
1228 if (0) SIMIX_cond_signal(cond);
1229 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1231 self->simcall.call = SIMCALL_COND_SIGNAL;
1232 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1233 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1234 self->simcall.args[0].dp = (void*) cond;
1235 if (self != simix_global->maestro_process) {
1236 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1237 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1238 SIMIX_process_yield(self);
1240 SIMIX_simcall_handle(&self->simcall, 0);
1245 inline static void simcall_BODY_cond_wait(smx_cond_t cond, smx_mutex_t mutex) {
1246 smx_process_t self = SIMIX_process_self();
1248 /* Go to that function to follow the code flow through the simcall barrier */
1249 if (0) simcall_HANDLER_cond_wait(&self->simcall, cond, mutex);
1250 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1252 self->simcall.call = SIMCALL_COND_WAIT;
1253 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1254 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1255 self->simcall.args[0].dp = (void*) cond;
1256 self->simcall.args[1].dp = (void*) mutex;
1257 if (self != simix_global->maestro_process) {
1258 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1259 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1260 SIMIX_process_yield(self);
1262 SIMIX_simcall_handle(&self->simcall, 0);
1267 inline static void simcall_BODY_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double timeout) {
1268 smx_process_t self = SIMIX_process_self();
1270 /* Go to that function to follow the code flow through the simcall barrier */
1271 if (0) simcall_HANDLER_cond_wait_timeout(&self->simcall, cond, mutex, timeout);
1272 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1274 self->simcall.call = SIMCALL_COND_WAIT_TIMEOUT;
1275 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1276 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1277 self->simcall.args[0].dp = (void*) cond;
1278 self->simcall.args[1].dp = (void*) mutex;
1279 self->simcall.args[2].d = (double) timeout;
1280 if (self != simix_global->maestro_process) {
1281 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1282 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1283 SIMIX_process_yield(self);
1285 SIMIX_simcall_handle(&self->simcall, 0);
1290 inline static void simcall_BODY_cond_broadcast(smx_cond_t cond) {
1291 smx_process_t self = SIMIX_process_self();
1293 /* Go to that function to follow the code flow through the simcall barrier */
1294 if (0) SIMIX_cond_broadcast(cond);
1295 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1297 self->simcall.call = SIMCALL_COND_BROADCAST;
1298 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1299 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1300 self->simcall.args[0].dp = (void*) cond;
1301 if (self != simix_global->maestro_process) {
1302 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1303 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1304 SIMIX_process_yield(self);
1306 SIMIX_simcall_handle(&self->simcall, 0);
1311 inline static smx_sem_t simcall_BODY_sem_init(unsigned int capacity) {
1312 smx_process_t self = SIMIX_process_self();
1314 /* Go to that function to follow the code flow through the simcall barrier */
1315 if (0) SIMIX_sem_init(capacity);
1316 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1318 self->simcall.call = SIMCALL_SEM_INIT;
1319 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1320 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1321 self->simcall.args[0].ui = (unsigned int) capacity;
1322 if (self != simix_global->maestro_process) {
1323 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1324 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1325 SIMIX_process_yield(self);
1327 SIMIX_simcall_handle(&self->simcall, 0);
1329 return (smx_sem_t) self->simcall.result.dp;
1332 inline static void simcall_BODY_sem_release(smx_sem_t sem) {
1333 smx_process_t self = SIMIX_process_self();
1335 /* Go to that function to follow the code flow through the simcall barrier */
1336 if (0) simcall_HANDLER_sem_release(&self->simcall, sem);
1337 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1339 self->simcall.call = SIMCALL_SEM_RELEASE;
1340 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1341 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1342 self->simcall.args[0].dp = (void*) sem;
1343 if (self != simix_global->maestro_process) {
1344 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1345 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1346 SIMIX_process_yield(self);
1348 SIMIX_simcall_handle(&self->simcall, 0);
1353 inline static int simcall_BODY_sem_would_block(smx_sem_t sem) {
1354 smx_process_t self = SIMIX_process_self();
1356 /* Go to that function to follow the code flow through the simcall barrier */
1357 if (0) simcall_HANDLER_sem_would_block(&self->simcall, sem);
1358 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1360 self->simcall.call = SIMCALL_SEM_WOULD_BLOCK;
1361 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1362 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1363 self->simcall.args[0].dp = (void*) sem;
1364 if (self != simix_global->maestro_process) {
1365 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1366 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1367 SIMIX_process_yield(self);
1369 SIMIX_simcall_handle(&self->simcall, 0);
1371 return (int) self->simcall.result.i;
1374 inline static void simcall_BODY_sem_acquire(smx_sem_t sem) {
1375 smx_process_t self = SIMIX_process_self();
1377 /* Go to that function to follow the code flow through the simcall barrier */
1378 if (0) simcall_HANDLER_sem_acquire(&self->simcall, sem);
1379 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1381 self->simcall.call = SIMCALL_SEM_ACQUIRE;
1382 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1383 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1384 self->simcall.args[0].dp = (void*) sem;
1385 if (self != simix_global->maestro_process) {
1386 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1387 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1388 SIMIX_process_yield(self);
1390 SIMIX_simcall_handle(&self->simcall, 0);
1395 inline static void simcall_BODY_sem_acquire_timeout(smx_sem_t sem, double timeout) {
1396 smx_process_t self = SIMIX_process_self();
1398 /* Go to that function to follow the code flow through the simcall barrier */
1399 if (0) simcall_HANDLER_sem_acquire_timeout(&self->simcall, sem, timeout);
1400 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1402 self->simcall.call = SIMCALL_SEM_ACQUIRE_TIMEOUT;
1403 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1404 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1405 self->simcall.args[0].dp = (void*) sem;
1406 self->simcall.args[1].d = (double) timeout;
1407 if (self != simix_global->maestro_process) {
1408 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1409 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1410 SIMIX_process_yield(self);
1412 SIMIX_simcall_handle(&self->simcall, 0);
1417 inline static int simcall_BODY_sem_get_capacity(smx_sem_t sem) {
1418 smx_process_t self = SIMIX_process_self();
1420 /* Go to that function to follow the code flow through the simcall barrier */
1421 if (0) simcall_HANDLER_sem_get_capacity(&self->simcall, sem);
1422 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1424 self->simcall.call = SIMCALL_SEM_GET_CAPACITY;
1425 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1426 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1427 self->simcall.args[0].dp = (void*) sem;
1428 if (self != simix_global->maestro_process) {
1429 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1430 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1431 SIMIX_process_yield(self);
1433 SIMIX_simcall_handle(&self->simcall, 0);
1435 return (int) self->simcall.result.i;
1438 inline static sg_size_t simcall_BODY_file_read(smx_file_t fd, sg_size_t size, sg_host_t host) {
1439 smx_process_t self = SIMIX_process_self();
1441 /* Go to that function to follow the code flow through the simcall barrier */
1442 if (0) simcall_HANDLER_file_read(&self->simcall, fd, size, host);
1443 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1445 self->simcall.call = SIMCALL_FILE_READ;
1446 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1447 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1448 self->simcall.args[0].dp = (void*) fd;
1449 self->simcall.args[1].sgsz = (sg_size_t) size;
1450 self->simcall.args[2].dp = (void*) host;
1451 if (self != simix_global->maestro_process) {
1452 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1453 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1454 SIMIX_process_yield(self);
1456 SIMIX_simcall_handle(&self->simcall, 0);
1458 return (sg_size_t) self->simcall.result.sgsz;
1461 inline static sg_size_t simcall_BODY_file_write(smx_file_t fd, sg_size_t size, sg_host_t host) {
1462 smx_process_t self = SIMIX_process_self();
1464 /* Go to that function to follow the code flow through the simcall barrier */
1465 if (0) simcall_HANDLER_file_write(&self->simcall, fd, size, host);
1466 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1468 self->simcall.call = SIMCALL_FILE_WRITE;
1469 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1470 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1471 self->simcall.args[0].dp = (void*) fd;
1472 self->simcall.args[1].sgsz = (sg_size_t) size;
1473 self->simcall.args[2].dp = (void*) host;
1474 if (self != simix_global->maestro_process) {
1475 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1476 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1477 SIMIX_process_yield(self);
1479 SIMIX_simcall_handle(&self->simcall, 0);
1481 return (sg_size_t) self->simcall.result.sgsz;
1484 inline static smx_file_t simcall_BODY_file_open(const char* fullpath, sg_host_t host) {
1485 smx_process_t self = SIMIX_process_self();
1487 /* Go to that function to follow the code flow through the simcall barrier */
1488 if (0) simcall_HANDLER_file_open(&self->simcall, fullpath, host);
1489 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1491 self->simcall.call = SIMCALL_FILE_OPEN;
1492 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1493 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1494 self->simcall.args[0].cc = (const char*) fullpath;
1495 self->simcall.args[1].dp = (void*) host;
1496 if (self != simix_global->maestro_process) {
1497 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1498 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1499 SIMIX_process_yield(self);
1501 SIMIX_simcall_handle(&self->simcall, 0);
1503 return (smx_file_t) self->simcall.result.dp;
1506 inline static int simcall_BODY_file_close(smx_file_t fd, sg_host_t host) {
1507 smx_process_t self = SIMIX_process_self();
1509 /* Go to that function to follow the code flow through the simcall barrier */
1510 if (0) simcall_HANDLER_file_close(&self->simcall, fd, host);
1511 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1513 self->simcall.call = SIMCALL_FILE_CLOSE;
1514 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1515 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1516 self->simcall.args[0].dp = (void*) fd;
1517 self->simcall.args[1].dp = (void*) host;
1518 if (self != simix_global->maestro_process) {
1519 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1520 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1521 SIMIX_process_yield(self);
1523 SIMIX_simcall_handle(&self->simcall, 0);
1525 return (int) self->simcall.result.i;
1528 inline static int simcall_BODY_file_unlink(smx_file_t fd, sg_host_t host) {
1529 smx_process_t self = SIMIX_process_self();
1531 /* Go to that function to follow the code flow through the simcall barrier */
1532 if (0) SIMIX_file_unlink(fd, host);
1533 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1535 self->simcall.call = SIMCALL_FILE_UNLINK;
1536 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1537 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1538 self->simcall.args[0].dp = (void*) fd;
1539 self->simcall.args[1].dp = (void*) host;
1540 if (self != simix_global->maestro_process) {
1541 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1542 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1543 SIMIX_process_yield(self);
1545 SIMIX_simcall_handle(&self->simcall, 0);
1547 return (int) self->simcall.result.i;
1550 inline static sg_size_t simcall_BODY_file_get_size(smx_file_t fd) {
1551 smx_process_t self = SIMIX_process_self();
1553 /* Go to that function to follow the code flow through the simcall barrier */
1554 if (0) simcall_HANDLER_file_get_size(&self->simcall, fd);
1555 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1557 self->simcall.call = SIMCALL_FILE_GET_SIZE;
1558 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1559 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1560 self->simcall.args[0].dp = (void*) fd;
1561 if (self != simix_global->maestro_process) {
1562 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1563 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1564 SIMIX_process_yield(self);
1566 SIMIX_simcall_handle(&self->simcall, 0);
1568 return (sg_size_t) self->simcall.result.sgsz;
1571 inline static sg_size_t simcall_BODY_file_tell(smx_file_t fd) {
1572 smx_process_t self = SIMIX_process_self();
1574 /* Go to that function to follow the code flow through the simcall barrier */
1575 if (0) simcall_HANDLER_file_tell(&self->simcall, fd);
1576 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1578 self->simcall.call = SIMCALL_FILE_TELL;
1579 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1580 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1581 self->simcall.args[0].dp = (void*) fd;
1582 if (self != simix_global->maestro_process) {
1583 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1584 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1585 SIMIX_process_yield(self);
1587 SIMIX_simcall_handle(&self->simcall, 0);
1589 return (sg_size_t) self->simcall.result.sgsz;
1592 inline static int simcall_BODY_file_seek(smx_file_t fd, sg_offset_t offset, int origin) {
1593 smx_process_t self = SIMIX_process_self();
1595 /* Go to that function to follow the code flow through the simcall barrier */
1596 if (0) simcall_HANDLER_file_seek(&self->simcall, fd, offset, origin);
1597 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1599 self->simcall.call = SIMCALL_FILE_SEEK;
1600 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1601 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1602 self->simcall.args[0].dp = (void*) fd;
1603 self->simcall.args[1].sgoff = (sg_offset_t) offset;
1604 self->simcall.args[2].i = (int) origin;
1605 if (self != simix_global->maestro_process) {
1606 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1607 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1608 SIMIX_process_yield(self);
1610 SIMIX_simcall_handle(&self->simcall, 0);
1612 return (int) self->simcall.result.i;
1615 inline static xbt_dynar_t simcall_BODY_file_get_info(smx_file_t fd) {
1616 smx_process_t self = SIMIX_process_self();
1618 /* Go to that function to follow the code flow through the simcall barrier */
1619 if (0) simcall_HANDLER_file_get_info(&self->simcall, fd);
1620 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1622 self->simcall.call = SIMCALL_FILE_GET_INFO;
1623 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1624 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1625 self->simcall.args[0].dp = (void*) fd;
1626 if (self != simix_global->maestro_process) {
1627 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1628 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1629 SIMIX_process_yield(self);
1631 SIMIX_simcall_handle(&self->simcall, 0);
1633 return (xbt_dynar_t) self->simcall.result.dp;
1636 inline static int simcall_BODY_file_move(smx_file_t fd, const char* fullpath) {
1637 smx_process_t self = SIMIX_process_self();
1639 /* Go to that function to follow the code flow through the simcall barrier */
1640 if (0) simcall_HANDLER_file_move(&self->simcall, fd, fullpath);
1641 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1643 self->simcall.call = SIMCALL_FILE_MOVE;
1644 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1645 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1646 self->simcall.args[0].dp = (void*) fd;
1647 self->simcall.args[1].cc = (const char*) fullpath;
1648 if (self != simix_global->maestro_process) {
1649 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1650 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1651 SIMIX_process_yield(self);
1653 SIMIX_simcall_handle(&self->simcall, 0);
1655 return (int) self->simcall.result.i;
1658 inline static sg_size_t simcall_BODY_storage_get_free_size(smx_storage_t storage) {
1659 smx_process_t self = SIMIX_process_self();
1661 /* Go to that function to follow the code flow through the simcall barrier */
1662 if (0) simcall_HANDLER_storage_get_free_size(&self->simcall, storage);
1663 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1665 self->simcall.call = SIMCALL_STORAGE_GET_FREE_SIZE;
1666 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1667 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1668 self->simcall.args[0].dp = (void*) storage;
1669 if (self != simix_global->maestro_process) {
1670 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1671 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1672 SIMIX_process_yield(self);
1674 SIMIX_simcall_handle(&self->simcall, 0);
1676 return (sg_size_t) self->simcall.result.sgsz;
1679 inline static sg_size_t simcall_BODY_storage_get_used_size(smx_storage_t name) {
1680 smx_process_t self = SIMIX_process_self();
1682 /* Go to that function to follow the code flow through the simcall barrier */
1683 if (0) simcall_HANDLER_storage_get_used_size(&self->simcall, name);
1684 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1686 self->simcall.call = SIMCALL_STORAGE_GET_USED_SIZE;
1687 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1688 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1689 self->simcall.args[0].dp = (void*) name;
1690 if (self != simix_global->maestro_process) {
1691 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1692 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1693 SIMIX_process_yield(self);
1695 SIMIX_simcall_handle(&self->simcall, 0);
1697 return (sg_size_t) self->simcall.result.sgsz;
1700 inline static xbt_dict_t simcall_BODY_storage_get_properties(smx_storage_t storage) {
1701 smx_process_t self = SIMIX_process_self();
1703 /* Go to that function to follow the code flow through the simcall barrier */
1704 if (0) SIMIX_storage_get_properties(storage);
1705 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1707 self->simcall.call = SIMCALL_STORAGE_GET_PROPERTIES;
1708 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1709 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1710 self->simcall.args[0].dp = (void*) storage;
1711 if (self != simix_global->maestro_process) {
1712 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1713 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1714 SIMIX_process_yield(self);
1716 SIMIX_simcall_handle(&self->simcall, 0);
1718 return (xbt_dict_t) self->simcall.result.dp;
1721 inline static xbt_dict_t simcall_BODY_storage_get_content(smx_storage_t storage) {
1722 smx_process_t self = SIMIX_process_self();
1724 /* Go to that function to follow the code flow through the simcall barrier */
1725 if (0) SIMIX_storage_get_content(storage);
1726 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1728 self->simcall.call = SIMCALL_STORAGE_GET_CONTENT;
1729 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1730 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1731 self->simcall.args[0].dp = (void*) storage;
1732 if (self != simix_global->maestro_process) {
1733 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1734 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1735 SIMIX_process_yield(self);
1737 SIMIX_simcall_handle(&self->simcall, 0);
1739 return (xbt_dict_t) self->simcall.result.dp;
1742 inline static xbt_dict_t simcall_BODY_asr_get_properties(const char* name) {
1743 smx_process_t self = SIMIX_process_self();
1745 /* Go to that function to follow the code flow through the simcall barrier */
1746 if (0) simcall_HANDLER_asr_get_properties(&self->simcall, name);
1747 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1749 self->simcall.call = SIMCALL_ASR_GET_PROPERTIES;
1750 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1751 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1752 self->simcall.args[0].cc = (const char*) name;
1753 if (self != simix_global->maestro_process) {
1754 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1755 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1756 SIMIX_process_yield(self);
1758 SIMIX_simcall_handle(&self->simcall, 0);
1760 return (xbt_dict_t) self->simcall.result.dp;
1763 inline static int simcall_BODY_mc_random(int min, int max) {
1764 smx_process_t self = SIMIX_process_self();
1766 /* Go to that function to follow the code flow through the simcall barrier */
1767 if (0) simcall_HANDLER_mc_random(&self->simcall, min, max);
1768 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1770 self->simcall.call = SIMCALL_MC_RANDOM;
1771 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1772 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1773 self->simcall.args[0].i = (int) min;
1774 self->simcall.args[1].i = (int) max;
1775 if (self != simix_global->maestro_process) {
1776 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1777 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1778 SIMIX_process_yield(self);
1780 SIMIX_simcall_handle(&self->simcall, 0);
1782 return (int) self->simcall.result.i;
1785 inline static void simcall_BODY_set_category(smx_synchro_t synchro, const char* category) {
1786 smx_process_t self = SIMIX_process_self();
1788 /* Go to that function to follow the code flow through the simcall barrier */
1789 if (0) SIMIX_set_category(synchro, category);
1790 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1792 self->simcall.call = SIMCALL_SET_CATEGORY;
1793 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1794 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1795 self->simcall.args[0].dp = (void*) synchro;
1796 self->simcall.args[1].cc = (const char*) category;
1797 if (self != simix_global->maestro_process) {
1798 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1799 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1800 SIMIX_process_yield(self);
1802 SIMIX_simcall_handle(&self->simcall, 0);
1807 inline static void simcall_BODY_run_kernel(void* code) {
1808 smx_process_t self = SIMIX_process_self();
1810 /* Go to that function to follow the code flow through the simcall barrier */
1811 if (0) SIMIX_run_kernel(code);
1812 /* end of the guide intended to the poor programmer wanting to go from MSG to Surf */
1814 self->simcall.call = SIMCALL_RUN_KERNEL;
1815 memset(&self->simcall.result, 0, sizeof(self->simcall.result));
1816 memset(self->simcall.args, 0, sizeof(self->simcall.args));
1817 self->simcall.args[0].dp = (void*) code;
1818 if (self != simix_global->maestro_process) {
1819 XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
1820 SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
1821 SIMIX_process_yield(self);
1823 SIMIX_simcall_handle(&self->simcall, 0);