Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
implement simix_comm_testany properly
[simgrid.git] / src / simix / 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 /********************************* Requests ***********************************/
11 typedef enum {
12   REQ_HOST_GET_BY_NAME,
13   REQ_HOST_GET_NAME,
14   REQ_HOST_GET_PROPERTIES,
15   REQ_HOST_GET_SPEED,
16   REQ_HOST_GET_AVAILABLE_SPEED,
17   REQ_HOST_GET_STATE,
18   REQ_HOST_GET_DATA,
19   REQ_HOST_SET_DATA,
20   REQ_HOST_EXECUTE,
21   REQ_HOST_PARALLEL_EXECUTE,
22   REQ_HOST_EXECUTION_DESTROY,
23   REQ_HOST_EXECUTION_CANCEL,
24   REQ_HOST_EXECUTION_GET_REMAINS,
25   REQ_HOST_EXECUTION_GET_STATE,
26   REQ_HOST_EXECUTION_SET_PRIORITY,
27   REQ_HOST_EXECUTION_WAIT,
28   REQ_PROCESS_CREATE,
29   REQ_PROCESS_KILL,
30   REQ_PROCESS_CHANGE_HOST,
31   REQ_PROCESS_SUSPEND,
32   REQ_PROCESS_RESUME,
33   REQ_PROCESS_COUNT,
34   REQ_PROCESS_GET_DATA,
35   REQ_PROCESS_SET_DATA,
36   REQ_PROCESS_GET_HOST,
37   REQ_PROCESS_GET_NAME,
38   REQ_PROCESS_IS_SUSPENDED,
39   REQ_PROCESS_GET_PROPERTIES,
40   REQ_PROCESS_SLEEP,
41   REQ_RDV_CREATE,
42   REQ_RDV_DESTROY,
43   REQ_RDV_GEY_BY_NAME,
44   REQ_RDV_COMM_COUNT_BY_HOST,
45   REQ_RDV_GET_HEAD,
46   REQ_COMM_ISEND,
47   REQ_COMM_IRECV,
48   REQ_COMM_DESTROY,
49   REQ_COMM_CANCEL,
50   REQ_COMM_WAITANY,
51   REQ_COMM_WAIT,
52   REQ_COMM_TEST,
53   REQ_COMM_TESTANY,
54   REQ_COMM_GET_REMAINS,
55   REQ_COMM_GET_STATE,
56   REQ_COMM_GET_DATA,
57   REQ_COMM_GET_SRC_BUFF,
58   REQ_COMM_GET_DST_BUFF,
59   REQ_COMM_GET_SRC_BUFF_SIZE,
60   REQ_COMM_GET_DST_BUFF_SIZE,
61   REQ_COMM_GET_SRC_PROC,
62   REQ_COMM_GET_DST_PROC,
63 #ifdef HAVE_LATENCY_BOUND_TRACKING
64   REQ_COMM_IS_LATENCY_BOUNDED,
65 #endif
66 #ifdef HAVE_TRACING
67   REQ_SET_CATEGORY,
68 #endif
69   REQ_MUTEX_INIT,
70   REQ_MUTEX_DESTROY,
71   REQ_MUTEX_LOCK,
72   REQ_MUTEX_TRYLOCK,
73   REQ_MUTEX_UNLOCK,
74   REQ_COND_INIT,
75   REQ_COND_DESTROY,
76   REQ_COND_SIGNAL,
77   REQ_COND_WAIT,
78   REQ_COND_WAIT_TIMEOUT,
79   REQ_COND_BROADCAST,
80   REQ_SEM_INIT,
81   REQ_SEM_DESTROY,
82   REQ_SEM_RELEASE,
83   REQ_SEM_WOULD_BLOCK,
84   REQ_SEM_ACQUIRE,
85   REQ_SEM_ACQUIRE_TIMEOUT,
86   REQ_SEM_GET_CAPACITY
87 } e_smx_req_t;
88
89 typedef struct s_smx_req {
90   s_xbt_swag_hookup_t state_hookup;
91   e_smx_req_t call;
92   smx_process_t issuer;
93
94   union {
95
96     struct {
97       const char *name;
98       smx_host_t result;
99     } host_get_by_name;
100
101     struct {
102       smx_host_t host;
103       const char* result;
104     } host_get_name;
105
106     struct {
107       smx_host_t host;
108       xbt_dict_t result;
109     } host_get_properties;
110
111     struct {
112       smx_host_t host;
113       double result;
114     } host_get_speed;
115
116     struct {
117       smx_host_t host;
118       double result;
119     } host_get_available_speed;
120
121     struct {
122       smx_host_t host;
123       int result;
124     } host_get_state;
125
126     struct {
127       smx_host_t host;
128       void* result;
129     } host_get_data;
130
131     struct {
132       smx_host_t host;
133       void* data;
134     } host_set_data;
135
136     struct {
137       const char* name;
138       smx_host_t host;
139       double computation_amount;
140       smx_action_t result;
141     } host_execute;
142
143     struct {
144       const char *name;
145       int host_nb;
146       smx_host_t *host_list;
147       double *computation_amount;
148       double *communication_amount;
149       double amount;
150       double rate;
151       smx_action_t result;
152     } host_parallel_execute;
153
154     struct {
155       smx_action_t execution;
156     } host_execution_destroy;
157
158     struct {
159       smx_action_t execution;
160     } host_execution_cancel;
161
162     struct {
163       smx_action_t execution;
164       double result;
165     } host_execution_get_remains;
166
167     struct {
168       smx_action_t execution;
169       e_smx_state_t result;
170     } host_execution_get_state;
171
172     struct {
173       smx_action_t execution;
174       double priority;
175     } host_execution_set_priority;
176
177     struct {
178       smx_action_t execution;
179     } host_execution_wait;
180
181     struct {
182       const char *name;
183       xbt_main_func_t code;
184       void *data;
185       const char *hostname;
186       int argc;
187       char **argv;
188       xbt_dict_t properties;
189       smx_process_t result;
190     } process_create;
191
192     struct {
193       smx_process_t process;
194     } process_kill;
195
196     struct {
197       smx_process_t process;
198       const char *source;
199       const char *dest;
200     } process_change_host;
201
202     struct {
203       smx_process_t process;
204     } process_suspend;
205
206     struct {
207       smx_process_t process;
208     } process_resume;
209
210     struct {
211       int result;
212     } process_count;
213
214     struct {
215       smx_process_t process;
216       void* result;
217     } process_get_data;
218
219     struct {
220       smx_process_t process;
221       void* data;
222     } process_set_data;
223
224     struct {
225       smx_process_t process;
226       smx_host_t result;
227     } process_get_host;
228
229     struct {
230       smx_process_t process;
231       const char *result;
232     } process_get_name;
233
234     struct {
235       smx_process_t process;
236       int result;
237     } process_is_suspended;
238
239     struct {
240       smx_process_t process;
241       xbt_dict_t result;
242     } process_get_properties;
243
244     struct {
245       double duration;
246       e_smx_state_t result;
247     } process_sleep;
248
249     struct {
250       const char *name;
251       smx_rdv_t result;
252     } rdv_create;
253
254     struct {
255       smx_rdv_t rdv;
256     } rdv_destroy;
257
258     struct {
259       const char* name;
260       smx_rdv_t result;
261     } rdv_get_by_name;
262
263     struct {
264       smx_rdv_t rdv;
265       smx_host_t host;
266       unsigned int result; 
267     } rdv_comm_count_by_host;
268
269     struct {
270       smx_rdv_t rdv;
271       smx_action_t result;
272     } rdv_get_head;
273
274     struct {
275       smx_rdv_t rdv;
276       double task_size;
277       double rate;
278       void *src_buff;
279       size_t src_buff_size;
280       void *data;
281       smx_action_t result;      
282     } comm_isend;
283
284     struct {
285       smx_rdv_t rdv;
286       void *dst_buff;
287       size_t *dst_buff_size;
288       smx_action_t result;
289     } comm_irecv;
290
291     struct {
292       smx_action_t comm;
293     } comm_destroy;
294
295     struct {
296       smx_action_t comm;
297     } comm_cancel;
298
299     struct {
300       xbt_dynar_t comms;
301       unsigned int result;
302     } comm_waitany;
303
304     struct {
305       smx_action_t comm;
306       double timeout;
307     } comm_wait;
308
309     struct {
310       smx_action_t comm;
311       int result;
312     } comm_test;
313
314     struct {
315       xbt_dynar_t comms;
316       int result;
317     } comm_testany;
318
319     struct {
320       smx_action_t comm;
321       double result;
322     } comm_get_remains;
323
324     struct {
325       smx_action_t comm;
326       e_smx_state_t result;
327     } comm_get_state;
328
329     struct {
330       smx_action_t comm;
331       void *result;    
332     } comm_get_data;
333
334     struct {
335       smx_action_t comm;
336       void *result;
337     } comm_get_src_buff;
338
339     struct {
340       smx_action_t comm;
341       void *result;
342     } comm_get_dst_buff;
343
344     struct {
345       smx_action_t comm;
346       size_t result;
347     } comm_get_src_buff_size;
348
349     struct {
350       smx_action_t comm;
351       size_t result;
352     } comm_get_dst_buff_size;
353
354     struct {
355       smx_action_t comm;
356       smx_process_t result;
357     } comm_get_src_proc;
358
359     struct {
360       smx_action_t comm;
361       smx_process_t result;
362     } comm_get_dst_proc;
363
364 #ifdef HAVE_LATENCY_BOUND_TRACKING
365     struct {
366       smx_action_t comm;
367       int result;
368     } comm_is_latency_bounded;
369 #endif
370
371 #ifdef HAVE_TRACING
372     struct {
373       smx_action_t action;
374       const char *category;
375     } set_category;
376 #endif
377
378     struct {
379       smx_mutex_t result;
380     } mutex_init;
381
382     struct {
383       smx_mutex_t mutex;
384     } mutex_lock;
385
386     struct {
387       smx_mutex_t mutex;
388       int result;
389     } mutex_trylock;
390
391     struct {
392       smx_mutex_t mutex;
393     } mutex_unlock;
394
395     struct {
396       smx_mutex_t mutex;
397     } mutex_destroy;
398
399     struct {
400       smx_cond_t result;
401     } cond_init;
402
403     struct {
404       smx_cond_t cond;
405     } cond_destroy;
406
407     struct {
408       smx_cond_t cond;
409     } cond_signal;
410
411     struct {
412       smx_cond_t cond;
413       smx_mutex_t mutex;
414     } cond_wait;
415
416     struct {
417       smx_cond_t cond;
418       smx_mutex_t mutex;
419       double timeout;
420     } cond_wait_timeout;
421
422     struct {
423       smx_cond_t cond;
424     } cond_broadcast;
425
426     struct {
427       int capacity;
428       smx_sem_t result;
429     } sem_init;
430
431     struct {
432       smx_sem_t sem;
433     } sem_destroy;
434
435     struct {
436       smx_sem_t sem;
437     } sem_release;
438
439     struct {
440       smx_sem_t sem;
441       int result;
442     } sem_would_block;
443
444     struct {
445       smx_sem_t sem;
446     } sem_acquire;
447
448     struct {
449       smx_sem_t sem;
450       double timeout;
451     } sem_acquire_timeout;
452
453     struct {
454       smx_sem_t sem;
455       int result;
456     } sem_get_capacity;
457   };
458 } s_smx_req_t, *smx_req_t;
459
460 /******************************** General *************************************/
461
462 void SIMIX_request_init(void);
463 void SIMIX_request_destroy(void);
464 void SIMIX_request_push(smx_req_t);
465 smx_req_t SIMIX_request_pop(void);
466 void SIMIX_request_answer(smx_req_t);
467 void SIMIX_request_pre(smx_req_t);
468 void SIMIX_request_post(smx_action_t);
469 int SIMIX_request_is_visible(smx_req_t req);
470 int SIMIX_request_is_enabled(smx_req_t req);
471
472 #endif
473