Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
SIMIX requests: generate strings from enumeration values automatically
[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 #include "smx_req_enum.h"
13 } e_smx_req_t;
14
15 typedef struct s_smx_req {
16   s_xbt_swag_hookup_t state_hookup;
17   e_smx_req_t call;
18   smx_process_t issuer;
19
20   union {
21
22     struct {
23       const char *name;
24       smx_host_t result;
25     } host_get_by_name;
26
27     struct {
28       smx_host_t host;
29       const char* result;
30     } host_get_name;
31
32     struct {
33       smx_host_t host;
34       xbt_dict_t result;
35     } host_get_properties;
36
37     struct {
38       smx_host_t host;
39       double result;
40     } host_get_speed;
41
42     struct {
43       smx_host_t host;
44       double result;
45     } host_get_available_speed;
46
47     struct {
48       smx_host_t host;
49       int result;
50     } host_get_state;
51
52     struct {
53       smx_host_t host;
54       void* result;
55     } host_get_data;
56
57     struct {
58       smx_host_t host;
59       void* data;
60     } host_set_data;
61
62     struct {
63       const char* name;
64       smx_host_t host;
65       double computation_amount;
66       smx_action_t result;
67     } host_execute;
68
69     struct {
70       const char *name;
71       int host_nb;
72       smx_host_t *host_list;
73       double *computation_amount;
74       double *communication_amount;
75       double amount;
76       double rate;
77       smx_action_t result;
78     } host_parallel_execute;
79
80     struct {
81       smx_action_t execution;
82     } host_execution_destroy;
83
84     struct {
85       smx_action_t execution;
86     } host_execution_cancel;
87
88     struct {
89       smx_action_t execution;
90       double result;
91     } host_execution_get_remains;
92
93     struct {
94       smx_action_t execution;
95       e_smx_state_t result;
96     } host_execution_get_state;
97
98     struct {
99       smx_action_t execution;
100       double priority;
101     } host_execution_set_priority;
102
103     struct {
104       smx_action_t execution;
105     } host_execution_wait;
106
107     struct {
108       const char *name;
109       xbt_main_func_t code;
110       void *data;
111       const char *hostname;
112       int argc;
113       char **argv;
114       xbt_dict_t properties;
115       smx_process_t result;
116     } process_create;
117
118     struct {
119       smx_process_t process;
120     } process_kill;
121
122     struct {
123       smx_process_t process;
124       const char *source;
125       const char *dest;
126     } process_change_host;
127
128     struct {
129       smx_process_t process;
130     } process_suspend;
131
132     struct {
133       smx_process_t process;
134     } process_resume;
135
136     struct {
137       int result;
138     } process_count;
139
140     struct {
141       smx_process_t process;
142       void* result;
143     } process_get_data;
144
145     struct {
146       smx_process_t process;
147       void* data;
148     } process_set_data;
149
150     struct {
151       smx_process_t process;
152       smx_host_t result;
153     } process_get_host;
154
155     struct {
156       smx_process_t process;
157       const char *result;
158     } process_get_name;
159
160     struct {
161       smx_process_t process;
162       int result;
163     } process_is_suspended;
164
165     struct {
166       smx_process_t process;
167       xbt_dict_t result;
168     } process_get_properties;
169
170     struct {
171       double duration;
172       e_smx_state_t result;
173     } process_sleep;
174
175     struct {
176       const char *name;
177       smx_rdv_t result;
178     } rdv_create;
179
180     struct {
181       smx_rdv_t rdv;
182     } rdv_destroy;
183
184     struct {
185       const char* name;
186       smx_rdv_t result;
187     } rdv_get_by_name;
188
189     struct {
190       smx_rdv_t rdv;
191       smx_host_t host;
192       unsigned int result; 
193     } rdv_comm_count_by_host;
194
195     struct {
196       smx_rdv_t rdv;
197       smx_action_t result;
198     } rdv_get_head;
199
200     struct {
201       smx_rdv_t rdv;
202       double task_size;
203       double rate;
204       void *src_buff;
205       size_t src_buff_size;
206       int (*match_fun)(void *, void *);
207       void *data;
208       smx_action_t result;
209     } comm_isend;
210
211     struct {
212       smx_rdv_t rdv;
213       void *dst_buff;
214       size_t *dst_buff_size;
215       int (*match_fun)(void *, void *);
216           void *data;
217       smx_action_t result;
218     } comm_irecv;
219
220     struct {
221       smx_action_t comm;
222     } comm_destroy;
223
224     struct {
225       smx_action_t comm;
226     } comm_cancel;
227
228     struct {
229       xbt_dynar_t comms;
230       unsigned int result;
231     } comm_waitany;
232
233     struct {
234       smx_action_t comm;
235       double timeout;
236     } comm_wait;
237
238     struct {
239       smx_action_t comm;
240       int result;
241     } comm_test;
242
243     struct {
244       xbt_dynar_t comms;
245       int result;
246     } comm_testany;
247
248     struct {
249       smx_action_t comm;
250       double result;
251     } comm_get_remains;
252
253     struct {
254       smx_action_t comm;
255       e_smx_state_t result;
256     } comm_get_state;
257
258     struct {
259       smx_action_t comm;
260       void *result;
261     } comm_get_src_data;
262
263     struct {
264       smx_action_t comm;
265       void *result;
266     } comm_get_dst_data;
267
268     struct {
269       smx_action_t comm;
270       void *result;
271     } comm_get_src_buff;
272
273     struct {
274       smx_action_t comm;
275       void *result;
276     } comm_get_dst_buff;
277
278     struct {
279       smx_action_t comm;
280       size_t result;
281     } comm_get_src_buff_size;
282
283     struct {
284       smx_action_t comm;
285       size_t result;
286     } comm_get_dst_buff_size;
287
288     struct {
289       smx_action_t comm;
290       smx_process_t result;
291     } comm_get_src_proc;
292
293     struct {
294       smx_action_t comm;
295       smx_process_t result;
296     } comm_get_dst_proc;
297
298 #ifdef HAVE_LATENCY_BOUND_TRACKING
299     struct {
300       smx_action_t comm;
301       int result;
302     } comm_is_latency_bounded;
303 #endif
304
305 #ifdef HAVE_TRACING
306     struct {
307       smx_action_t action;
308       const char *category;
309     } set_category;
310 #endif
311
312     struct {
313       smx_mutex_t result;
314     } mutex_init;
315
316     struct {
317       smx_mutex_t mutex;
318     } mutex_lock;
319
320     struct {
321       smx_mutex_t mutex;
322       int result;
323     } mutex_trylock;
324
325     struct {
326       smx_mutex_t mutex;
327     } mutex_unlock;
328
329     struct {
330       smx_mutex_t mutex;
331     } mutex_destroy;
332
333     struct {
334       smx_cond_t result;
335     } cond_init;
336
337     struct {
338       smx_cond_t cond;
339     } cond_destroy;
340
341     struct {
342       smx_cond_t cond;
343     } cond_signal;
344
345     struct {
346       smx_cond_t cond;
347       smx_mutex_t mutex;
348     } cond_wait;
349
350     struct {
351       smx_cond_t cond;
352       smx_mutex_t mutex;
353       double timeout;
354     } cond_wait_timeout;
355
356     struct {
357       smx_cond_t cond;
358     } cond_broadcast;
359
360     struct {
361       int capacity;
362       smx_sem_t result;
363     } sem_init;
364
365     struct {
366       smx_sem_t sem;
367     } sem_destroy;
368
369     struct {
370       smx_sem_t sem;
371     } sem_release;
372
373     struct {
374       smx_sem_t sem;
375       int result;
376     } sem_would_block;
377
378     struct {
379       smx_sem_t sem;
380     } sem_acquire;
381
382     struct {
383       smx_sem_t sem;
384       double timeout;
385     } sem_acquire_timeout;
386
387     struct {
388       smx_sem_t sem;
389       int result;
390     } sem_get_capacity;
391   };
392 } s_smx_req_t, *smx_req_t;
393
394 /******************************** General *************************************/
395
396 void SIMIX_request_init(void);
397 void SIMIX_request_destroy(void);
398 void SIMIX_request_push(void);
399 smx_req_t SIMIX_request_pop(void);
400 void SIMIX_request_answer(smx_req_t);
401 void SIMIX_request_pre(smx_req_t, int);
402 void SIMIX_request_post(smx_action_t);
403 XBT_INLINE smx_req_t SIMIX_req_mine(void);
404
405 #endif
406