Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Reduce overengeneering around datadesc, put stubs in place so that the kernel compile...
[simgrid.git] / src / gras / gras_private.h
1 /* $Id$ */
2
3 /* gras_private.h - GRAS private definitions                                */
4
5 /* Authors: Martin Quinson                                                  */
6 /* Copyright (C) 2003 the OURAGAN project.                                  */
7
8 /* This program is free software; you can redistribute it and/or modify it
9    under the terms of the license (GNU LGPL) which comes with this package. */
10
11 #ifndef GRAS_PRIVATE_H
12 #define GRAS_PRIVATE_H
13
14 #include <unistd.h>
15 #include <stdio.h>
16 #include <stdlib.h>
17 #include <string.h>
18
19 /* Oli's macro */
20 #ifndef GS_FAILURE_CONTEXT
21 #  define GS_FAILURE_CONTEXT
22 #endif /* FAILURE_CONTEXT */
23
24 #define GS_FAILURE(str) \
25      (fprintf(stderr, "FAILURE: %s(%s:%d)" GS_FAILURE_CONTEXT "%s\n", __func__, __FILE__, __LINE__, (str)), \
26       abort())
27
28 #define aligned(v, a) (((v) + (a - 1)) & ~(a - 1))
29 #define max(a, b) (((a) > (b))?(a):(b))
30 #define min(a, b) (((a) < (b))?(a):(b))
31
32 /* end of Oli's cruft */
33
34 #include "gras_config.h"
35
36 #include "gras/error.h"
37 #include "gras/log.h"
38 #include "gras/module.h"
39 #include "gras/dynar.h"
40 #include "gras/dict.h"
41 #include "gras/config.h"
42
43 #include "gras/data_description.h"
44 #include "gras/dd_type_bag.h"
45
46 #include "gras/core.h"
47 #include "gras/transport.h"
48 #include "gras/datadesc_simple.h"
49 #include "gras/socket.h"
50 #include "gras/messages.h"
51
52 #define TRUE  1
53 #define FALSE 0
54
55 #define ASSERT(cond,msg) do {if (!(cond)) { fprintf(stderr,msg); abort(); }} while(0)
56
57 /* **************************************************************************
58  * Locking system
59  ****************************************************************************/
60 /**
61  * gras_lock:
62  * @Returns: 1 if succesfull 0 otherwise.
63  *
64  * Get the GRAS lock.
65  */
66 int
67 gras_lock(void);
68
69 /**
70  * gras_unlock:
71  * @Returns: 1 if succesfull 0 otherwise.
72  *
73  * release the GRAS general lock.
74  */
75 int
76 gras_unlock(void);
77
78 /* **************************************************************************
79  * Messaging stuff
80  * **************************************************************************/
81
82 /**
83  * gras_cblist_t:
84  *
85  * The list of callbacks for a given message type on a given host
86  */
87 typedef struct {
88   gras_msgid_t id;     /** identificator of this message */
89   
90   int cbCount;         /** number of registered callbacks */
91   gras_cb_t *cb;       /** callbacks */
92   int *cbTTL;          /** TTL of each callback (in number of use)*/
93 } gras_cblist_t;
94
95 /**
96  * gras_msgentry_t:
97  *
98  * An entry in the registered message list.
99  */
100
101 struct gras_msgentry_s {
102   gras_msgid_t id;     /** identificator of this message */
103   char *name;               /** printable name of this message */
104
105   int seqCount;             /** number of sequence for this message */
106   DataDescriptor **dd;      /** list of datadescriptor for each sequence */
107   size_t *ddCount;          /** list of datadescriptor for each sequence */
108   unsigned int *networkSize;/** network size of one element in each sequence */
109   unsigned int *hostSize;   /** host size of one element in each sequence */
110 };
111 /* **************************************************************************
112  * GRAS globals
113  * **************************************************************************/
114
115 /** 
116  * gras_hostglobal_t:
117  * 
118  * Globals for a given host. 
119  */
120 typedef struct {
121   gras_cblist_t *grasCbList; /** callbacks for registered messages */
122   unsigned int grasCbListCount;      /** length of previous array */
123 } gras_hostglobal_t;
124
125 /**
126  * gras_msgheader_t:
127  *
128  * A header sent with messages.  #version# is the NWS version and is presently
129  * ignored, but it could be used for compatibility.  #message# is the actual
130  * message. #seqCount# is the number of sequence accompagning this message.
131  */
132 struct gras_msgheader_s {
133   char          version[10];
134   gras_msgid_t  message;
135   unsigned int  dataSize;
136   unsigned int  seqCount;
137 };
138
139 /**
140  * grasProcessData_t:
141  *
142  * Data for each process 
143  */
144 typedef struct {
145   /* queue of messages which where received but not wanted in msgWait, and therefore
146      temporarly queued until the next msgHandle */
147   int grasMsgQueueLen;
148   gras_msg_t **grasMsgQueue;
149
150   /* registered callbacks for each message */
151   int grasCblListLen;
152   gras_cblist_t *grasCblList;
153
154   /* The channel we are listening to in SG for formated messages */
155   int chan;
156   /* The channel we are listening to in SG for raw send/recv */
157   int rawChan; 
158
159   /* globals of the process */
160   void *userdata;               
161 } grasProcessData_t;
162
163
164 /*@unused@*/static const DataDescriptor headerDescriptor[] =
165   {SIMPLE_MEMBER(CHAR_TYPE, 10, offsetof(gras_msgheader_t, version)),
166    SIMPLE_MEMBER(UNSIGNED_INT_TYPE, 1, offsetof(gras_msgheader_t, message)),
167    SIMPLE_MEMBER(UNSIGNED_INT_TYPE, 1, offsetof(gras_msgheader_t, dataSize)),
168    SIMPLE_MEMBER(UNSIGNED_INT_TYPE, 1, offsetof(gras_msgheader_t, seqCount))};
169 #define headerDescriptorCount 4
170
171 /*@unused@*/static const DataDescriptor countDescriptor[] =
172   {SIMPLE_DATA(UNSIGNED_INT_TYPE,1)};
173 #define countDescriptorCount 1
174
175 /**
176  * GRASVERSION
177  *
178  * This string is sent in each message to identify the version of the 
179  * communication protocol used. This may be paranoid, but I feel so right now.
180  */
181 #define GRASVERSION "0.0.020504"
182
183 /**
184  * grasMsgEntryGet: 
185  * @id: msg id to look for
186  * @Returns: the entry if found, NULL otherwise
187  * 
188  * Get the entry corresponding to this message id;
189  */ /*@observer@*/
190 gras_msgentry_t * grasMsgEntryGet(gras_msgid_t id);
191
192 /**
193  * grasProcessDataGet: 
194  * 
195  * Get the GRAS globals for this host
196  */ /*@observer@*/
197 grasProcessData_t *grasProcessDataGet(void);
198
199 /**
200  * gras_cb_get: 
201  * @id: msg id to look for
202  * 
203  * Get the callback list corresponding to this message id;
204  */ /*@observer@*/
205 gras_cblist_t * gras_cb_get(gras_msgid_t id);
206
207 /**
208  * gras_cb_create:
209  * @id: the id of the new msg
210  *
211  * Create a new callback list for a new message id.
212  */
213 gras_error_t gras_cb_create(gras_msgid_t message);
214
215 /**
216  * grasMsgHeaderNew:
217  * @msgId: 
218  * @dataSize: total size in network format, including headers and seqcount
219  * @seqCount: Number of sequences in this message (to check that everything goes well)
220  * @Returns: the created header
221  *
222  * Create a new header containing the passed values.
223  */
224 gras_msgheader_t *grasMsgHeaderNew(gras_msgid_t msgId, 
225                                   unsigned int dataSize,
226                                   unsigned int seqCount);
227
228 /**
229  * grasMsgRecv:
230  *
231  * Receive the next message arriving within the given timeout
232  */
233 gras_error_t grasMsgRecv(gras_msg_t **msg, double timeout);
234
235 /**
236  * gras_sock_new:
237  *
238  * Create an empty socket
239  */
240 gras_sock_t *gras_sock_new(void);
241
242 /**
243  * grasSockFree:
244  *
245  * Frees an old socket
246  */
247 void grasSockFree(gras_sock_t *s);
248
249
250
251 /* **************************************************************************
252  * Handling DataDescriptors
253  * **************************************************************************/
254 #if 0
255 FIXME: Kill it
256 typedef enum {HOST_FORMAT, NETWORK_FORMAT} FormatTypes;
257 size_t DataSize(const DataDescriptor *description,
258                 size_t length,
259                 FormatTypes format);
260 void *gras_datadesc_copy_data(const DataDescriptor *dd, unsigned int c, void *data);
261 int gras_datadesc_cmp(/*@null@*/const DataDescriptor *dd1, unsigned int c1,
262                       /*@null@*/const DataDescriptor *dd2, unsigned int c2);
263 void gras_datadesc_dump(/*@null@*/const DataDescriptor *dd, unsigned int c);
264 #endif
265 #endif /* GRAS_PRIVATE_H */