Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Give it the possibility to do only writes or only reads (so that I can work on portab...
[simgrid.git] / testsuite / gras / datadesc_usage.c
1 /* $Id$ */
2
3 /* datadesc: test of data description (using file transport).               */
4
5 /* Authors: Martin Quinson                                                  */
6 /* Copyright (C) 2004 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 #include <stdio.h>
12 #include <gras.h>
13
14 #include "../DataDesc/datadesc_interface.h"
15 GRAS_LOG_NEW_DEFAULT_CATEGORY(test);
16
17 #define READ  0
18 #define WRITE 1
19 #define RW    2
20
21 gras_error_t
22 write_read(gras_datadesc_type_t *type,void *src, void *dst, 
23            gras_socket_t *sock, int direction);
24
25 gras_error_t
26 write_read(gras_datadesc_type_t *type,void *src, void *dst, 
27            gras_socket_t *sock, int direction) {
28   gras_error_t errcode;
29    
30   /* write */
31   if (direction == RW) 
32     TRY(gras_socket_client_from_file("datadesc_usage.out",&sock));
33   if (direction == WRITE || direction == RW)
34     TRY(gras_datadesc_send(sock, type, src));
35   if (direction == RW) 
36     gras_socket_close(&sock);
37    
38   /* read */
39   if (direction == RW) 
40     TRY(gras_socket_server_from_file("datadesc_usage.out",&sock));
41
42   if (direction == READ || direction == RW)
43     TRY(gras_datadesc_recv(sock, type, gras_arch_selfid(), dst));
44
45   if (direction == RW) 
46     gras_socket_close(&sock);
47   
48   return no_error;
49 }
50
51 gras_error_t test_int(gras_socket_t *sock, int direction);
52 gras_error_t test_float(gras_socket_t *sock, int direction);
53 gras_error_t test_array(gras_socket_t *sock, int direction);
54 gras_error_t test_intref(gras_socket_t *sock, int direction);
55 gras_error_t test_string(gras_socket_t *sock, int direction);
56
57 gras_error_t test_homostruct(gras_socket_t *sock, int direction);
58 gras_error_t test_hetestruct(gras_socket_t *sock, int direction);
59 gras_error_t test_nestedstruct(gras_socket_t *sock, int direction);
60 gras_error_t test_chain_list(gras_socket_t *sock, int direction);
61 gras_error_t test_graph(gras_socket_t *sock, int direction);
62
63 gras_error_t test_int(gras_socket_t *sock, int direction) {
64   gras_error_t errcode;
65   int i=5,j;
66   
67   INFO0("==== Test on integer ====");
68   TRY(write_read(gras_datadesc_by_name("int"), &i,&j, sock,direction));
69   if (direction == READ || direction == RW) {
70     gras_assert(i == j);
71   }
72   return no_error;
73 }
74 gras_error_t test_float(gras_socket_t *sock, int direction) {
75   gras_error_t errcode;
76   float i=5.0,j;
77   
78   INFO0("==== Test on float ====");
79   TRY(write_read(gras_datadesc_by_name("float"), &i,&j, sock,direction));
80   if (direction == READ || direction == RW) {
81     gras_assert(i == j);
82   }
83   return no_error;
84 }
85
86 #define SIZE 5
87 typedef int array[SIZE];
88 gras_error_t test_array(gras_socket_t *sock, int direction) {
89   gras_error_t errcode;
90   gras_datadesc_type_t *my_type;
91   
92   array i,j;
93   int cpt;
94
95   INFO0("==== Test on fixed array ====");
96   for (cpt=0; cpt<SIZE; cpt++) {
97     i[cpt] = rand();
98   }
99
100   TRY(gras_datadesc_declare_array_fixed("fixed int array", 
101                                         gras_datadesc_by_name("int"),
102                                         SIZE, &my_type));
103
104   TRY(write_read(my_type, &i,&j, sock,direction));
105   if (direction == READ || direction == RW) {
106     for (cpt=0; cpt<SIZE; cpt++)
107       gras_assert4(i[cpt] == j[cpt],"i[%d]=%d  !=  j[%d]=%d",
108                    cpt,i[cpt],cpt,j[cpt]);
109   }
110   return no_error;
111 }
112 gras_error_t test_intref(gras_socket_t *sock, int direction) {
113   gras_error_t errcode;
114   gras_datadesc_type_t *my_type;
115   int *i,*j;
116   
117   if (! (i=malloc(sizeof(int))) )
118     RAISE_MALLOC;
119   *i=12345;
120
121   INFO1("==== Test on a reference to an integer (%p) ====",i);
122
123   TRY(gras_datadesc_declare_ref("int*",gras_datadesc_by_name("int"),&my_type));
124
125   TRY(write_read(my_type, &i,&j, sock,direction));
126   if (direction == READ || direction == RW) {
127     gras_assert(*i == *j);
128     free(j);
129   }
130   free(i);
131   return no_error;
132 }
133
134 /***
135  *** string (dynamic array)
136  ***/ 
137 gras_error_t test_string(gras_socket_t *sock, int direction) {
138   gras_error_t errcode;
139   gras_datadesc_type_t *my_type;
140   char *i=strdup("Some data"), *j=NULL;
141   int cpt;
142   
143   INFO0("==== Test on string (dynamic array) ====");
144   TRY(gras_datadesc_declare_ref("string*",
145                                 gras_datadesc_by_name("string"),
146                                 &my_type));
147
148   TRY(write_read(gras_datadesc_by_name("string*"), &i,&j,
149                  sock,direction));
150   if (direction == READ || direction == RW) {
151     for (cpt=0; cpt<strlen(i); cpt++) {
152       fprintf(stderr,"%d ", cpt);
153       gras_assert4(i[cpt] == j[cpt],"i[%d]=%c  !=  j[%d]=%c",
154                    cpt,i[cpt],cpt,j[cpt]);
155     } 
156     free(j);
157   }
158   free(i);
159   return no_error;
160 }
161
162
163 /***
164  *** homogeneous struct
165  ***/ 
166 typedef struct {
167   int a,b,c,d;
168 } homostruct;
169 gras_error_t test_homostruct(gras_socket_t *sock, int direction) {
170   gras_error_t errcode;
171   gras_datadesc_type_t *my_type;
172   homostruct *i, *j; 
173
174   INFO0("==== Test on homogeneous structure ====");
175   /* create descriptor */
176   TRY(gras_datadesc_declare_struct("homostruct",&my_type));
177   TRY(gras_datadesc_declare_struct_append(my_type,"a",
178                                           gras_datadesc_by_name("signed int")));
179   TRY(gras_datadesc_declare_struct_append(my_type,"b",
180                                           gras_datadesc_by_name("int")));
181   TRY(gras_datadesc_declare_struct_append(my_type,"c",
182                                           gras_datadesc_by_name("int")));
183   TRY(gras_datadesc_declare_struct_append(my_type,"d",
184                                           gras_datadesc_by_name("int")));
185   TRY(gras_datadesc_declare_ref("homostruct*",
186                                 gras_datadesc_by_name("homostruct"),
187                                 &my_type));
188
189   /* init a value, exchange it and check its validity*/
190   if (! (i=malloc(sizeof(homostruct))) )
191     RAISE_MALLOC;
192   i->a = rand();  i->b = rand();
193   i->c = rand();  i->d = rand();
194
195   TRY(write_read(my_type, &i,&j, sock,direction));
196   if (direction == READ || direction == RW) {
197     gras_assert(i->a == j->a);
198     gras_assert(i->b == j->b);
199     gras_assert(i->c == j->c);
200     gras_assert(i->d == j->d);
201     free(j);
202   }
203   free(i);
204   return no_error;
205 }
206
207 /***
208  *** heterogeneous struct
209  ***/ 
210 typedef struct {
211   unsigned char c1;
212   unsigned long int l1;
213   unsigned char c2;
214   unsigned long int l2;
215 } hetestruct;
216 gras_error_t test_hetestruct(gras_socket_t *sock, int direction) {
217   gras_error_t errcode;
218   gras_datadesc_type_t *my_type;
219   hetestruct *i, *j; 
220
221   INFO0("==== Test on heterogeneous structure ====");
222   /* create descriptor */
223   TRY(gras_datadesc_declare_struct("hetestruct",&my_type));
224   TRY(gras_datadesc_declare_struct_append(my_type,"c1",
225                                           gras_datadesc_by_name("unsigned char")));
226   TRY(gras_datadesc_declare_struct_append(my_type,"l1",
227                                           gras_datadesc_by_name("unsigned long int")));
228   TRY(gras_datadesc_declare_struct_append(my_type,"c2",
229                                           gras_datadesc_by_name("unsigned char")));
230   TRY(gras_datadesc_declare_struct_append(my_type,"l2",
231                                           gras_datadesc_by_name("unsigned long int")));
232   TRY(gras_datadesc_declare_ref("hetestruct*",
233                                 gras_datadesc_by_name("hetestruct"),
234                                 &my_type));
235
236   /* init a value, exchange it and check its validity*/
237   if (! (i=malloc(sizeof(hetestruct))) )
238     RAISE_MALLOC;
239   i->c1 = 's'; i->l1 = 123455;
240   i->c2 = 'e'; i->l2 = 774531;
241
242   TRY(write_read(my_type, &i,&j, sock,direction));
243   if (direction == READ || direction == RW) {
244     gras_assert(i->c1 == j->c1);
245     gras_assert(i->c2 == j->c2);
246     gras_assert(i->l1 == j->l1);
247     gras_assert(i->l2 == j->l2);
248     free(j);
249   }
250   free(i);
251   return no_error;
252 }
253
254 /***
255  *** nested struct
256  ***/ 
257 typedef struct {
258   hetestruct hete;
259   homostruct homo;
260 } nestedstruct;
261 gras_error_t test_nestedstruct(gras_socket_t *sock, int direction) {
262   gras_error_t errcode;
263   gras_datadesc_type_t *my_type;
264   nestedstruct *i, *j; 
265
266   INFO0("==== Test on nested structures ====");
267   /* create descriptor */
268   TRY(gras_datadesc_declare_struct("nestedstruct",&my_type));
269
270   TRY(gras_datadesc_declare_struct_append(my_type,"hete",
271                                           gras_datadesc_by_name("hetestruct")));
272   TRY(gras_datadesc_declare_struct_append(my_type,"homo",
273                                           gras_datadesc_by_name("homostruct")));
274   TRY(gras_datadesc_declare_ref("nestedstruct*",
275                                 gras_datadesc_by_name("nestedstruct"),
276                                 &my_type));
277
278   /* init a value, exchange it and check its validity*/
279   if (! (i=malloc(sizeof(nestedstruct))) )
280     RAISE_MALLOC;
281   i->homo.a = rand();  i->homo.b = rand();
282   i->homo.c = rand();  i->homo.d = rand();
283   i->hete.c1 = 's'; i->hete.l1 = 123455;
284   i->hete.c2 = 'e'; i->hete.l2 = 774531;
285
286   TRY(write_read(my_type, &i,&j, sock,direction));
287   if (direction == READ || direction == RW) {
288     gras_assert(i->homo.a == j->homo.a);
289     gras_assert(i->homo.b == j->homo.b);
290     gras_assert(i->homo.c == j->homo.c);
291     gras_assert(i->homo.d == j->homo.d);
292     gras_assert(i->hete.c1 == j->hete.c1);
293     gras_assert(i->hete.c2 == j->hete.c2);
294     gras_assert(i->hete.l1 == j->hete.l1);
295     gras_assert(i->hete.l2 == j->hete.l2);
296     free(j);
297   }
298   free(i);
299   return no_error;
300 }
301
302 /***
303  *** chained list
304  ***/ 
305 typedef struct s_chained_list chained_list_t;
306 struct s_chained_list {
307   int          v;
308   chained_list_t *l;
309 };
310 gras_error_t declare_chained_list_type(void);
311 chained_list_t *cons(int v, chained_list_t *l);
312 void list_free(chained_list_t *l);
313 int list_eq(chained_list_t*i,chained_list_t*j);
314
315 gras_error_t declare_chained_list_type(void) {
316   gras_error_t errcode;
317   gras_datadesc_type_t *my_type,*ref_my_type;
318
319   TRY(gras_datadesc_declare_struct("chained_list_t",&my_type));
320   TRY(gras_datadesc_declare_ref("chained_list_t*",my_type,&ref_my_type));
321
322   TRY(gras_datadesc_declare_struct_append(my_type,"v",
323                                           gras_datadesc_by_name("int")));
324   TRY(gras_datadesc_declare_struct_append(my_type,"l",ref_my_type));
325
326   return no_error;
327 }
328
329 chained_list_t * cons(int v, chained_list_t *l) {
330   chained_list_t *nl = malloc(sizeof (chained_list_t));
331   
332   nl->v = v;
333   nl->l = l;
334   
335   return nl;
336 }
337 void list_free(chained_list_t*l) {
338   if (l) {
339     list_free(l->l);
340     free(l);
341   }
342 }
343 int list_eq(chained_list_t*i,chained_list_t*j) {
344   if (!i || !j) return i == j;
345   if (i->v != j->v)
346     return 0;
347   return list_eq(i->l, j->l); 
348 }
349 gras_error_t test_chain_list(gras_socket_t *sock, int direction) {
350   gras_error_t errcode;
351   chained_list_t *i, *j; 
352
353   INFO0("==== Test on chained list ====");
354
355   /* init a value, exchange it and check its validity*/
356   i = cons( rand(), cons( rand() , cons( rand(), NULL)));
357   j = NULL;
358
359   TRY(write_read(gras_datadesc_by_name("chained_list_t*"),
360                  &i,&j,
361                  sock,direction));
362   if (direction == READ || direction == RW) {
363     gras_assert(list_eq(i,j));    
364     list_free(j);
365   }
366
367   list_free(i);
368   return no_error;
369 }
370 /***
371  *** graph
372  ***/
373 gras_error_t test_graph(gras_socket_t *sock, int direction) {
374   gras_error_t errcode;
375   chained_list_t *i, *j; 
376
377   INFO0("==== Test on graph (cyclique chained list) ====");
378   /* init a value, exchange it and check its validity*/
379   i = cons( rand(), cons( rand() , cons( rand(), NULL)));
380   i->l->l->l = i;
381   j = NULL;
382
383   TRY(write_read(gras_datadesc_by_name("chained_list_t*"),
384                  &i,&j, sock,direction));
385   if (direction == READ || direction == RW) {
386     
387     DEBUG1("i=%p"         ,i);
388     DEBUG1("i->l=%p"      ,i->l);
389     DEBUG1("i->l->l=%p"   ,i->l->l);
390     DEBUG1("i->l->l->l=%p",i->l->l->l);
391     DEBUG1("j=%p"         ,j);
392     DEBUG1("j->l=%p"      ,j->l);
393     DEBUG1("j->l->l=%p"   ,j->l->l);
394     DEBUG1("j->l->l->l=%p",j->l->l->l);
395     gras_assert4(j->l->l->l == j,
396                  "Received list is not cyclic. j=%p != j->l->l->l=%p\n"
397                  "j=%p; &j=%p",
398                  j,j->l->l->l, 
399                  j ,&j);
400     i->l->l->l = NULL;
401     j->l->l->l = NULL;
402     gras_assert(list_eq(i,j));
403
404     list_free(j);
405   }
406   list_free(i);
407   return no_error;
408 }
409
410 /**** PBIO *****/
411 typedef struct { /* structure presented in the IEEE article */
412   int Cnstatv;
413   double Cstatev[12];
414   int Cnprops;
415   double Cprops[110];
416   int Cndi[4], Cnshr, Cnpt;
417   double Cdtime, Ctime[2];
418   int Cntens;
419   double Cdfgrd0[3][373], Cdfgrd1[3][3], Cstress[106], Cddsdde[106][106];
420 } KSdata1;
421
422 int main(int argc,char *argv[]) {
423   gras_error_t errcode;
424   gras_socket_t *sock;
425   int direction = RW; // READ; // WRITE
426
427   gras_init_defaultlog(&argc,argv,
428                        "DataDesc.thresh=verbose"
429                        " test.thresh=debug"
430                        //" set.thresh=debug"
431                        );
432   if (argc >= 2) {
433     if (!strcmp(argv[1], "--read"))
434       direction = READ;
435     if (!strcmp(argv[1], "--write"))
436       direction = WRITE;
437   }
438     
439   if (direction == WRITE) 
440     TRYFAIL(gras_socket_client_from_file("datadesc_usage.out",&sock));
441   if (direction == READ) 
442     TRYFAIL(gras_socket_server_from_file("datadesc_usage.out",&sock));
443
444   TRYFAIL(test_int(sock,direction));    
445   TRYFAIL(test_float(sock,direction));  
446   TRYFAIL(test_array(sock,direction));  
447   TRYFAIL(test_intref(sock,direction)); 
448
449   TRYFAIL(test_string(sock,direction)); 
450
451   TRYFAIL(test_homostruct(sock,direction));
452   TRYFAIL(test_hetestruct(sock,direction));
453   TRYFAIL(test_nestedstruct(sock,direction));
454
455   TRYFAIL(declare_chained_list_type());
456   TRYFAIL(test_chain_list(sock,direction));
457   TRYFAIL(test_graph(sock,direction));
458
459   if (direction != RW) 
460     gras_socket_close(&sock);
461   gras_exit();
462   return 0;
463 }