Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Catch up with the lastest API breakage
[simgrid.git] / src / gras / DataDesc / ddt_create.c
1 /* $Id$ */
2
3 /* ddt_new - creation/deletion of datatypes structs (private to this module)*/
4
5 /* Copyright (c) 2003 Olivier Aumage.                                       */
6 /* Copyright (c) 2003, 2004 Martin Quinson.                                 */
7 /* All rights reserved.                                                     */
8
9 /* This program is free software; you can redistribute it and/or modify it
10  * under the terms of the license (GNU LGPL) which comes with this package. */
11
12 #include "xbt/misc.h" /* min()/max() */
13 #include "xbt/ex.h"
14 #include "gras/DataDesc/datadesc_private.h"
15
16 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(ddt_create,datadesc,"Creating new datadescriptions");
17
18 /*** prototypes ***/
19 static gras_dd_cat_field_t
20   gras_dd_find_field(gras_datadesc_type_t  type,
21                      const char           *field_name);
22 /**
23  * gras_ddt_freev:
24  *
25  * gime that memory back, dude. I mean it.
26  */
27 void gras_ddt_freev(void *ddt) {
28   gras_datadesc_type_t type= (gras_datadesc_type_t)ddt;
29   
30   if (type) {
31     gras_datadesc_free(&type);
32   }
33 }
34
35 static gras_datadesc_type_t gras_ddt_new(const char *name) {
36   gras_datadesc_type_t res;
37
38   XBT_IN1("(%s)",name);
39   res=xbt_new0(s_gras_datadesc_type_t,1);
40
41   res->name = (char*)strdup(name);
42   res->name_len = strlen(name);
43   res->cycle = 0;
44       
45   xbt_set_add(gras_datadesc_set_local,
46                (xbt_set_elm_t)res,&gras_ddt_freev);
47   XBT_OUT;
48   return res;
49 }
50
51 /**
52  * This returns NULL no type of this name can be found instead of throwing exceptions which would complicate the GRAS_DEFINE_TYPE macro
53  */
54 gras_datadesc_type_t gras_datadesc_by_name(const char *name) {
55   xbt_ex_t e;
56   gras_datadesc_type_t res = NULL;
57   TRY {
58     res = (gras_datadesc_type_t)xbt_set_get_by_name(gras_datadesc_set_local,name);
59   } CATCH(e) {
60     if (e.category != not_found_error)
61       RETHROW;
62     xbt_ex_free(&e);
63     res = NULL;
64   }
65   return res;
66 }
67
68 /**
69  * Retrieve a type from its code (or NULL if not found)
70  */
71 gras_datadesc_type_t gras_datadesc_by_id(long int code) {
72   xbt_ex_t e;
73   gras_datadesc_type_t res=NULL;
74   TRY {
75     res = (gras_datadesc_type_t)xbt_set_get_by_id(gras_datadesc_set_local,code);
76   } CATCH(e) {
77     if (e.category != not_found_error)
78       RETHROW;
79     xbt_ex_free(&e);
80     res = NULL;
81   }
82   return res;
83 }
84
85 /**
86  * Create a new scalar and give a pointer to it 
87  */
88 gras_datadesc_type_t 
89   gras_datadesc_scalar(const char                      *name,
90                        gras_ddt_scalar_type_t           type,
91                        enum e_gras_dd_scalar_encoding   encoding) {
92
93   gras_datadesc_type_t res;
94   long int arch;
95
96   XBT_IN;
97   res = gras_datadesc_by_name(name);
98   if (res) {
99     xbt_assert1(res->category_code == e_gras_datadesc_type_cat_scalar,
100                  "Redefinition of type %s does not match", name);
101     xbt_assert1(res->category.scalar_data.encoding == encoding,
102                  "Redefinition of type %s does not match", name);
103     xbt_assert1(res->category.scalar_data.type == type,
104                  "Redefinition of type %s does not match", name);
105     VERB1("Discarding redefinition of %s",name);
106     return res;
107   } 
108   res = gras_ddt_new(name);
109
110   for (arch = 0; arch < gras_arch_count; arch ++) {
111     res->size[arch]         = gras_arches[arch].sizeofs[type];
112     res->alignment[arch]    = gras_arches[arch].boundaries[type];
113     res->aligned_size[arch] = aligned(res->size[arch], res->alignment[arch]);
114   }
115
116   res->category_code                 = e_gras_datadesc_type_cat_scalar;
117   res->category.scalar_data.encoding = encoding;
118   res->category.scalar_data.type     = type;
119   XBT_OUT;
120   
121   return res;
122 }
123
124
125 /** Frees one struct or union field */
126 void gras_dd_cat_field_free(void *f) {
127   gras_dd_cat_field_t field = *(gras_dd_cat_field_t *)f;
128   XBT_IN;
129   if (field) {
130     if (field->name) 
131       free(field->name);
132     free(field);
133   }
134   XBT_OUT;
135 }
136
137 /** \brief Declare a new structure description */
138 gras_datadesc_type_t 
139   gras_datadesc_struct(const char            *name) {
140
141   gras_datadesc_type_t res;
142   long int arch;
143   
144   XBT_IN1("(%s)",name);
145   res = gras_datadesc_by_name(name);
146   if (res) {
147     /* FIXME: Check that field redefinition matches */
148     xbt_assert1(res->category_code == e_gras_datadesc_type_cat_struct,
149                  "Redefinition of type %s does not match", name);
150     VERB1("Discarding redefinition of %s",name);
151     return res;
152   }
153   res = gras_ddt_new(name);
154
155   for (arch=0; arch<gras_arch_count; arch ++) {
156     res->size[arch] = 0;
157     res->alignment[arch] = 0;
158     res->aligned_size[arch] = 0;
159   }
160   res->category_code = e_gras_datadesc_type_cat_struct;
161   res->category.struct_data.fields = 
162        xbt_dynar_new(sizeof(gras_dd_cat_field_t),
163                       &gras_dd_cat_field_free);
164
165   XBT_OUT;
166   return res;
167 }
168
169 /** \brief Append a new field to a structure description */
170 void
171 gras_datadesc_struct_append(gras_datadesc_type_t struct_type,
172                             const char          *name,
173                             gras_datadesc_type_t field_type) {
174
175   gras_dd_cat_field_t field;
176   int arch;
177
178   xbt_assert2(field_type,
179                "Cannot add the field '%s' into struct '%s': its type is NULL. Typo in get_by_name?",
180                name,struct_type->name);
181   XBT_IN3("(%s %s.%s;)",field_type->name,struct_type->name,name);
182   if (struct_type->category.struct_data.closed) {
183     VERB1("Ignoring request to add field to struct %s (closed. Redefinition?)",
184           struct_type->name);
185     return;
186   }
187
188   xbt_assert1(field_type->size != 0,
189                "Cannot add a dynamically sized field in structure %s",
190                struct_type->name);
191     
192   field=xbt_new(s_gras_dd_cat_field_t,1);
193   field->name   = (char*)strdup(name);
194
195   DEBUG0("----------------");
196   DEBUG3("PRE s={size=%ld,align=%ld,asize=%ld}",
197          struct_type->size[GRAS_THISARCH], 
198          struct_type->alignment[GRAS_THISARCH], 
199          struct_type->aligned_size[GRAS_THISARCH]);
200      
201      
202   for (arch=0; arch<gras_arch_count; arch ++) {
203     field->offset[arch] = aligned(struct_type->size[arch],
204                                   field_type->alignment[arch]);
205
206     struct_type->size[arch] = field->offset[arch] + field_type->size[arch];
207     struct_type->alignment[arch] = max(struct_type->alignment[arch],
208                                        field_type->alignment[arch]);
209     struct_type->aligned_size[arch] = aligned(struct_type->size[arch],
210                                               struct_type->alignment[arch]);
211   }
212   field->type   = field_type;
213   field->send   = NULL;
214   field->recv   = NULL;
215   
216   xbt_dynar_push(struct_type->category.struct_data.fields, &field);
217
218   DEBUG3("Push a %s into %s at offset %ld.",
219          field_type->name, struct_type->name,field->offset[GRAS_THISARCH]);
220   DEBUG3("  f={size=%ld,align=%ld,asize=%ld}",
221          field_type->size[GRAS_THISARCH], 
222          field_type->alignment[GRAS_THISARCH], 
223          field_type->aligned_size[GRAS_THISARCH]);
224   DEBUG3("  s={size=%ld,align=%ld,asize=%ld}",
225          struct_type->size[GRAS_THISARCH], 
226          struct_type->alignment[GRAS_THISARCH], 
227          struct_type->aligned_size[GRAS_THISARCH]);
228   XBT_OUT;
229 }
230
231 /** \brief Close a structure description
232  * 
233  * No new field can be added afterward, and it is mandatory to close the structure before using it.
234  */
235 void
236 gras_datadesc_struct_close(gras_datadesc_type_t struct_type) {
237   XBT_IN;
238   struct_type->category.struct_data.closed = 1;
239   DEBUG4("structure %s closed. size=%ld,align=%ld,asize=%ld",
240          struct_type->name,
241          struct_type->size[GRAS_THISARCH], 
242          struct_type->alignment[GRAS_THISARCH], 
243          struct_type->aligned_size[GRAS_THISARCH]);
244 }
245
246 /**
247  * gras_datadesc_cycle_set:
248  * 
249  * Tell GRAS that the pointers of the type described by ddt may present
250  * some loop, and that the cycle detection mechanism is needed.
251  *
252  * Note that setting this option when not needed have a rather bad effect 
253  * on the performance (several times slower on big data).
254  */
255 void
256 gras_datadesc_cycle_set(gras_datadesc_type_t ddt) {
257   ddt->cycle = 1;
258 }
259
260 /**
261  * gras_datadesc_cycle_unset:
262  * 
263  * Tell GRAS that the pointers of the type described by ddt do not present
264  * any loop and that cycle detection mechanism are not needed.
265  * (default)
266  */
267 void
268 gras_datadesc_cycle_unset(gras_datadesc_type_t ddt) {
269   ddt->cycle = 0;
270 }
271
272 /** \brief Declare a new union description */
273 gras_datadesc_type_t 
274   gras_datadesc_union(const char                   *name,
275                       gras_datadesc_type_cb_int_t   selector) {
276
277   gras_datadesc_type_t res;
278   int arch;
279
280   XBT_IN1("(%s)",name);
281   xbt_assert0(selector,
282                "Attempt to creat an union without field_count function");
283
284   res = gras_datadesc_by_name(name);
285   if (res) {
286     /* FIXME: Check that field redefinition matches */
287     xbt_assert1(res->category_code == e_gras_datadesc_type_cat_union,
288                  "Redefinition of type %s does not match", name);
289     xbt_assert1(res->category.union_data.selector == selector,
290                  "Redefinition of type %s does not match", name);
291     VERB1("Discarding redefinition of %s",name);
292     return res;
293   }
294
295   res = gras_ddt_new(name);
296
297   for (arch=0; arch<gras_arch_count; arch ++) {
298      res->size[arch] = 0;
299      res->alignment[arch] = 0;
300      res->aligned_size[arch] = 0;
301   }
302
303   res->category_code            = e_gras_datadesc_type_cat_union;
304   res->category.union_data.fields =
305      xbt_dynar_new(sizeof(gras_dd_cat_field_t*),
306                     &gras_dd_cat_field_free);
307   res->category.union_data.selector = selector;
308
309   return res;
310 }
311
312 /** \brief Append a new field to an union description */
313 void gras_datadesc_union_append(gras_datadesc_type_t  union_type,
314                                 const char           *name,
315                                 gras_datadesc_type_t  field_type) {
316
317   gras_dd_cat_field_t field;
318   int arch;
319
320   XBT_IN3("(%s %s.%s;)",field_type->name,union_type->name,name);
321   xbt_assert1(field_type->size != 0,
322                "Cannot add a dynamically sized field in union %s",
323                union_type->name);
324
325   if (union_type->category.union_data.closed) {
326     VERB1("Ignoring request to add field to union %s (closed)",
327            union_type->name);
328     return;
329   }
330     
331   field=xbt_new0(s_gras_dd_cat_field_t,1);
332
333   field->name   = (char*)strdup(name);
334   field->type   = field_type;
335   /* All offset are left to 0 in an union */
336   
337   xbt_dynar_push(union_type->category.union_data.fields, &field);
338
339   for (arch=0; arch<gras_arch_count; arch ++) {
340     union_type->size[arch] = max(union_type->size[arch],
341                                  field_type->size[arch]);
342     union_type->alignment[arch] = max(union_type->alignment[arch],
343                                       field_type->alignment[arch]);
344     union_type->aligned_size[arch] = aligned(union_type->size[arch],
345                                              union_type->alignment[arch]);
346   }
347 }
348
349
350 /** \brief Close an union description 
351  *
352  * No new field can be added afterward, and it is mandatory to close the union before using it.
353  */
354 void
355 gras_datadesc_union_close(gras_datadesc_type_t union_type) {
356    union_type->category.union_data.closed = 1;
357 }
358
359 /** \brief Declare a new type being a reference to the one passed in arg */
360 gras_datadesc_type_t 
361   gras_datadesc_ref(const char           *name,
362                     gras_datadesc_type_t  referenced_type) {
363
364   gras_datadesc_type_t res;
365   gras_datadesc_type_t pointer_type = gras_datadesc_by_name("data pointer");
366   int arch;
367
368   XBT_IN1("(%s)",name);
369   res = gras_datadesc_by_name(name);
370   if (res) {
371     xbt_assert1(res->category_code == e_gras_datadesc_type_cat_ref,
372                  "Redefinition of %s does not match",name);
373     xbt_assert1(res->category.ref_data.type == referenced_type,
374                  "Redefinition of %s does not match",name);
375     xbt_assert1(res->category.ref_data.selector == NULL,
376                  "Redefinition of %s does not match",name);
377     VERB1("Discarding redefinition of %s",name);
378     return res;
379   }
380
381   res = gras_ddt_new(name);
382
383   xbt_assert0(pointer_type, "Cannot get the description of data pointer");
384       
385   for (arch=0; arch<gras_arch_count; arch ++){
386     res->size[arch] = pointer_type->size[arch];
387     res->alignment[arch] = pointer_type->alignment[arch];
388     res->aligned_size[arch] = pointer_type->aligned_size[arch];
389   }
390   
391   res->category_code              = e_gras_datadesc_type_cat_ref;
392   res->category.ref_data.type     = referenced_type;
393   res->category.ref_data.selector = NULL;
394
395   return res;
396 }
397 /** \brief Declare a new type being a generic reference.
398  * 
399  * The callback passed in argument is to be used to select which type is currently used.
400  * So, when GRAS wants to send a generic reference, it passes the current data to the selector 
401  * callback and expects it to return the type description to use. 
402  */
403 gras_datadesc_type_t 
404   gras_datadesc_ref_generic(const char                *name,
405                             gras_datadesc_selector_t   selector) {
406
407   gras_datadesc_type_t res;
408   gras_datadesc_type_t pointer_type = gras_datadesc_by_name("data pointer");
409   int arch;
410
411   XBT_IN1("(%s)",name);
412   res = gras_datadesc_by_name(name);
413
414   if (res) {
415     xbt_assert1(res->category_code == e_gras_datadesc_type_cat_ref,
416                  "Redefinition of type %s does not match", name);
417     xbt_assert1(res->category.ref_data.type == NULL,
418                  "Redefinition of type %s does not match", name);
419     xbt_assert1(res->category.ref_data.selector == selector,
420                  "Redefinition of type %s does not match", name);
421     VERB1("Discarding redefinition of %s",name);
422     return res;
423   }
424   res = gras_ddt_new(name);
425
426   xbt_assert0(pointer_type, "Cannot get the description of data pointer");
427       
428   for (arch=0; arch<gras_arch_count; arch ++) {
429     res->size[arch] = pointer_type->size[arch];
430     res->alignment[arch] = pointer_type->alignment[arch];
431     res->aligned_size[arch] = pointer_type->aligned_size[arch];
432   }
433
434   res->category_code            = e_gras_datadesc_type_cat_ref;
435
436   res->category.ref_data.type     = NULL;
437   res->category.ref_data.selector = selector;
438
439   return res;
440 }
441
442 /** \brief Declare a new type being an array of fixed size and content */
443 gras_datadesc_type_t 
444   gras_datadesc_array_fixed(const char           *name,
445                             gras_datadesc_type_t  element_type,
446                             long int              fixed_size) {
447
448   gras_datadesc_type_t res;
449   int arch;
450
451   XBT_IN1("(%s)",name);
452   res = gras_datadesc_by_name(name);
453   if (res) {
454     xbt_assert1(res->category_code == e_gras_datadesc_type_cat_array,
455                  "Redefinition of type %s does not match", name);
456      
457     if (res->category.array_data.type != element_type) {
458        ERROR1("Redefinition of type %s does not match: array elements differ", name);
459        gras_datadesc_type_dump(res->category.array_data.type);
460        gras_datadesc_type_dump(element_type);
461     }
462      
463     xbt_assert1(res->category.array_data.fixed_size == fixed_size,
464                  "Redefinition of type %s does not match", name);
465     xbt_assert1(res->category.array_data.dynamic_size == NULL,
466                  "Redefinition of type %s does not match", name);
467     VERB1("Discarding redefinition of %s",name);
468
469     return res;
470   }
471   res = gras_ddt_new(name);
472
473   xbt_assert1(fixed_size > 0, "'%s' is a array of null fixed size",name);
474   for (arch=0; arch<gras_arch_count; arch ++) {
475     res->size[arch] = fixed_size * element_type->aligned_size[arch];
476     res->alignment[arch] = element_type->alignment[arch];
477     res->aligned_size[arch] = res->size[arch];
478   }  
479
480   res->category_code            = e_gras_datadesc_type_cat_array;
481
482   res->category.array_data.type         = element_type;
483   res->category.array_data.fixed_size   = fixed_size;
484   res->category.array_data.dynamic_size = NULL;
485
486   return res;
487 }
488
489 /** \brief Declare a new type being an array of fixed size, but accepting several content types. */
490 gras_datadesc_type_t gras_datadesc_array_dyn(const char                 *name,
491                                              gras_datadesc_type_t        element_type,
492                                              gras_datadesc_type_cb_int_t dynamic_size) {
493
494   gras_datadesc_type_t res;
495   int arch;
496
497   XBT_IN1("(%s)",name);
498   xbt_assert1(dynamic_size,
499                "'%s' is a dynamic array without size discriminant",
500                name);
501
502   res = gras_datadesc_by_name(name);
503   if (res) {
504     xbt_assert1(res->category_code == e_gras_datadesc_type_cat_array,
505                  "Redefinition of type %s does not match", name);
506     xbt_assert1(res->category.array_data.type == element_type,
507                  "Redefinition of type %s does not match", name);
508     xbt_assert1(res->category.array_data.fixed_size == 0,
509                  "Redefinition of type %s does not match", name);
510     xbt_assert1(res->category.array_data.dynamic_size == dynamic_size,
511                  "Redefinition of type %s does not match", name);
512     VERB1("Discarding redefinition of %s",name);
513
514     return res;
515   }
516
517   res = gras_ddt_new(name);
518
519   for (arch=0; arch<gras_arch_count; arch ++) {
520     res->size[arch] = 0; /* make sure it indicates "dynamic" */
521     res->alignment[arch] = element_type->alignment[arch];
522     res->aligned_size[arch] = 0; /*FIXME: That was so in GS, but looks stupid*/
523   }
524
525   res->category_code            = e_gras_datadesc_type_cat_array;
526
527   res->category.array_data.type         = element_type;
528   res->category.array_data.fixed_size   = 0;
529   res->category.array_data.dynamic_size = dynamic_size;
530
531   return res;
532 }
533
534 /** \brief Declare a new type being an array which size can be found with \ref gras_cbps_i_pop 
535  * 
536  * Most of the time, you want to include a reference in your structure which
537  * is a pointer to a dynamic array whose size is fixed by another field of 
538  * your structure.
539  *
540  * This case pops up so often that this function was created to take care of
541  * this case. It creates a dynamic array type whose size is poped from the 
542  * current cbps, and then create a reference to it.
543  *
544  * The name of the created datatype will be the name of the element type, with
545  * '[]*' appended to it.
546  *
547  * Then to use it, you just have to make sure that your structure pre-callback
548  * does push the size of the array in the cbps (using #gras_cbps_i_push), and 
549  * you are set. 
550  *
551  * But be remember that this is a stack. If you have two different pop_arr, you
552  * should push the second one first, so that the first one is on the top of the 
553  * list when the first field gets transfered.
554  *
555  */
556 gras_datadesc_type_t 
557   gras_datadesc_ref_pop_arr(gras_datadesc_type_t element_type) {
558
559   gras_datadesc_type_t res;
560   char *name=(char*)xbt_malloc(strlen(element_type->name) + 4);
561
562   sprintf(name,"%s[]",element_type->name);
563
564   res = gras_datadesc_array_dyn(name,element_type,
565                                 gras_datadesc_cb_pop);
566
567   sprintf(name,"%s[]*",element_type->name);
568   res = gras_datadesc_ref(name,res);
569
570   free(name);
571
572   return res;
573 }
574
575 #include "xbt/dynar_private.h"
576 static void gras_datadesc_dynar_cb(gras_datadesc_type_t typedesc, gras_cbps_t vars, void *data) {
577   gras_datadesc_type_t subtype;
578   xbt_dynar_t dynar=(xbt_dynar_t)data;
579    
580   memcpy(&dynar->free_f, &typedesc->extra, sizeof(dynar->free_f));
581
582   /* search for the elemsize in what we have. If elements are "int", typedesc got is "int[]*" */
583   subtype = gras_dd_find_field(typedesc,"data")->type;
584   
585   /* this is now a ref to array of what we're looking for */
586   subtype = subtype->category.ref_data.type;
587   subtype = subtype->category.array_data.type;
588    
589   DEBUG1("subtype is %s",subtype->name);
590
591   dynar->elmsize = subtype->size[GRAS_THISARCH];
592   dynar->size = dynar->used;
593 }
594
595 gras_datadesc_type_t
596 gras_datadesc_dynar(gras_datadesc_type_t elm_t,
597                     void_f_pvoid_t *free_func) {
598    
599   char *buffname;
600   gras_datadesc_type_t res;
601   
602   buffname=xbt_new0(char, strlen(elm_t->name)+10);
603   sprintf(buffname,"dynar(%s)_s",elm_t->name);
604    
605   res = gras_datadesc_struct(buffname);
606   
607   gras_datadesc_struct_append(res, "size",    gras_datadesc_by_name("unsigned long int"));
608    
609   gras_datadesc_struct_append(res, "used",    gras_datadesc_by_name("unsigned long int"));
610   gras_datadesc_cb_field_push(res, "used");
611    
612   gras_datadesc_struct_append(res, "elmsize", gras_datadesc_by_name("unsigned long int"));
613    
614   gras_datadesc_struct_append(res, "data",    gras_datadesc_ref_pop_arr (elm_t));
615
616   gras_datadesc_struct_append(res, "free_f",  gras_datadesc_by_name("function pointer"));
617   memcpy(res->extra,&free_func,sizeof(free_func));
618       
619   gras_datadesc_struct_close(res);
620    
621   gras_datadesc_cb_recv(res,  &gras_datadesc_dynar_cb);
622
623   /* build a ref to it */
624   sprintf(buffname,"dynar(%s)",elm_t->name);
625   res=gras_datadesc_ref(buffname,res);
626   free(buffname);
627   return res;
628 }
629
630
631 gras_datadesc_type_t
632 gras_datadesc_import_nws(const char           *name,
633                          const DataDescriptor *desc,
634                          unsigned long         howmany) {
635   THROW_UNIMPLEMENTED;
636 }
637
638 /**
639  * (useful to push the sizes of the upcoming arrays, for example)
640  */
641 void gras_datadesc_cb_send (gras_datadesc_type_t          type,
642                             gras_datadesc_type_cb_void_t  send) {
643   type->send = send;
644 }
645 /**
646  * (useful to put the function pointers to the rigth value, for example)
647  */
648 void gras_datadesc_cb_recv(gras_datadesc_type_t          type,
649                            gras_datadesc_type_cb_void_t  recv) {
650   type->recv = recv;
651 }
652 /*
653  * gras_dd_find_field:
654  * 
655  * Returns the type descriptor of the given field. Abort on error.
656  */
657 static gras_dd_cat_field_t
658   gras_dd_find_field(gras_datadesc_type_t  type,
659                      const char           *field_name) {
660    xbt_dynar_t         field_array;
661    
662    gras_dd_cat_field_t  field=NULL;
663    int                  field_num;
664    
665    if (type->category_code == e_gras_datadesc_type_cat_union) {
666       field_array = type->category.union_data.fields;
667    } else if (type->category_code == e_gras_datadesc_type_cat_struct) {
668       field_array = type->category.struct_data.fields;
669    } else {
670       ERROR2("%s (%p) is not a struct nor an union. There is no field.", type->name,(void*)type);
671       xbt_abort();
672    }
673    xbt_dynar_foreach(field_array,field_num,field) {
674       if (!strcmp(field_name,field->name)) {
675          return field;
676       }
677    }
678    ERROR2("No field nammed %s in %s",field_name,type->name);
679    xbt_abort();
680
681 }
682                                   
683 /**
684  * The given datadesc must be a struct or union (abort if not).
685  * (useful to push the sizes of the upcoming arrays, for example)
686  */
687 void gras_datadesc_cb_field_send (gras_datadesc_type_t          type,
688                                   const char                   *field_name,
689                                   gras_datadesc_type_cb_void_t  send) {
690    
691    gras_dd_cat_field_t field=gras_dd_find_field(type,field_name);   
692    field->send = send;
693 }
694
695
696 /**
697  * The value, which must be an int, unsigned int, long int or unsigned long int
698  * is pushed to the stacks of sizes and can then be retrieved with 
699  * \ref gras_datadesc_ref_pop_arr or directly with \ref gras_cbps_i_pop.
700  */
701 void gras_datadesc_cb_field_push (gras_datadesc_type_t  type,
702                                   const char           *field_name) {
703    
704    gras_dd_cat_field_t  field=gras_dd_find_field(type,field_name);
705    gras_datadesc_type_t sub_type=field->type;
706    
707    DEBUG3("add a PUSHy cb to '%s' field (type '%s') of '%s'",
708           field_name,sub_type->name,type->name);
709    if (!strcmp("int",sub_type->name)) {
710       field->send = gras_datadesc_cb_push_int;
711    } else if (!strcmp("unsigned int",sub_type->name)) {
712       field->send = gras_datadesc_cb_push_uint;
713    } else if (!strcmp("long int",sub_type->name)) {
714       field->send = gras_datadesc_cb_push_lint;
715    } else if (!strcmp("unsigned long int",sub_type->name)) {
716       field->send = gras_datadesc_cb_push_ulint;
717    } else {
718       ERROR1("Field %s is not an int, unsigned int, long int neither unsigned long int",
719              sub_type->name);
720       xbt_abort();
721    }
722 }
723
724 /**
725  * Any previously pushed value is poped and the field value is multiplied to
726  * it. The result is then pushed back into the stack of sizes. It can then be
727  * retrieved with \ref gras_datadesc_ref_pop_arr or directly with \ref
728  * gras_cbps_i_pop.
729  *
730  * The field must be an int, unsigned int, long int or unsigned long int.
731  */
732 void gras_datadesc_cb_field_push_multiplier (gras_datadesc_type_t  type,
733                                              const char         *field_name) {
734    
735    gras_dd_cat_field_t  field=gras_dd_find_field(type,field_name);
736    gras_datadesc_type_t sub_type=field->type;
737    
738    DEBUG3("add a MPUSHy cb to '%s' field (type '%s') of '%s'",
739           field_name,sub_type->name,type->name);
740    if (!strcmp("int",sub_type->name)) {
741       field->send = gras_datadesc_cb_push_int_mult;
742    } else if (!strcmp("unsigned int",sub_type->name)) {
743       field->send = gras_datadesc_cb_push_uint_mult;
744    } else if (!strcmp("long int",sub_type->name)) {
745       field->send = gras_datadesc_cb_push_lint_mult;
746    } else if (!strcmp("unsigned long int",sub_type->name)) {
747       field->send = gras_datadesc_cb_push_ulint_mult;
748    } else {
749       ERROR1("Field %s is not an int, unsigned int, long int neither unsigned long int",
750              sub_type->name);
751       xbt_abort();
752    }
753 }
754
755 /**
756  * The given datadesc must be a struct or union (abort if not).
757  * (useful to put the function pointers to the right value, for example)
758  */
759 void gras_datadesc_cb_field_recv(gras_datadesc_type_t          type,
760                                  const char                   *field_name,
761                                  gras_datadesc_type_cb_void_t  recv) {
762    
763    gras_dd_cat_field_t field=gras_dd_find_field(type,field_name);   
764    field->recv = recv;
765 }
766
767 /*
768  * Free a datadesc. Should only be called at xbt_exit. 
769  */
770 void gras_datadesc_free(gras_datadesc_type_t *type) {
771
772   DEBUG1("Let's free ddt %s",(*type)->name);
773   
774   switch ((*type)->category_code) {
775   case e_gras_datadesc_type_cat_scalar:
776   case e_gras_datadesc_type_cat_ref:
777   case e_gras_datadesc_type_cat_array:
778     /* nothing to free in there */
779     break;
780     
781   case e_gras_datadesc_type_cat_struct:
782     xbt_dynar_free(&( (*type)->category.struct_data.fields ));
783     break;
784     
785   case e_gras_datadesc_type_cat_union:
786     xbt_dynar_free(&( (*type)->category.union_data.fields ));
787     break;
788     
789   default:
790     /* datadesc was invalid. Killing it is like euthanasy, I guess */
791     break;
792   }
793   free((*type)->name);
794   free(*type);
795   type=NULL;
796 }
797
798 /**
799  * gras_datadesc_type_cmp:
800  *
801  * Compares two datadesc types with the same semantic than strcmp.
802  *
803  * This comparison does not take the set headers into account (name and ID), 
804  * but only the payload (actual type description).
805  */
806 int gras_datadesc_type_cmp(const gras_datadesc_type_t d1,
807                            const gras_datadesc_type_t d2) {
808   int ret,cpt;
809   gras_dd_cat_field_t field1,field2;
810   gras_datadesc_type_t field_desc_1,field_desc_2;
811
812   if (d1 == d2) return 0; /* easy optimization */
813
814   if (!d1 && d2) {
815     DEBUG0("ddt_cmp: !d1 && d2 => 1");
816     return 1;
817   }
818   if (!d1 && !d2) {
819     DEBUG0("ddt_cmp: !d1 && !d2 => 0");
820     return 0;
821   }
822   if ( d1 && !d2) {
823     DEBUG0("ddt_cmp: d1 && !d2 => -1");
824     return -1;
825   }
826
827   for (cpt=0; cpt<gras_arch_count; cpt++) {
828     if (d1->size[cpt] != d2->size[cpt]) {
829       DEBUG5("ddt_cmp: %s->size=%ld  !=  %s->size=%ld (on %s)",
830              d1->name,d1->size[cpt],d2->name,d2->size[cpt],
831              gras_arches[cpt].name);
832       return d1->size[cpt] >  d2->size[cpt] ? 1 : -1;
833     }
834
835     if (d1->alignment[cpt] != d2->alignment[cpt]) {
836       DEBUG5("ddt_cmp: %s->alignment=%ld  !=  %s->alignment=%ld (on %s)",
837              d1->name,d1->alignment[cpt],d2->name,d2->alignment[cpt],
838              gras_arches[cpt].name);
839       return d1->alignment[cpt] > d2->alignment[cpt] ? 1 : -1;
840     }
841
842     if (d1->aligned_size[cpt] != d2->aligned_size[cpt]) {
843       DEBUG5("ddt_cmp: %s->aligned_size=%ld  !=  %s->aligned_size=%ld (on %s)",
844              d1->name,d1->aligned_size[cpt],d2->name,d2->aligned_size[cpt],
845              gras_arches[cpt].name);
846       return d1->aligned_size[cpt] > d2->aligned_size[cpt] ? 1 : -1;
847     }
848   }
849
850   if (d1->category_code != d2->category_code) {
851     DEBUG4("ddt_cmp: %s->cat=%s  !=  %s->cat=%s",
852            d1->name,gras_datadesc_cat_names[d1->category_code],
853            d2->name,gras_datadesc_cat_names[d2->category_code]);
854     return d1->category_code > d2->category_code ? 1 : -1;
855   }
856
857   if (d1->send != d2->send) {
858     DEBUG4("ddt_cmp: %s->send=%p  !=  %s->send=%p",
859            d1->name,(void*)d1->send, d2->name,(void*)d2->send);
860     return 1; /* ISO C forbids ordered comparisons of pointers to functions */
861   }
862
863   if (d1->recv != d2->recv) {
864     DEBUG4("ddt_cmp: %s->recv=%p  !=  %s->recv=%p",
865            d1->name,(void*)d1->recv, d2->name,(void*)d2->recv);
866     return 1; /* ISO C forbids ordered comparisons of pointers to functions */
867   }
868
869   switch (d1->category_code) {
870   case e_gras_datadesc_type_cat_scalar:
871     if (d1->category.scalar_data.encoding != d2->category.scalar_data.encoding)
872       return d1->category.scalar_data.encoding > d2->category.scalar_data.encoding ? 1 : -1 ;
873     break;
874     
875   case e_gras_datadesc_type_cat_struct:    
876     if (xbt_dynar_length(d1->category.struct_data.fields) != 
877         xbt_dynar_length(d2->category.struct_data.fields)) {
878       DEBUG4("ddt_cmp: %s (having %lu fields) !=  %s (having %lu fields)",
879              d1->name, xbt_dynar_length(d1->category.struct_data.fields),
880              d2->name, xbt_dynar_length(d2->category.struct_data.fields));
881       
882       return xbt_dynar_length(d1->category.struct_data.fields) >
883         xbt_dynar_length(d2->category.struct_data.fields) ?
884         1 : -1;
885     }
886     xbt_dynar_foreach(d1->category.struct_data.fields, cpt, field1) {
887       
888       field2 = xbt_dynar_get_as(d2->category.struct_data.fields, cpt, gras_dd_cat_field_t);
889       field_desc_1 = field1->type;
890       field_desc_2 = field2->type;
891       ret = gras_datadesc_type_cmp(field_desc_1,field_desc_2);
892       if (ret) {
893         DEBUG6("%s->field[%d]=%s != %s->field[%d]=%s",
894                d1->name,cpt,field1->name,              
895                d2->name,cpt,field2->name);
896         return ret;
897       }
898       
899     }
900     break;
901     
902   case e_gras_datadesc_type_cat_union:
903     if (d1->category.union_data.selector != d2->category.union_data.selector) 
904       return 1;  /* ISO C forbids ordered comparisons of pointers to functions */
905     
906     if (xbt_dynar_length(d1->category.union_data.fields) != 
907         xbt_dynar_length(d2->category.union_data.fields))
908       return xbt_dynar_length(d1->category.union_data.fields) >
909              xbt_dynar_length(d2->category.union_data.fields) ?
910         1 : -1;
911     
912     xbt_dynar_foreach(d1->category.union_data.fields, cpt, field1) {
913       
914       field2 = xbt_dynar_get_as(d2->category.union_data.fields, cpt, gras_dd_cat_field_t);
915       field_desc_1 = field1->type;
916       field_desc_2 = field2->type;
917       ret = gras_datadesc_type_cmp(field_desc_1,field_desc_2);
918       if (ret)
919         return ret;
920       
921     }
922     break;
923     
924     
925   case e_gras_datadesc_type_cat_ref:
926     if (d1->category.ref_data.selector != d2->category.ref_data.selector) 
927       return 1; /* ISO C forbids ordered comparisons of pointers to functions */
928     
929     if (d1->category.ref_data.type != d2->category.ref_data.type) 
930       return d1->category.ref_data.type > d2->category.ref_data.type ? 1 : -1;
931     break;
932     
933   case e_gras_datadesc_type_cat_array:
934     if (d1->category.array_data.type != d2->category.array_data.type) 
935       return d1->category.array_data.type > d2->category.array_data.type ? 1 : -1;
936     
937     if (d1->category.array_data.fixed_size != d2->category.array_data.fixed_size) 
938       return d1->category.array_data.fixed_size > d2->category.array_data.fixed_size ? 1 : -1;
939     
940     if (d1->category.array_data.dynamic_size != d2->category.array_data.dynamic_size) 
941       return 1; /* ISO C forbids ordered comparisons of pointers to functions */
942     
943     break;
944     
945   default:
946     /* two stupidly created ddt are equally stupid ;) */
947     break;
948   }
949   return 0;
950   
951 }