Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Interface revolution: do not try to survive to malloc failure
[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 "gras/DataDesc/datadesc_interface.h"
15 GRAS_LOG_NEW_DEFAULT_CATEGORY(test,"Logging specific to this test");
16
17 #define READ  0
18 #define WRITE 1
19 #define RW    2
20
21 int r_arch;
22 const char *filename = "datadesc_usage.out";  
23
24 gras_error_t
25 write_read(gras_datadesc_type_t *type,void *src, void *dst, 
26            gras_socket_t *sock, int direction);
27
28 gras_error_t
29 write_read(gras_datadesc_type_t *type,void *src, void *dst, 
30            gras_socket_t *sock, int direction) {
31   gras_error_t errcode;
32    
33   /* write */
34   if (direction == RW) 
35     TRY(gras_socket_client_from_file(filename,&sock));
36   if (direction == WRITE || direction == RW)
37     TRY(gras_datadesc_send(sock, type, src));
38   if (direction == RW) 
39     gras_socket_close(sock);
40    
41   /* read */
42   if (direction == RW) 
43     TRY(gras_socket_server_from_file(filename,&sock));
44
45   if (direction == READ || direction == RW)
46     TRY(gras_datadesc_recv(sock, type, r_arch, dst));
47
48   if (direction == RW) 
49     gras_socket_close(sock);
50   
51   return no_error;
52 }
53
54 gras_error_t test_int(gras_socket_t *sock, int direction);
55 gras_error_t test_float(gras_socket_t *sock, int direction);
56 gras_error_t test_double(gras_socket_t *sock, int direction);
57 gras_error_t test_array(gras_socket_t *sock, int direction);
58 gras_error_t test_intref(gras_socket_t *sock, int direction);
59 gras_error_t test_string(gras_socket_t *sock, int direction);
60
61 gras_error_t test_homostruct(gras_socket_t *sock, int direction);
62 gras_error_t test_hetestruct(gras_socket_t *sock, int direction);
63 gras_error_t test_nestedstruct(gras_socket_t *sock, int direction);
64 gras_error_t test_chain_list(gras_socket_t *sock, int direction);
65 gras_error_t test_graph(gras_socket_t *sock, int direction);
66
67 gras_error_t test_pbio(gras_socket_t *sock, int direction);
68 gras_error_t test_clause(gras_socket_t *sock, int direction);
69
70 /* defined in datadesc_structures.c, which in perl generated */
71 gras_error_t test_structures(gras_socket_t *sock, int direction); 
72
73
74
75 gras_error_t test_int(gras_socket_t *sock, int direction) {
76   gras_error_t errcode;
77   int i=5,j;
78   
79   INFO0("---- Test on integer ----");
80   TRY(write_read(gras_datadesc_by_name("int"), &i,&j, sock,direction));
81   if (direction == READ || direction == RW) {
82     gras_assert(i == j);
83   }
84   return no_error;
85 }
86 gras_error_t test_float(gras_socket_t *sock, int direction) {
87   gras_error_t errcode;
88   float i=5.0,j;
89   
90   INFO0("---- Test on float ----");
91   TRY(write_read(gras_datadesc_by_name("float"), &i,&j, sock,direction));
92   if (direction == READ || direction == RW) {
93     gras_assert2(i == j,"%f != %f",i,j);
94   }
95   return no_error;
96 }
97 gras_error_t test_double(gras_socket_t *sock, int direction) {
98   gras_error_t errcode;
99   double i=-3252355.1234,j;
100   
101   INFO0("---- Test on double ----");
102   TRY(write_read(gras_datadesc_by_name("double"), &i,&j, sock,direction));
103   if (direction == READ || direction == RW) {
104     gras_assert2(i == j,"%f != %f",i,j);
105   }
106   return no_error;
107 }
108
109 #define SIZE 5
110 typedef int array[SIZE];
111 gras_error_t test_array(gras_socket_t *sock, int direction) {
112   gras_error_t errcode;
113   gras_datadesc_type_t *my_type;
114   
115   array i = { 35212,-6226,74337,11414,7733};
116   array j;
117   int cpt;
118
119   INFO0("---- Test on fixed array ----");
120
121   my_type=gras_datadesc_array_fixed("fixed int array", 
122                                     gras_datadesc_by_name("int"),
123                                     SIZE);
124
125   TRY(write_read(my_type, &i,&j, sock,direction));
126   if (direction == READ || direction == RW) {
127     for (cpt=0; cpt<SIZE; cpt++) {
128       DEBUG1("Test spot %d",cpt);
129       gras_assert4(i[cpt] == j[cpt],"i[%d]=%d  !=  j[%d]=%d",
130                    cpt,i[cpt],cpt,j[cpt]);
131     }
132   }
133   return no_error;
134 }
135 gras_error_t test_intref(gras_socket_t *sock, int direction) {
136   gras_error_t errcode;
137   gras_datadesc_type_t *my_type;
138   int *i,*j;
139   
140   i=gras_new(int,1);
141   *i=12345;
142
143   INFO1("---- Test on a reference to an integer (%p) ----",i);
144
145   my_type = gras_datadesc_ref("int*",gras_datadesc_by_name("int"));
146
147   TRY(write_read(my_type, &i,&j, sock,direction));
148   if (direction == READ || direction == RW) {
149     gras_assert(*i == *j);
150     gras_free(j);
151   }
152   gras_free(i);
153   return no_error;
154 }
155
156 /***
157  *** string (dynamic array)
158  ***/ 
159 gras_error_t test_string(gras_socket_t *sock, int direction) {
160   gras_error_t errcode;
161   char *i=gras_strdup("Some data"), *j=NULL;
162   int cpt;
163   
164   INFO0("---- Test on string (ref to dynamic array) ----");
165   TRY(write_read(gras_datadesc_by_name("string"), &i,&j,
166                  sock,direction));
167   if (direction == READ || direction == RW) {
168     for (cpt=0; cpt<strlen(i); cpt++) {
169       gras_assert4(i[cpt] == j[cpt],"i[%d]=%c  !=  j[%d]=%c",
170                    cpt,i[cpt],cpt,j[cpt]);
171     } 
172     gras_free(j);
173   }
174   gras_free(i);
175   return no_error;
176 }
177
178
179 /***
180  *** homogeneous struct
181  ***/ 
182 typedef struct {
183   int a,b,c,d;
184 } homostruct;
185 gras_error_t test_homostruct(gras_socket_t *sock, int direction) {
186   gras_error_t errcode;
187   gras_datadesc_type_t *my_type;
188   homostruct *i, *j; 
189
190   INFO0("---- Test on homogeneous structure ----");
191   /* create descriptor */
192   my_type=gras_datadesc_struct("homostruct");
193   gras_datadesc_struct_append(my_type,"a",
194                               gras_datadesc_by_name("signed int"));
195   gras_datadesc_struct_append(my_type,"b",
196                               gras_datadesc_by_name("int"));
197   gras_datadesc_struct_append(my_type,"c",
198                               gras_datadesc_by_name("int"));
199   gras_datadesc_struct_append(my_type,"d",
200                               gras_datadesc_by_name("int"));
201   gras_datadesc_struct_close(my_type);
202   my_type=gras_datadesc_ref("homostruct*",
203                             gras_datadesc_by_name("homostruct"));
204
205   /* init a value, exchange it and check its validity*/
206   i=gras_new(homostruct,1);
207   i->a = 2235;    i->b = 433425;
208   i->c = -23423;  i->d = -235235;
209
210   TRY(write_read(my_type, &i,&j, sock,direction));
211   if (direction == READ || direction == RW) {
212     gras_assert(i->a == j->a);
213     gras_assert(i->b == j->b);
214     gras_assert(i->c == j->c);
215     gras_assert(i->d == j->d);
216     gras_free(j);
217   }
218   gras_free(i);
219   return no_error;
220 }
221
222 /***
223  *** heterogeneous struct
224  ***/ 
225 typedef struct {
226   unsigned char c1;
227   unsigned long int l1;
228   unsigned char c2;
229   unsigned long int l2;
230 } hetestruct;
231 gras_error_t test_hetestruct(gras_socket_t *sock, int direction) {
232   gras_error_t errcode;
233   gras_datadesc_type_t *my_type;
234   hetestruct *i, *j; 
235
236   INFO0("---- Test on heterogeneous structure ----");
237   /* create descriptor */
238   my_type=gras_datadesc_struct("hetestruct");
239   gras_datadesc_struct_append(my_type,"c1",
240                               gras_datadesc_by_name("unsigned char"));
241   gras_datadesc_struct_append(my_type,"l1",
242                               gras_datadesc_by_name("unsigned long int"));
243   gras_datadesc_struct_append(my_type,"c2",
244                               gras_datadesc_by_name("unsigned char"));
245   gras_datadesc_struct_append(my_type,"l2",
246                               gras_datadesc_by_name("unsigned long int"));
247   gras_datadesc_struct_close(my_type);
248   my_type=gras_datadesc_ref("hetestruct*", gras_datadesc_by_name("hetestruct"));
249
250
251   /* init a value, exchange it and check its validity*/
252   i=gras_new(hetestruct,1);
253   i->c1 = 's'; i->l1 = 123455;
254   i->c2 = 'e'; i->l2 = 774531;
255
256   TRY(write_read(my_type, &i,&j, sock,direction));
257   if (direction == READ || direction == RW) {
258     gras_assert(i->c1 == j->c1);
259     gras_assert(i->c2 == j->c2);
260     gras_assert2(i->l1 == j->l1,"i->l1(=%ld)  !=  j->l1(=%ld)",i->l1,j->l1);
261     gras_assert(i->l2 == j->l2);
262     gras_free(j);
263   }
264   gras_free(i);
265   return no_error;
266 }
267
268 /***
269  *** nested struct
270  ***/ 
271 typedef struct {
272   hetestruct hete;
273   homostruct homo;
274 } nestedstruct;
275 gras_error_t test_nestedstruct(gras_socket_t *sock, int direction) {
276   gras_error_t errcode;
277   gras_datadesc_type_t *my_type;
278   nestedstruct *i, *j; 
279
280   INFO0("---- Test on nested structures ----");
281   /* create descriptor */
282   my_type=gras_datadesc_struct("nestedstruct");
283
284   gras_datadesc_struct_append(my_type,"hete",
285                               gras_datadesc_by_name("hetestruct"));
286   gras_datadesc_struct_append(my_type,"homo",
287                               gras_datadesc_by_name("homostruct"));
288   gras_datadesc_struct_close(my_type);
289   my_type=gras_datadesc_ref("nestedstruct*", gras_datadesc_by_name("nestedstruct"));
290
291   /* init a value, exchange it and check its validity*/
292   i=gras_new(nestedstruct,1);
293   i->homo.a = 235231;  i->homo.b = -124151;
294   i->homo.c = 211551;  i->homo.d = -664222;
295   i->hete.c1 = 's'; i->hete.l1 = 123455;
296   i->hete.c2 = 'e'; i->hete.l2 = 774531;
297
298   TRY(write_read(my_type, &i,&j, sock,direction));
299   if (direction == READ || direction == RW) {
300     gras_assert(i->homo.a == j->homo.a);
301     gras_assert(i->homo.b == j->homo.b);
302     gras_assert(i->homo.c == j->homo.c);
303     gras_assert(i->homo.d == j->homo.d);
304     gras_assert(i->hete.c1 == j->hete.c1);
305     gras_assert(i->hete.c2 == j->hete.c2);
306     gras_assert(i->hete.l1 == j->hete.l1);
307     gras_assert(i->hete.l2 == j->hete.l2);
308     gras_free(j);
309   }
310   gras_free(i);
311   return no_error;
312 }
313
314 /***
315  *** chained list
316  ***/ 
317 typedef struct s_chained_list chained_list_t;
318 struct s_chained_list {
319   int          v;
320   chained_list_t *l;
321 };
322 gras_error_t declare_chained_list_type(void);
323 chained_list_t *cons(int v, chained_list_t *l);
324 void list_free(chained_list_t *l);
325 int list_eq(chained_list_t*i,chained_list_t*j);
326
327 gras_error_t declare_chained_list_type(void) {
328   gras_error_t errcode;
329   gras_datadesc_type_t *my_type,*ref_my_type;
330
331   my_type=gras_datadesc_struct("chained_list_t");
332   ref_my_type=gras_datadesc_ref("chained_list_t*",my_type);
333
334   gras_datadesc_struct_append(my_type,"v", gras_datadesc_by_name("int"));
335   gras_datadesc_struct_append(my_type,"l", ref_my_type);
336   gras_datadesc_struct_close(my_type);
337
338   return no_error;
339 }
340
341 chained_list_t * cons(int v, chained_list_t *l) {
342   chained_list_t *nl = gras_new(chained_list_t,1);
343   
344   nl->v = v;
345   nl->l = l;
346   
347   return nl;
348 }
349 void list_free(chained_list_t*l) {
350   if (l) {
351     list_free(l->l);
352     gras_free(l);
353   }
354 }
355 int list_eq(chained_list_t*i,chained_list_t*j) {
356   if (!i || !j) return i == j;
357   if (i->v != j->v)
358     return 0;
359   return list_eq(i->l, j->l); 
360 }
361 gras_error_t test_chain_list(gras_socket_t *sock, int direction) {
362   gras_error_t errcode;
363   chained_list_t *i, *j; 
364
365   INFO0("---- Test on chained list ----");
366
367   /* init a value, exchange it and check its validity*/
368   i = cons( 12355, cons( 246264 , cons( 23263, NULL)));
369   j = NULL;
370
371   TRY(write_read(gras_datadesc_by_name("chained_list_t*"),
372                  &i,&j,
373                  sock,direction));
374   if (direction == READ || direction == RW) {
375     gras_assert(list_eq(i,j));    
376     list_free(j);
377   }
378
379   list_free(i);
380   return no_error;
381 }
382 /***
383  *** graph
384  ***/
385 gras_error_t test_graph(gras_socket_t *sock, int direction) {
386   gras_error_t errcode;
387   chained_list_t *i, *j; 
388
389   INFO0("---- Test on graph (cyclique chained list) ----");
390   /* init a value, exchange it and check its validity*/
391   i = cons( 1151515, cons( -232362 , cons( 222552, NULL)));
392   i->l->l->l = i;
393   j = NULL;
394
395   TRY(write_read(gras_datadesc_by_name("chained_list_t*"),
396                  &i,&j, sock,direction));
397   if (direction == READ || direction == RW) {
398     
399     DEBUG1("i=%p"         ,i);
400     DEBUG1("i->l=%p"      ,i->l);
401     DEBUG1("i->l->l=%p"   ,i->l->l);
402     DEBUG1("i->l->l->l=%p",i->l->l->l);
403     DEBUG1("j=%p"         ,j);
404     DEBUG1("j->l=%p"      ,j->l);
405     DEBUG1("j->l->l=%p"   ,j->l->l);
406     DEBUG1("j->l->l->l=%p",j->l->l->l);
407     gras_assert4(j->l->l->l == j,
408                  "Received list is not cyclic. j=%p != j->l->l->l=%p\n"
409                  "j=%p; &j=%p",
410                  j,j->l->l->l, 
411                  j ,&j);
412     j->l->l->l = NULL;
413     i->l->l->l = NULL;
414     gras_assert(list_eq(i,j));
415
416     list_free(j);
417   }
418   i->l->l->l = NULL; /* do this even in WRITE mode */
419   list_free(i);
420   return no_error;
421 }
422
423 /**** PBIO *****/
424 GRAS_DEFINE_TYPE(s_pbio,
425 struct s_pbio{ /* structure presented in the IEEE article */
426   int Cnstatv;
427   double Cstatev[12];
428   int Cnprops;
429   double Cprops[110];
430   int Cndi[4];
431   int Cnshr;
432   int Cnpt;
433   double Cdtime;
434   double Ctime[2];
435   int Cntens;
436   double Cdfgrd0[373][3];
437   double Cdfgrd1[3][3];
438   double Cstress[106];
439   double Cddsdde[106][106];
440 };
441                  )
442 typedef struct s_pbio pbio_t;
443
444 gras_error_t test_pbio(gras_socket_t *sock, int direction) {
445   gras_error_t errcode;
446   pbio_t i,j;
447   int cpt;
448   int cpt2;
449   gras_datadesc_type_t *pbio_type;
450
451   INFO0("---- Test on the PBIO IEEE struct (also tests GRAS DEFINE TYPE) ----");
452   pbio_type = gras_datadesc_by_symbol(s_pbio);
453
454   /* Fill in that damn struct */
455   i.Cnstatv = 325115;
456   for (cpt=0; cpt<12; cpt++) 
457     i.Cstatev[cpt] = ((double) cpt) * -2361.11;
458   i.Cnprops = -37373;
459   for (cpt=0; cpt<110; cpt++)
460     i.Cprops[cpt] = cpt * 100.0;
461   for (cpt=0; cpt<4; cpt++)
462     i.Cndi[cpt] = cpt * 23262;
463   i.Cnshr = -4634;
464   i.Cnpt = 114142;
465   i.Cdtime = -11515.662;
466   i.Ctime[0] = 332523.226;
467   i.Ctime[1] = -26216.113;
468   i.Cntens = 235211411;
469   
470   for (cpt=0; cpt<3; cpt++) {
471     for (cpt2=0; cpt2<373; cpt2++)
472       i.Cdfgrd0[cpt2][cpt] = ((double)cpt) * ((double)cpt2);
473     for (cpt2=0; cpt2<3; cpt2++)
474       i.Cdfgrd1[cpt][cpt2] = -((double)cpt) * ((double)cpt2);
475   }
476   for (cpt=0; cpt<106; cpt++) {
477     i.Cstress[cpt]=(double)cpt * 22.113;
478     for (cpt2=0; cpt2<106; cpt2++) 
479       i.Cddsdde[cpt][cpt2] = ((double)cpt) * ((double)cpt2);
480   }
481   TRY(write_read(gras_datadesc_by_symbol(s_pbio),
482                  &i,&j, sock,direction));
483   if (direction == READ || direction == RW) {
484     /* Check that the data match */
485     gras_assert(i.Cnstatv == j.Cnstatv);
486     for (cpt=0; cpt<12; cpt++)
487       gras_assert(i.Cstatev[cpt] == j.Cstatev[cpt]);
488     gras_assert(i.Cnprops == j.Cnprops);
489     for (cpt=0; cpt<110; cpt++)
490       gras_assert(i.Cprops[cpt] == j.Cprops[cpt]);
491     for (cpt=0; cpt<4; cpt++) 
492       gras_assert(i.Cndi[cpt] == j.Cndi[cpt]);
493     gras_assert(i.Cnshr == j.Cnshr);
494     gras_assert(i.Cnpt == j.Cnpt);
495     gras_assert(i.Cdtime == j.Cdtime);
496     gras_assert(i.Ctime[0] == j.Ctime[0]);
497     gras_assert(i.Ctime[1] == j.Ctime[1]);
498     gras_assert(i.Cntens == j.Cntens);
499     for (cpt=0; cpt<3; cpt++) {
500       for (cpt2=0; cpt2<373; cpt2++)
501         gras_assert(i.Cdfgrd0[cpt2][cpt] == j.Cdfgrd0[cpt2][cpt]);
502       for (cpt2=0; cpt2<3; cpt2++)
503         gras_assert(i.Cdfgrd1[cpt][cpt2] == j.Cdfgrd1[cpt][cpt2]);
504     }
505     for (cpt=0; cpt<106; cpt++) {
506       gras_assert(i.Cstress[cpt] == j.Cstress[cpt]);
507       for (cpt2=0; cpt2<106; cpt2++) 
508         gras_assert4(i.Cddsdde[cpt][cpt2] == j.Cddsdde[cpt][cpt2],
509                      "%f=i.Cddsdde[%d][%d] != j.Cddsdde[cpt][cpt2]=%f",
510                      i.Cddsdde[cpt][cpt2],cpt,cpt2,j.Cddsdde[cpt][cpt2]);
511     }
512   }
513
514   return no_error;
515 }
516
517 GRAS_DEFINE_TYPE(s_clause,
518 struct s_clause {
519    int num_lits;
520    int *literals GRAS_ANNOTE(size,num_lits); /* Tells GRAS where to find the size */
521 };)
522 typedef struct s_clause Clause;
523
524 gras_error_t test_clause(gras_socket_t *sock, int direction) {
525   gras_error_t errcode;
526   gras_datadesc_type_t *ddt,*array_t;
527   Clause *i,*j;
528   int cpt;
529   
530   INFO0("---- Test on struct containing dynamic array and its size (cbps test) ----");
531
532   /* create and fill the struct */
533   i=gras_new(Clause,1);
534
535   i->num_lits = 5432;
536   i->literals = gras_new(int, i->num_lits);
537   for (cpt=0; cpt<i->num_lits; cpt++)
538     i->literals[cpt] = cpt * cpt - ((cpt * cpt) / 2);
539   DEBUG3("created data=%p (within %p @%p)",&(i->num_lits),i,&i);
540   DEBUG1("created count=%d",i->num_lits);
541
542   /* create the damn type descriptor */
543   ddt = gras_datadesc_by_symbol(s_clause);
544 /*  gras_datadesc_type_dump(ddt); */
545
546   ddt=gras_datadesc_ref("Clause*",ddt);
547
548   TRY(write_read(ddt, &i,&j, sock,direction));
549   if (direction == READ || direction == RW) {
550     gras_assert(i->num_lits == j->num_lits);
551     for (cpt=0; cpt<i->num_lits; cpt++)
552       gras_assert(i->literals[cpt] == j->literals[cpt]);
553     
554     gras_free(j->literals);
555     gras_free(j);
556   }
557   gras_free(i->literals);
558   gras_free(i);
559   return no_error;
560 }
561
562 int main(int argc,char *argv[]) {
563   gras_error_t errcode;
564   gras_socket_t *sock;
565   int direction = RW;
566   int cpt;
567   char r_arch_char = gras_arch_selfid();
568
569   gras_init_defaultlog(&argc,argv,NULL);
570
571   for (cpt=1; cpt<argc; cpt++) {
572     if (!strcmp(argv[cpt], "--read")) {
573       direction = READ;
574     } else if (!strcmp(argv[cpt], "--write")) {
575       direction = WRITE;
576     } else {
577        filename=argv[cpt];
578     }
579   }
580     
581   if (direction == WRITE) {
582     TRYFAIL(gras_socket_client_from_file(filename,&sock));
583     TRY(gras_datadesc_send(sock, gras_datadesc_by_name("char"),
584                            &r_arch_char));
585   }
586   if (direction == READ) {
587     TRYFAIL(gras_socket_server_from_file(filename,&sock));
588     TRY(gras_datadesc_recv(sock, gras_datadesc_by_name("char"),
589                            gras_arch_selfid(), &r_arch_char));
590     INFO3("This datafile was generated on %s (%d), I'm %s.",
591           gras_datadesc_arch_name(r_arch_char),(int)r_arch_char,
592           gras_datadesc_arch_name(gras_arch_selfid()));
593   }
594   r_arch = (int)r_arch_char;
595   
596   TRYFAIL(test_int(sock,direction));    
597   TRYFAIL(test_float(sock,direction));  
598   TRYFAIL(test_double(sock,direction));  
599   TRYFAIL(test_array(sock,direction));  
600   TRYFAIL(test_intref(sock,direction)); 
601   
602   TRYFAIL(test_string(sock,direction)); 
603
604   TRYFAIL(test_structures(sock,direction));
605
606   TRYFAIL(test_homostruct(sock,direction));
607   TRYFAIL(test_hetestruct(sock,direction));
608   TRYFAIL(test_nestedstruct(sock,direction));
609
610   TRYFAIL(declare_chained_list_type());
611   TRYFAIL(test_chain_list(sock,direction));
612   /*  TRYFAIL(test_graph(sock,direction)); */
613
614   TRYFAIL(test_pbio(sock,direction));
615
616   TRYFAIL(test_clause(sock,direction));
617
618   if (direction != RW) 
619     gras_socket_close(sock);
620   gras_exit();
621   return 0;
622 }
623