Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Implement file open read and stat in simix.
[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_RDV_CREATE),\
49 SIMCALL_ENUM_ELEMENT(SIMCALL_RDV_DESTROY),\
50 SIMCALL_ENUM_ELEMENT(SIMCALL_RDV_GEY_BY_NAME),\
51 SIMCALL_ENUM_ELEMENT(SIMCALL_RDV_COMM_COUNT_BY_HOST),\
52 SIMCALL_ENUM_ELEMENT(SIMCALL_RDV_GET_HEAD),\
53 SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_SEND),\
54 SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_ISEND),\
55 SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_RECV),\
56 SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_IRECV),\
57 SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_DESTROY),\
58 SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_CANCEL),\
59 SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_WAITANY),\
60 SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_WAIT),\
61 SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_TEST),\
62 SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_TESTANY),\
63 SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_GET_REMAINS),\
64 SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_GET_STATE),\
65 SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_GET_SRC_DATA),\
66 SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_GET_DST_DATA),\
67 SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_GET_SRC_PROC),\
68 SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_GET_DST_PROC),\
69 SIMCALL_ENUM_ELEMENT(SIMCALL_MUTEX_INIT),\
70 SIMCALL_ENUM_ELEMENT(SIMCALL_MUTEX_DESTROY),\
71 SIMCALL_ENUM_ELEMENT(SIMCALL_MUTEX_LOCK),\
72 SIMCALL_ENUM_ELEMENT(SIMCALL_MUTEX_TRYLOCK),\
73 SIMCALL_ENUM_ELEMENT(SIMCALL_MUTEX_UNLOCK),\
74 SIMCALL_ENUM_ELEMENT(SIMCALL_COND_INIT),\
75 SIMCALL_ENUM_ELEMENT(SIMCALL_COND_DESTROY),\
76 SIMCALL_ENUM_ELEMENT(SIMCALL_COND_SIGNAL),\
77 SIMCALL_ENUM_ELEMENT(SIMCALL_COND_WAIT),\
78 SIMCALL_ENUM_ELEMENT(SIMCALL_COND_WAIT_TIMEOUT),\
79 SIMCALL_ENUM_ELEMENT(SIMCALL_COND_BROADCAST),\
80 SIMCALL_ENUM_ELEMENT(SIMCALL_SEM_INIT),\
81 SIMCALL_ENUM_ELEMENT(SIMCALL_SEM_DESTROY),\
82 SIMCALL_ENUM_ELEMENT(SIMCALL_SEM_RELEASE),\
83 SIMCALL_ENUM_ELEMENT(SIMCALL_SEM_WOULD_BLOCK),\
84 SIMCALL_ENUM_ELEMENT(SIMCALL_SEM_ACQUIRE),\
85 SIMCALL_ENUM_ELEMENT(SIMCALL_SEM_ACQUIRE_TIMEOUT),\
86 SIMCALL_ENUM_ELEMENT(SIMCALL_SEM_GET_CAPACITY),\
87 SIMCALL_ENUM_ELEMENT(SIMCALL_FILE_READ),\
88 SIMCALL_ENUM_ELEMENT(SIMCALL_FILE_WRITE),\
89 SIMCALL_ENUM_ELEMENT(SIMCALL_FILE_OPEN),\
90 SIMCALL_ENUM_ELEMENT(SIMCALL_FILE_CLOSE),\
91 SIMCALL_ENUM_ELEMENT(SIMCALL_FILE_STAT)
92
93
94 /* SIMCALL_COMM_IS_LATENCY_BOUNDED and SIMCALL_SET_CATEGORY make things complicated
95  * because they are not always present */
96 #ifdef HAVE_LATENCY_BOUND_TRACKING
97 #define SIMCALL_LIST2 \
98 ,SIMCALL_ENUM_ELEMENT(SIMCALL_COMM_IS_LATENCY_BOUNDED)
99 #else
100 #define SIMCALL_LIST2
101 #endif
102
103 #ifdef HAVE_TRACING
104 #define SIMCALL_LIST3 \
105 ,SIMCALL_ENUM_ELEMENT(SIMCALL_SET_CATEGORY)
106 #else
107 #define SIMCALL_LIST3
108 #endif
109
110 /* SIMCALL_LIST is the final macro to use */
111 #define SIMCALL_LIST SIMCALL_LIST1 SIMCALL_LIST2 SIMCALL_LIST3
112
113 /* you can redefine the following macro differently to generate something else
114  * with the list of enumeration values (e.g. a table of strings or a table of function pointers) */
115 #define SIMCALL_ENUM_ELEMENT(x) x
116
117 /**
118  * \brief All possible simcalls.
119  */
120 typedef enum {
121 SIMCALL_LIST
122 } e_smx_simcall_t;
123
124 /**
125  * \brief Represents a simcall to the kernel.
126  */
127 typedef struct s_smx_simcall {
128   e_smx_simcall_t call;
129   smx_process_t issuer;
130
131   union {
132
133     struct {
134       const char *name;
135       smx_host_t result;
136     } host_get_by_name;
137
138     struct {
139       smx_host_t host;
140       const char* result;
141     } host_get_name;
142
143     struct {
144       smx_host_t host;
145       xbt_dict_t result;
146     } host_get_properties;
147
148     struct {
149       smx_host_t host;
150       double result;
151     } host_get_speed;
152
153     struct {
154       smx_host_t host;
155       double result;
156     } host_get_available_speed;
157
158     struct {
159       smx_host_t host;
160       int result;
161     } host_get_state;
162
163     struct {
164       smx_host_t host;
165       void* result;
166     } host_get_data;
167
168     struct {
169       smx_host_t host;
170       void* data;
171     } host_set_data;
172
173     struct {
174       const char* name;
175       smx_host_t host;
176       double computation_amount;
177       double priority;
178       smx_action_t result;
179     } host_execute;
180
181     struct {
182       const char *name;
183       int host_nb;
184       smx_host_t *host_list;
185       double *computation_amount;
186       double *communication_amount;
187       double amount;
188       double rate;
189       smx_action_t result;
190     } host_parallel_execute;
191
192     struct {
193       smx_action_t execution;
194     } host_execution_destroy;
195
196     struct {
197       smx_action_t execution;
198     } host_execution_cancel;
199
200     struct {
201       smx_action_t execution;
202       double result;
203     } host_execution_get_remains;
204
205     struct {
206       smx_action_t execution;
207       e_smx_state_t result;
208     } host_execution_get_state;
209
210     struct {
211       smx_action_t execution;
212       double priority;
213     } host_execution_set_priority;
214
215     struct {
216       smx_action_t execution;
217       e_smx_state_t result;
218     } host_execution_wait;
219
220     struct {
221       smx_process_t *process;
222       const char *name;
223       xbt_main_func_t code;
224       void *data;
225       const char *hostname;
226       int argc;
227       char **argv;
228       xbt_dict_t properties;
229     } process_create;
230
231     struct {
232       smx_process_t process;
233     } process_kill;
234
235     struct {
236       smx_process_t process;
237     } process_cleanup;
238
239     struct {
240       smx_process_t process;
241       smx_host_t dest;
242     } process_change_host;
243
244     struct {
245       smx_process_t process;
246     } process_suspend;
247
248     struct {
249       smx_process_t process;
250     } process_resume;
251
252     struct {
253       int result;
254     } process_count;
255
256     struct {
257       smx_process_t process;
258       void* result;
259     } process_get_data;
260
261     struct {
262       smx_process_t process;
263       void* data;
264     } process_set_data;
265
266     struct {
267       smx_process_t process;
268       smx_host_t result;
269     } process_get_host;
270
271     struct {
272       smx_process_t process;
273       const char *result;
274     } process_get_name;
275
276     struct {
277       smx_process_t process;
278       int result;
279     } process_is_suspended;
280
281     struct {
282       smx_process_t process;
283       xbt_dict_t result;
284     } process_get_properties;
285
286     struct {
287       double duration;
288       e_smx_state_t result;
289     } process_sleep;
290
291     struct {
292       const char *name;
293       smx_rdv_t result;
294     } rdv_create;
295
296     struct {
297       smx_rdv_t rdv;
298     } rdv_destroy;
299
300     struct {
301       const char* name;
302       smx_rdv_t result;
303     } rdv_get_by_name;
304
305     struct {
306       smx_rdv_t rdv;
307       smx_host_t host;
308       unsigned int result; 
309     } rdv_comm_count_by_host;
310
311     struct {
312       smx_rdv_t rdv;
313       smx_action_t result;
314     } rdv_get_head;
315
316     struct {
317       smx_rdv_t rdv;
318       double task_size;
319       double rate;
320       void *src_buff;
321       size_t src_buff_size;
322       int (*match_fun)(void *, void *);
323       void *data;
324       double timeout;
325     } comm_send;
326
327     struct {
328       smx_rdv_t rdv;
329       double task_size;
330       double rate;
331       void *src_buff;
332       size_t src_buff_size;
333       int (*match_fun)(void *, void *);
334       void (*clean_fun)(void *);
335       void *data;
336       int detached;
337       smx_action_t result;
338     } comm_isend;
339
340     struct {
341       smx_rdv_t rdv;
342       void *dst_buff;
343       size_t *dst_buff_size;
344       int (*match_fun)(void *, void *);
345       void *data;
346       double timeout;
347     } comm_recv;
348
349     struct {
350       smx_rdv_t rdv;
351       void *dst_buff;
352       size_t *dst_buff_size;
353       int (*match_fun)(void *, void *);
354           void *data;
355       smx_action_t result;
356     } comm_irecv;
357
358     struct {
359       smx_action_t comm;
360     } comm_destroy;
361
362     struct {
363       smx_action_t comm;
364     } comm_cancel;
365
366     struct {
367       xbt_dynar_t comms;
368       unsigned int result;
369     } comm_waitany;
370
371     struct {
372       smx_action_t comm;
373       double timeout;
374     } comm_wait;
375
376     struct {
377       smx_action_t comm;
378       int result;
379     } comm_test;
380
381     struct {
382       xbt_dynar_t comms;
383       int result;
384     } comm_testany;
385
386     struct {
387       smx_action_t comm;
388       double result;
389     } comm_get_remains;
390
391     struct {
392       smx_action_t comm;
393       e_smx_state_t result;
394     } comm_get_state;
395
396     struct {
397       smx_action_t comm;
398       void *result;
399     } comm_get_src_data;
400
401     struct {
402       smx_action_t comm;
403       void *result;
404     } comm_get_dst_data;
405
406     struct {
407       smx_action_t comm;
408       smx_process_t result;
409     } comm_get_src_proc;
410
411     struct {
412       smx_action_t comm;
413       smx_process_t result;
414     } comm_get_dst_proc;
415
416 #ifdef HAVE_LATENCY_BOUND_TRACKING
417     struct {
418       smx_action_t comm;
419       int result;
420     } comm_is_latency_bounded;
421 #endif
422
423 #ifdef HAVE_TRACING
424     struct {
425       smx_action_t action;
426       const char *category;
427     } set_category;
428 #endif
429
430     struct {
431       smx_mutex_t result;
432     } mutex_init;
433
434     struct {
435       smx_mutex_t mutex;
436     } mutex_lock;
437
438     struct {
439       smx_mutex_t mutex;
440       int result;
441     } mutex_trylock;
442
443     struct {
444       smx_mutex_t mutex;
445     } mutex_unlock;
446
447     struct {
448       smx_mutex_t mutex;
449     } mutex_destroy;
450
451     struct {
452       smx_cond_t result;
453     } cond_init;
454
455     struct {
456       smx_cond_t cond;
457     } cond_destroy;
458
459     struct {
460       smx_cond_t cond;
461     } cond_signal;
462
463     struct {
464       smx_cond_t cond;
465       smx_mutex_t mutex;
466     } cond_wait;
467
468     struct {
469       smx_cond_t cond;
470       smx_mutex_t mutex;
471       double timeout;
472     } cond_wait_timeout;
473
474     struct {
475       smx_cond_t cond;
476     } cond_broadcast;
477
478     struct {
479       int capacity;
480       smx_sem_t result;
481     } sem_init;
482
483     struct {
484       smx_sem_t sem;
485     } sem_destroy;
486
487     struct {
488       smx_sem_t sem;
489     } sem_release;
490
491     struct {
492       smx_sem_t sem;
493       int result;
494     } sem_would_block;
495
496     struct {
497       smx_sem_t sem;
498     } sem_acquire;
499
500     struct {
501       smx_sem_t sem;
502       double timeout;
503     } sem_acquire_timeout;
504
505     struct {
506       smx_sem_t sem;
507       int result;
508     } sem_get_capacity;
509
510     struct {
511       void *ptr;
512       size_t size;
513       size_t nmemb;
514       smx_file_t* stream;
515       size_t result;
516     } file_read;
517
518     struct {
519       const void *ptr;
520       size_t size;
521       size_t nmemb;
522       smx_file_t* stream;
523       size_t result;
524     } file_write;
525
526     struct {
527       const char* path;
528       const char* mode;
529       smx_file_t* result;
530     } file_open;
531
532     struct {
533       smx_file_t* fp;
534       int result;
535     } file_close;
536
537     struct {
538       int fd;
539       //Next should be struct stat* buf
540       void* buf;
541       int result;
542     } file_stat;
543
544   };
545 } s_smx_simcall_t, *smx_simcall_t;
546
547 /******************************** General *************************************/
548
549 void SIMIX_simcall_push(smx_process_t self);
550 void SIMIX_simcall_answer(smx_simcall_t);
551 void SIMIX_simcall_pre(smx_simcall_t, int);
552 void SIMIX_simcall_post(smx_action_t);
553 XBT_INLINE smx_simcall_t SIMIX_simcall_mine(void);
554 const char *SIMIX_simcall_name(e_smx_simcall_t kind);
555
556 #endif
557