Logo AND Algorithmique Numérique Distribuée

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