Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
91af60dd202ab0f1cdd755e49b9e60ecd667968e
[simgrid.git] / src / simix / smx_smurf_private.h
1 /* Copyright (c) 2007, 2008, 2009, 2010. The SimGrid Team.
2  * All rights reserved.                                                     */
3
4 /* This program is free software; you can redistribute it and/or modify it
5  * under the terms of the license (GNU LGPL) which comes with this package. */
6
7 #ifndef _SIMIX_SMURF_PRIVATE_H
8 #define _SIMIX_SMURF_PRIVATE_H
9
10 /********************************* Simcalls *********************************/
11
12 /* we want to build the e_smx_simcall_t enumeration and the table of the
13  * corresponding strings automatically, using macros */
14
15 #define SIMCALL_LIST1 \
16 SIMCALL_ENUM_ELEMENT(SIMCALL_NONE),\
17 SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_GET_BY_NAME),\
18 SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_GET_NAME),\
19 SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_GET_PROPERTIES),\
20 SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_GET_SPEED),\
21 SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_GET_AVAILABLE_SPEED),\
22 SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_GET_STATE),\
23 SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_GET_DATA),\
24 SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_SET_DATA),\
25 SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_EXECUTE),\
26 SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_PARALLEL_EXECUTE),\
27 SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_EXECUTION_DESTROY),\
28 SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_EXECUTION_CANCEL),\
29 SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_EXECUTION_GET_REMAINS),\
30 SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_EXECUTION_GET_STATE),\
31 SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_EXECUTION_SET_PRIORITY),\
32 SIMCALL_ENUM_ELEMENT(SIMCALL_HOST_EXECUTION_WAIT),\
33 SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_CREATE),\
34 SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_KILL),\
35 SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_KILLALL),\
36 SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_CLEANUP),\
37 SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_CHANGE_HOST),\
38 SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_SUSPEND),\
39 SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_RESUME),\
40 SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_COUNT),\
41 SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_GET_DATA),\
42 SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_SET_DATA),\
43 SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_GET_HOST),\
44 SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_GET_NAME),\
45 SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_IS_SUSPENDED),\
46 SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_GET_PROPERTIES),\
47 SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_SLEEP),\
48 SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_ON_EXIT),\
49 SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_AUTO_RESTART_SET),\
50 SIMCALL_ENUM_ELEMENT(SIMCALL_PROCESS_RESTART),\
51 SIMCALL_ENUM_ELEMENT(SIMCALL_RDV_CREATE),\
52 SIMCALL_ENUM_ELEMENT(SIMCALL_RDV_DESTROY),\
53 SIMCALL_ENUM_ELEMENT(SIMCALL_RDV_GEY_BY_NAME),\
54 SIMCALL_ENUM_ELEMENT(SIMCALL_RDV_COMM_COUNT_BY_HOST),\
55 SIMCALL_ENUM_ELEMENT(SIMCALL_RDV_GET_HEAD),\
56 SIMCALL_ENUM_ELEMENT(SIMCALL_RDV_SET_RECV),\
57 SIMCALL_ENUM_ELEMENT(SIMCALL_RDV_GET_RECV),\
58 SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_SEND),\
59 SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_ISEND),\
60 SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_RECV),\
61 SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_IRECV),\
62 SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_DESTROY),\
63 SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_CANCEL),\
64 SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_WAITANY),\
65 SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_WAIT),\
66 SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_TEST),\
67 SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_TESTANY),\
68 SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_IPROBE),\
69 SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_GET_REMAINS),\
70 SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_GET_STATE),\
71 SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_GET_SRC_DATA),\
72 SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_GET_DST_DATA),\
73 SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_GET_SRC_PROC),\
74 SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_GET_DST_PROC),\
75 SIMCALL_ENUM_ELEMENT(SIMCALL_MUTEX_INIT),\
76 SIMCALL_ENUM_ELEMENT(SIMCALL_MUTEX_DESTROY),\
77 SIMCALL_ENUM_ELEMENT(SIMCALL_MUTEX_LOCK),\
78 SIMCALL_ENUM_ELEMENT(SIMCALL_MUTEX_TRYLOCK),\
79 SIMCALL_ENUM_ELEMENT(SIMCALL_MUTEX_UNLOCK),\
80 SIMCALL_ENUM_ELEMENT(SIMCALL_COND_INIT),\
81 SIMCALL_ENUM_ELEMENT(SIMCALL_COND_DESTROY),\
82 SIMCALL_ENUM_ELEMENT(SIMCALL_COND_SIGNAL),\
83 SIMCALL_ENUM_ELEMENT(SIMCALL_COND_WAIT),\
84 SIMCALL_ENUM_ELEMENT(SIMCALL_COND_WAIT_TIMEOUT),\
85 SIMCALL_ENUM_ELEMENT(SIMCALL_COND_BROADCAST),\
86 SIMCALL_ENUM_ELEMENT(SIMCALL_SEM_INIT),\
87 SIMCALL_ENUM_ELEMENT(SIMCALL_SEM_DESTROY),\
88 SIMCALL_ENUM_ELEMENT(SIMCALL_SEM_RELEASE),\
89 SIMCALL_ENUM_ELEMENT(SIMCALL_SEM_WOULD_BLOCK),\
90 SIMCALL_ENUM_ELEMENT(SIMCALL_SEM_ACQUIRE),\
91 SIMCALL_ENUM_ELEMENT(SIMCALL_SEM_ACQUIRE_TIMEOUT),\
92 SIMCALL_ENUM_ELEMENT(SIMCALL_SEM_GET_CAPACITY),\
93 SIMCALL_ENUM_ELEMENT(SIMCALL_FILE_READ),\
94 SIMCALL_ENUM_ELEMENT(SIMCALL_FILE_WRITE),\
95 SIMCALL_ENUM_ELEMENT(SIMCALL_FILE_OPEN),\
96 SIMCALL_ENUM_ELEMENT(SIMCALL_FILE_CLOSE),\
97 SIMCALL_ENUM_ELEMENT(SIMCALL_FILE_STAT), \
98 SIMCALL_ENUM_ELEMENT(SIMCALL_FILE_UNLINK),\
99 SIMCALL_ENUM_ELEMENT(SIMCALL_FILE_LS),\
100 SIMCALL_ENUM_ELEMENT(SIMCALL_ASR_GET_PROPERTIES), \
101 /* ****************************************************************************************** */ \
102 /* TUTORIAL: New API                                                                        */ \
103 /* ****************************************************************************************** */ \
104 SIMCALL_ENUM_ELEMENT(SIMCALL_NEW_API_INIT)
105
106 /* SIMCALL_COMM_IS_LATENCY_BOUNDED and SIMCALL_SET_CATEGORY make things complicated
107  * because they are not always present */
108 #ifdef HAVE_LATENCY_BOUND_TRACKING
109 #define SIMCALL_LIST2 \
110 ,SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_IS_LATENCY_BOUNDED)
111 #else
112 #define SIMCALL_LIST2
113 #endif
114
115 #ifdef HAVE_TRACING
116 #define SIMCALL_LIST3 \
117 ,SIMCALL_ENUM_ELEMENT(SIMCALL_SET_CATEGORY)
118 #else
119 #define SIMCALL_LIST3
120 #endif
121
122 #ifdef HAVE_MC
123 #define SIMCALL_LIST4                                        \
124   ,SIMCALL_ENUM_ELEMENT(SIMCALL_MC_SNAPSHOT)                 \
125   ,SIMCALL_ENUM_ELEMENT(SIMCALL_MC_COMPARE_SNAPSHOTS)
126 #else
127 #define SIMCALL_LIST4
128 #endif
129
130 /* SIMCALL_LIST is the final macro to use */
131 #define SIMCALL_LIST SIMCALL_LIST1 SIMCALL_LIST2 SIMCALL_LIST3 SIMCALL_LIST4
132
133 /* you can redefine the following macro differently to generate something else
134  * with the list of enumeration values (e.g. a table of strings or a table of function pointers) */
135 #define SIMCALL_ENUM_ELEMENT(x) x
136
137 /**
138  * \brief All possible simcalls.
139  */
140 typedef enum {
141 SIMCALL_LIST
142 } e_smx_simcall_t;
143
144 /**
145  * \brief Represents a simcall to the kernel.
146  */
147 typedef struct s_smx_simcall {
148   e_smx_simcall_t call;
149   smx_process_t issuer;
150
151   union {
152
153     struct {
154       const char *name;
155       smx_host_t result;
156     } host_get_by_name;
157
158     struct {
159       smx_host_t host;
160       const char* result;
161     } host_get_name;
162
163     struct {
164       smx_host_t host;
165       xbt_dict_t result;
166     } host_get_properties;
167
168     struct {
169       smx_host_t host;
170       double result;
171     } host_get_speed;
172
173     struct {
174       smx_host_t host;
175       double result;
176     } host_get_available_speed;
177
178     struct {
179       smx_host_t host;
180       int result;
181     } host_get_state;
182
183     struct {
184       smx_host_t host;
185       void* result;
186     } host_get_data;
187
188     struct {
189       smx_host_t host;
190       void* data;
191     } host_set_data;
192
193     struct {
194       const char* name;
195       smx_host_t host;
196       double computation_amount;
197       double priority;
198       smx_action_t result;
199     } host_execute;
200
201     struct {
202       const char *name;
203       int host_nb;
204       smx_host_t *host_list;
205       double *computation_amount;
206       double *communication_amount;
207       double amount;
208       double rate;
209       smx_action_t result;
210     } host_parallel_execute;
211
212     struct {
213       smx_action_t execution;
214     } host_execution_destroy;
215
216     struct {
217       smx_action_t execution;
218     } host_execution_cancel;
219
220     struct {
221       smx_action_t execution;
222       double result;
223     } host_execution_get_remains;
224
225     struct {
226       smx_action_t execution;
227       e_smx_state_t result;
228     } host_execution_get_state;
229
230     struct {
231       smx_action_t execution;
232       double priority;
233     } host_execution_set_priority;
234
235     struct {
236       smx_action_t execution;
237       e_smx_state_t result;
238     } host_execution_wait;
239
240     struct {
241       smx_process_t *process;
242       const char *name;
243       xbt_main_func_t code;
244       void *data;
245       const char *hostname;
246       double kill_time;
247       int argc;
248       char **argv;
249       xbt_dict_t properties;
250       int auto_restart;
251     } process_create;
252
253     struct {
254       smx_process_t process;
255     } process_kill;
256
257     struct {
258       smx_process_t process;
259     } process_cleanup;
260
261     struct {
262       smx_process_t process;
263       smx_host_t dest;
264     } process_change_host;
265
266     struct {
267       smx_process_t process;
268     } process_suspend;
269
270     struct {
271       smx_process_t process;
272     } process_resume;
273
274     struct {
275       int result;
276     } process_count;
277
278     struct {
279       smx_process_t process;
280       void* result;
281     } process_get_data;
282
283     struct {
284       smx_process_t process;
285       void* data;
286     } process_set_data;
287
288     struct {
289       smx_process_t process;
290       smx_host_t result;
291     } process_get_host;
292
293     struct {
294       smx_process_t process;
295       const char *result;
296     } process_get_name;
297
298     struct {
299       smx_process_t process;
300       int result;
301     } process_is_suspended;
302
303     struct {
304       smx_process_t process;
305       xbt_dict_t result;
306     } process_get_properties;
307
308     struct {
309       double duration;
310       e_smx_state_t result;
311     } process_sleep;
312
313     struct {
314       smx_process_t process;
315       int_f_pvoid_t fun;
316       void *data;
317     } process_on_exit;
318
319     struct {
320       smx_process_t process;
321       int auto_restart;
322     } process_auto_restart;
323
324     struct {
325       smx_process_t process;
326       smx_process_t result;
327     } process_restart;
328
329     struct {
330       const char *name;
331       smx_rdv_t result;
332     } rdv_create;
333
334     struct {
335       smx_rdv_t rdv;
336     } rdv_destroy;
337
338     struct {
339       const char* name;
340       smx_rdv_t result;
341     } rdv_get_by_name;
342
343     struct {
344       smx_rdv_t rdv;
345       smx_host_t host;
346       unsigned int result; 
347     } rdv_comm_count_by_host;
348
349     struct {
350       smx_rdv_t rdv;
351       smx_action_t result;
352     } rdv_get_head;
353
354     struct {
355       smx_rdv_t rdv;
356       smx_process_t receiver;
357     } rdv_set_rcv_proc;
358
359     struct {
360       smx_rdv_t rdv;
361       smx_process_t result;
362     } rdv_get_rcv_proc;
363
364     struct {
365       smx_rdv_t rdv;
366       double task_size;
367       double rate;
368       void *src_buff;
369       size_t src_buff_size;
370       int (*match_fun)(void *, void *, smx_action_t);
371       void *data;
372       double timeout;
373     } comm_send;
374
375     struct {
376       smx_rdv_t rdv;
377       double task_size;
378       double rate;
379       void *src_buff;
380       size_t src_buff_size;
381       int (*match_fun)(void *, void *, smx_action_t);
382       void (*clean_fun)(void *);
383       void *data;
384       int detached;
385       smx_action_t result;
386     } comm_isend;
387
388     struct {
389       smx_rdv_t rdv;
390       void *dst_buff;
391       size_t *dst_buff_size;
392       int (*match_fun)(void *, void *, smx_action_t);
393       void *data;
394       double timeout;
395     } comm_recv;
396
397     struct {
398       smx_rdv_t rdv;
399       void *dst_buff;
400       size_t *dst_buff_size;
401       int (*match_fun)(void *, void *, smx_action_t);
402       void *data;
403       smx_action_t result;
404     } comm_irecv;
405
406     struct {
407       smx_rdv_t rdv;
408       int src;
409       int tag;
410       int (*match_fun)(void *, void *, smx_action_t);
411       void *data;
412       smx_action_t result;
413     } comm_iprobe;
414
415     struct {
416       smx_action_t comm;
417     } comm_destroy;
418
419     struct {
420       smx_action_t comm;
421     } comm_cancel;
422
423     struct {
424       xbt_dynar_t comms;
425       unsigned int result;
426     } comm_waitany;
427
428     struct {
429       smx_action_t comm;
430       double timeout;
431     } comm_wait;
432
433     struct {
434       smx_action_t comm;
435       int result;
436     } comm_test;
437
438     struct {
439       xbt_dynar_t comms;
440       int result;
441     } comm_testany;
442
443     struct {
444       smx_action_t comm;
445       double result;
446     } comm_get_remains;
447
448     struct {
449       smx_action_t comm;
450       e_smx_state_t result;
451     } comm_get_state;
452
453     struct {
454       smx_action_t comm;
455       void *result;
456     } comm_get_src_data;
457
458     struct {
459       smx_action_t comm;
460       void *result;
461     } comm_get_dst_data;
462
463     struct {
464       smx_action_t comm;
465       smx_process_t result;
466     } comm_get_src_proc;
467
468     struct {
469       smx_action_t comm;
470       smx_process_t result;
471     } comm_get_dst_proc;
472
473 #ifdef HAVE_LATENCY_BOUND_TRACKING
474     struct {
475       smx_action_t comm;
476       int result;
477     } comm_is_latency_bounded;
478 #endif
479
480 #ifdef HAVE_TRACING
481     struct {
482       smx_action_t action;
483       const char *category;
484     } set_category;
485 #endif
486
487     struct {
488       smx_mutex_t result;
489     } mutex_init;
490
491     struct {
492       smx_mutex_t mutex;
493     } mutex_lock;
494
495     struct {
496       smx_mutex_t mutex;
497       int result;
498     } mutex_trylock;
499
500     struct {
501       smx_mutex_t mutex;
502     } mutex_unlock;
503
504     struct {
505       smx_mutex_t mutex;
506     } mutex_destroy;
507
508     struct {
509       smx_cond_t result;
510     } cond_init;
511
512     struct {
513       smx_cond_t cond;
514     } cond_destroy;
515
516     struct {
517       smx_cond_t cond;
518     } cond_signal;
519
520     struct {
521       smx_cond_t cond;
522       smx_mutex_t mutex;
523     } cond_wait;
524
525     struct {
526       smx_cond_t cond;
527       smx_mutex_t mutex;
528       double timeout;
529     } cond_wait_timeout;
530
531     struct {
532       smx_cond_t cond;
533     } cond_broadcast;
534
535     struct {
536       int capacity;
537       smx_sem_t result;
538     } sem_init;
539
540     struct {
541       smx_sem_t sem;
542     } sem_destroy;
543
544     struct {
545       smx_sem_t sem;
546     } sem_release;
547
548     struct {
549       smx_sem_t sem;
550       int result;
551     } sem_would_block;
552
553     struct {
554       smx_sem_t sem;
555     } sem_acquire;
556
557     struct {
558       smx_sem_t sem;
559       double timeout;
560     } sem_acquire_timeout;
561
562     struct {
563       smx_sem_t sem;
564       int result;
565     } sem_get_capacity;
566
567     struct {
568       void *ptr;
569       size_t size;
570       size_t nmemb;
571       smx_file_t stream;
572       double result;
573     } file_read;
574
575     struct {
576       const void *ptr;
577       size_t size;
578       size_t nmemb;
579       smx_file_t stream;
580       size_t result;
581     } file_write;
582
583     struct {
584       const char* mount;
585       const char* path;
586       const char* mode;
587       smx_file_t result;
588     } file_open;
589
590     struct {
591       smx_file_t fp;
592       int result;
593     } file_close;
594
595     struct {
596       smx_file_t fd;
597       s_file_stat_t buf;
598       int result;
599     } file_stat;
600
601     struct {
602       smx_file_t fd;
603       int result;
604     } file_unlink;
605
606     struct {
607       const char *mount;
608       const char *path;
609       xbt_dict_t result;
610     } file_ls;
611
612     struct {
613       const char* name;
614       xbt_dict_t result;
615     } asr_get_properties;
616
617     struct{
618       void *s;
619     } mc_snapshot;
620
621     struct{
622       void *snapshot1;
623       void *snapshot2;
624       int result;
625     } mc_compare_snapshots;
626
627     /* ****************************************************************************************** */
628     /* TUTORIAL: New API                                                                        */
629     /* ****************************************************************************************** */
630     struct {
631       const char* param1;
632       double param2;
633       int result;
634     } new_api;
635
636   };
637 } s_smx_simcall_t, *smx_simcall_t;
638
639 /******************************** General *************************************/
640
641 void SIMIX_simcall_push(smx_process_t self);
642 void SIMIX_simcall_answer(smx_simcall_t);
643 void SIMIX_simcall_pre(smx_simcall_t, int);
644 void SIMIX_simcall_post(smx_action_t);
645 smx_simcall_t SIMIX_simcall_mine(void);
646 const char *SIMIX_simcall_name(e_smx_simcall_t kind);
647
648 /*************************** New simcall interface ****************************/
649
650 /* Pack all possible scalar types in an union */
651 typedef union {
652   char            c;
653   short           s;
654   int             i;
655   long            l;
656   unsigned char   uc;
657   unsigned short  us;
658   unsigned int    ui;
659   unsigned long   ul;
660   float           f;
661   double          d;
662   void            *p;
663 } u_smx_scalar_t;
664
665 /*
666  * Define scalar type wrappers to ease the use of simcalls.
667  * These are used to wrap the arguments in SIMIX_simcall macro.
668  */
669 #define CHAR(x) (c,x)
670 #define SHORT(x) (s,x)
671 #define INT(x) (i,x)
672 #define LONG(x) (l,x)
673 #define UCHAR(x) (uc,x)
674 #define USHORT(x) (us,x)
675 #define UINT(x) (ui,x)
676 #define ULONG(x) (ul,x)
677 #define FLOAT(x) (f,x)
678 #define DOUBLE(x) (d,x)
679 #define PTR(x)  (p,x)
680
681 /*
682  * Some macro machinery to get a MAP over the arguments of a variadic macro.
683  * It uses a FOLD to apply a macro to every argument, and because there is
684  * no recursion in the C preprocessor we must create a new macro for every
685  * depth of FOLD's recursion.
686  */
687
688 /* FOLD macro */
689 #define FE_1(WHAT, X) WHAT(X)
690 #define FE_2(WHAT, X, ...) WHAT(X), FE_1(WHAT, __VA_ARGS__)
691 #define FE_3(WHAT, X, ...) WHAT(X), FE_2(WHAT, __VA_ARGS__)
692 #define FE_4(WHAT, X, ...) WHAT(X), FE_3(WHAT, __VA_ARGS__)
693 #define FE_5(WHAT, X, ...) WHAT(X), FE_4(WHAT, __VA_ARGS__)
694 /* NOTE: add as many FE_n as needed (maximum number of simcall arguments )*/
695
696 /* Make a MAP macro usgin FOLD (will apply 'action' to the arguments.
697  * GET_MACRO is a smart hack that counts the number of arguments passed to
698  * the variadic macro, and it is used to invoke the right FOLD depth.
699  */
700 #define GET_MACRO(_1,_2,_3,_4,_5,NAME,...) NAME
701 #define MAP(action,...) \
702   GET_MACRO(__VA_ARGS__,FE_5,FE_4,FE_3,FE_2,FE_1) (action, __VA_ARGS__)
703
704
705 /* Generate code to initialize the field 'x' with value 'y' of an structure or union */
706 #define INIT_FIELD_(x,y) {.x = y}
707 #define INIT_FIELD(t) INIT_FIELD t
708
709 /* Project the second element of a tuple */
710 #define SECOND_(x, y) y
711 #define SECOND(t) SECOND_ t
712
713 /*
714  * \brief Simcall invocation macro
715  * It calls a dummy function that uses the format attribute to ensure typesafety (see
716  * gcc format attribute), then it invokes the real simcall function packing the
717  * user provided arguments in an array.
718  * \param id a simcall id (from the simcall enumeration ids)
719  *
720  */
721 #define SIMIX_simcall(id, ...) \
722   SIMIX_simcall_typecheck(simcall_types[id], MAP(SECOND, __VA_ARGS__)); \
723   __SIMIX_simcall(id, (mytype_t[]){MAP(INIT_FIELD, __VA_ARGS__)})
724
725 void __SIMIX_simcall(e_smx_simcall_t simcall_id, u_smx_scalar_t *args);
726
727 /*
728  * \biref Dummy variadic function used to typecheck the arguments of a simcall
729  * \param fmt A format string following printf style
730  */
731 void SIMIX_simcall_typecheck(const char *fmt, ...) __attribute__ ((format (printf, 1, 2)));
732
733
734 #endif
735