Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Do declare variables at the begining of the block, not in the middle, to make old...
[simgrid.git] / src / gras / DataDesc / ddt_exchange.c
1 /* $Id$ */
2
3 /* ddt_exchange - send/recv data described                                  */
4
5 /* Authors: Olivier Aumage, Martin Quinson                                  */
6 /* Copyright (C) 2003, 2004 the GRAS posse.                                 */
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 "gras/DataDesc/datadesc_private.h"
12 #include "gras/Transport/transport_interface.h" /* gras_trp_chunk_send/recv */
13
14 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(ddt_exchange,datadesc,
15                                  "Sending data over the network");
16 const char *gras_datadesc_cat_names[9] = { 
17   "undefined", 
18   "scalar", "struct", "union", "ref", "array", "ignored",
19   "invalid"};
20
21 static gras_datadesc_type_t int_type = NULL;
22 static gras_datadesc_type_t pointer_type = NULL;    
23 static _XBT_INLINE xbt_error_t gras_dd_send_int(gras_socket_t sock,             int  i);
24 static _XBT_INLINE xbt_error_t gras_dd_recv_int(gras_socket_t sock, int r_arch, int *i);
25
26 static _XBT_INLINE xbt_error_t
27 gras_dd_alloc_ref(xbt_dict_t  refs,  long int     size,
28                   char       **r_ref, long int     r_len,
29                   char       **l_ref, int detect_cycle);
30
31 static _XBT_INLINE int
32 gras_dd_is_r_null(char **r_ptr, long int length);
33
34 static xbt_error_t 
35 gras_datadesc_send_rec(gras_socket_t         sock,
36                        gras_cbps_t           state,
37                        xbt_dict_t           refs,
38                        gras_datadesc_type_t  type, 
39                        char                 *data, 
40                        int                   detect_cycle);
41 static xbt_error_t
42 gras_datadesc_recv_rec(gras_socket_t         sock, 
43                        gras_cbps_t           state,
44                        xbt_dict_t           refs,
45                        gras_datadesc_type_t  type,
46                        int                   r_arch,
47                        char                **r_data,
48                        long int              r_lgr,
49                        char                 *dst,
50                        int                   subsize, 
51                        int                   detect_cycle);
52
53
54 static _XBT_INLINE xbt_error_t
55 gras_dd_send_int(gras_socket_t sock,int i) {
56
57   if (!int_type) {
58     int_type = gras_datadesc_by_name("int");
59      xbt_assert(int_type);  
60   }
61    
62   DEBUG1("send_int(%d)",i);
63   return gras_trp_chunk_send(sock, (char*)&i, int_type->size[GRAS_THISARCH]);
64 }
65
66 static _XBT_INLINE xbt_error_t
67 gras_dd_recv_int(gras_socket_t sock, int r_arch, int *i) {
68   xbt_error_t errcode;
69
70   if (!int_type) {
71      int_type = gras_datadesc_by_name("int");
72      xbt_assert(int_type);
73   }
74
75   if (int_type->size[GRAS_THISARCH] >= int_type->size[r_arch]) {
76     TRY(gras_trp_chunk_recv(sock, (char*)i, int_type->size[r_arch]));
77     if (r_arch != GRAS_THISARCH)
78       TRY(gras_dd_convert_elm(int_type,1,r_arch, i,i));
79   } else {
80     void *ptr = xbt_malloc(int_type->size[r_arch]);
81
82     TRY(gras_trp_chunk_recv(sock, (char*)ptr, int_type->size[r_arch]));
83     if (r_arch != GRAS_THISARCH)
84       TRY(gras_dd_convert_elm(int_type,1,r_arch, ptr,i));
85     xbt_free(ptr);
86   }
87   DEBUG1("recv_int(%d)",*i);
88
89   return no_error;
90 }
91
92 /*
93  * Note: here we suppose that the remote NULL is a sequence 
94  *       of 'length' bytes set to 0.
95  * FIXME: Check in configure?
96  */
97 static _XBT_INLINE int 
98 gras_dd_is_r_null(char **r_ptr, long int length) {
99   int i;
100
101   for (i=0; i<length; i++) {
102     if ( ((unsigned char*)r_ptr) [i]) {
103       return 0;
104     }
105   }
106
107   return 1;
108 }
109
110 static _XBT_INLINE xbt_error_t
111 gras_dd_alloc_ref(xbt_dict_t  refs,
112                   long int     size,
113                   char       **r_ref,
114                   long int     r_len, /* pointer_type->size[r_arch] */
115                   char       **l_ref,
116                   int          detect_cycle) {
117   char *l_data = NULL;
118
119   xbt_assert1(size>0,"Cannot allocate %ld bytes!", size);
120   l_data = xbt_malloc((size_t)size);
121
122   *l_ref = l_data;
123   DEBUG2("l_data=%p, &l_data=%p",(void*)l_data,(void*)&l_data);
124
125   DEBUG3("alloc_ref: r_ref=%p; *r_ref=%p, r_len=%ld",
126          (void*)r_ref, (void*)(r_ref?*r_ref:NULL), r_len);
127   if (detect_cycle && r_ref && !gras_dd_is_r_null( r_ref, r_len)) {
128     xbt_error_t errcode;
129     void *ptr = xbt_malloc(sizeof(void *));
130
131     CRITICAL0("detect_cycle");
132     memcpy(ptr,l_ref, sizeof(void *));
133
134     DEBUG2("Insert %p under %p",*(void**)ptr, *(void**)r_ref);
135
136     if (detect_cycle)
137        xbt_dict_set_ext(refs,(const char *) r_ref, r_len, ptr, xbt_free_fct);
138   }
139   return no_error;
140 }
141
142 /**
143  * gras_datadesc_type_cmp:
144  *
145  * Compares two datadesc types with the same semantic than strcmp.
146  *
147  * This comparison does not take the set headers into account (name and ID), 
148  * but only the payload (actual type description).
149  */
150 int gras_datadesc_type_cmp(const gras_datadesc_type_t d1,
151                            const gras_datadesc_type_t d2) {
152   int ret,cpt;
153   gras_dd_cat_field_t field1,field2;
154   gras_datadesc_type_t field_desc_1,field_desc_2;
155
156   if (d1 == d2) return 0; /* easy optimization */
157
158   if (!d1 && d2) {
159     DEBUG0("ddt_cmp: !d1 && d2 => 1");
160     return 1;
161   }
162   if (!d1 && !d2) {
163     DEBUG0("ddt_cmp: !d1 && !d2 => 0");
164     return 0;
165   }
166   if ( d1 && !d2) {
167     DEBUG0("ddt_cmp: d1 && !d2 => -1");
168     return -1;
169   }
170
171   for (cpt=0; cpt<gras_arch_count; cpt++) {
172     if (d1->size[cpt] != d2->size[cpt]) {
173       DEBUG5("ddt_cmp: %s->size=%ld  !=  %s->size=%ld (on %s)",
174              d1->name,d1->size[cpt],d2->name,d2->size[cpt],
175              gras_arches[cpt].name);
176       return d1->size[cpt] >  d2->size[cpt] ? 1 : -1;
177     }
178
179     if (d1->alignment[cpt] != d2->alignment[cpt]) {
180       DEBUG5("ddt_cmp: %s->alignment=%ld  !=  %s->alignment=%ld (on %s)",
181              d1->name,d1->alignment[cpt],d2->name,d2->alignment[cpt],
182              gras_arches[cpt].name);
183       return d1->alignment[cpt] > d2->alignment[cpt] ? 1 : -1;
184     }
185
186     if (d1->aligned_size[cpt] != d2->aligned_size[cpt]) {
187       DEBUG5("ddt_cmp: %s->aligned_size=%ld  !=  %s->aligned_size=%ld (on %s)",
188              d1->name,d1->aligned_size[cpt],d2->name,d2->aligned_size[cpt],
189              gras_arches[cpt].name);
190       return d1->aligned_size[cpt] > d2->aligned_size[cpt] ? 1 : -1;
191     }
192   }
193
194   if (d1->category_code != d2->category_code) {
195     DEBUG4("ddt_cmp: %s->cat=%s  !=  %s->cat=%s",
196            d1->name,gras_datadesc_cat_names[d1->category_code],
197            d2->name,gras_datadesc_cat_names[d2->category_code]);
198     return d1->category_code > d2->category_code ? 1 : -1;
199   }
200
201   if (d1->send != d2->send) {
202     DEBUG4("ddt_cmp: %s->send=%p  !=  %s->send=%p",
203            d1->name,(void*)d1->send, d2->name,(void*)d2->send);
204     return 1; /* ISO C forbids ordered comparisons of pointers to functions */
205   }
206
207   if (d1->recv != d2->recv) {
208     DEBUG4("ddt_cmp: %s->recv=%p  !=  %s->recv=%p",
209            d1->name,(void*)d1->recv, d2->name,(void*)d2->recv);
210     return 1; /* ISO C forbids ordered comparisons of pointers to functions */
211   }
212
213   switch (d1->category_code) {
214   case e_gras_datadesc_type_cat_scalar:
215     if (d1->category.scalar_data.encoding != d2->category.scalar_data.encoding)
216       return d1->category.scalar_data.encoding > d2->category.scalar_data.encoding ? 1 : -1 ;
217     break;
218     
219   case e_gras_datadesc_type_cat_struct:    
220     if (xbt_dynar_length(d1->category.struct_data.fields) != 
221         xbt_dynar_length(d2->category.struct_data.fields)) {
222       DEBUG4("ddt_cmp: %s (having %lu fields) !=  %s (having %lu fields)",
223              d1->name, xbt_dynar_length(d1->category.struct_data.fields),
224              d2->name, xbt_dynar_length(d2->category.struct_data.fields));
225       
226       return xbt_dynar_length(d1->category.struct_data.fields) >
227         xbt_dynar_length(d2->category.struct_data.fields) ?
228         1 : -1;
229     }
230     xbt_dynar_foreach(d1->category.struct_data.fields, cpt, field1) {
231       
232       field2 = xbt_dynar_get_as(d2->category.struct_data.fields, cpt, gras_dd_cat_field_t);
233       field_desc_1 = field1->type;
234       field_desc_2 = field2->type;
235       ret = gras_datadesc_type_cmp(field_desc_1,field_desc_2);
236       if (ret) {
237         DEBUG6("%s->field[%d]=%s != %s->field[%d]=%s",
238                d1->name,cpt,field1->name,              
239                d2->name,cpt,field2->name);
240         return ret;
241       }
242       
243     }
244     break;
245     
246   case e_gras_datadesc_type_cat_union:
247     if (d1->category.union_data.selector != d2->category.union_data.selector) 
248       return 1;  /* ISO C forbids ordered comparisons of pointers to functions */
249     
250     if (xbt_dynar_length(d1->category.union_data.fields) != 
251         xbt_dynar_length(d2->category.union_data.fields))
252       return xbt_dynar_length(d1->category.union_data.fields) >
253              xbt_dynar_length(d2->category.union_data.fields) ?
254         1 : -1;
255     
256     xbt_dynar_foreach(d1->category.union_data.fields, cpt, field1) {
257       
258       field2 = xbt_dynar_get_as(d2->category.union_data.fields, cpt, gras_dd_cat_field_t);
259       field_desc_1 = field1->type;
260       field_desc_2 = field2->type;
261       ret = gras_datadesc_type_cmp(field_desc_1,field_desc_2);
262       if (ret)
263         return ret;
264       
265     }
266     break;
267     
268     
269   case e_gras_datadesc_type_cat_ref:
270     if (d1->category.ref_data.selector != d2->category.ref_data.selector) 
271       return 1; /* ISO C forbids ordered comparisons of pointers to functions */
272     
273     if (d1->category.ref_data.type != d2->category.ref_data.type) 
274       return d1->category.ref_data.type > d2->category.ref_data.type ? 1 : -1;
275     break;
276     
277   case e_gras_datadesc_type_cat_array:
278     if (d1->category.array_data.type != d2->category.array_data.type) 
279       return d1->category.array_data.type > d2->category.array_data.type ? 1 : -1;
280     
281     if (d1->category.array_data.fixed_size != d2->category.array_data.fixed_size) 
282       return d1->category.array_data.fixed_size > d2->category.array_data.fixed_size ? 1 : -1;
283     
284     if (d1->category.array_data.dynamic_size != d2->category.array_data.dynamic_size) 
285       return 1; /* ISO C forbids ordered comparisons of pointers to functions */
286     
287     break;
288     
289   case e_gras_datadesc_type_cat_ignored:
290     /* That's ignored... */
291   default:
292     /* two stupidly created ddt are equally stupid ;) */
293     break;
294   }
295   return 0;
296   
297 }
298
299 /**
300  * gras_datadesc_cpy:
301  *
302  * Copy the data pointed by src and described by type 
303  * to a new location, and store a pointer to it in dst.
304  *
305  */
306 xbt_error_t gras_datadesc_cpy(gras_datadesc_type_t type, 
307                                void *src, 
308                                void **dst) {
309   RAISE_UNIMPLEMENTED;
310 }
311
312 static xbt_error_t 
313 gras_datadesc_send_rec(gras_socket_t         sock,
314                        gras_cbps_t           state,
315                        xbt_dict_t           refs,
316                        gras_datadesc_type_t  type, 
317                        char                 *data,
318                        int                   detect_cycle) {
319
320   xbt_error_t         errcode;
321   int                  cpt;
322   gras_datadesc_type_t sub_type; /* type on which we recurse */
323   
324   VERB2("Send a %s (%s)", 
325         type->name, gras_datadesc_cat_names[type->category_code]);
326
327   if (type->send) {
328     type->send(state,data);
329   }
330
331   switch (type->category_code) {
332   case e_gras_datadesc_type_cat_scalar:
333     TRY(gras_trp_chunk_send(sock, data, type->size[GRAS_THISARCH]));
334     break;
335
336   case e_gras_datadesc_type_cat_struct: {
337     gras_dd_cat_struct_t struct_data;
338     gras_dd_cat_field_t  field;
339     char                *field_data;
340     
341     struct_data = type->category.struct_data;
342     xbt_assert1(struct_data.closed,
343       "Please call gras_datadesc_declare_struct_close on %s before sending it",
344                 type->name);
345     VERB1(">> Send all fields of the structure %s",type->name);
346     xbt_dynar_foreach(struct_data.fields, cpt, field) {
347       field_data = data;
348       field_data += field->offset[GRAS_THISARCH];
349       
350       sub_type = field->type;
351       
352       if (field->pre)
353         field->pre(state,field_data);
354       
355       VERB1("Send field %s",field->name);
356       TRY(gras_datadesc_send_rec(sock,state,refs,sub_type, field_data, detect_cycle || sub_type->cycle));
357       
358       if (field->post)
359         field->post(state,field_data);
360     }
361     VERB1("<< Sent all fields of the structure %s", type->name);
362     
363     break;
364   }
365
366   case e_gras_datadesc_type_cat_union: {
367     gras_dd_cat_union_t union_data;
368     gras_dd_cat_field_t field=NULL;
369     int                 field_num;
370     
371     union_data = type->category.union_data;
372     
373     xbt_assert1(union_data.closed,
374                 "Please call gras_datadesc_declare_union_close on %s before sending it",
375                 type->name);
376     /* retrieve the field number */
377     field_num = union_data.selector(state, data);
378     
379     xbt_assert1(field_num > 0,
380                  "union field selector of %s gave a negative value", 
381                  type->name);
382     
383     xbt_assert3(field_num < xbt_dynar_length(union_data.fields),
384          "union field selector of %s returned %d but there is only %lu fields",
385                  type->name, field_num, xbt_dynar_length(union_data.fields));
386
387     /* Send the field number */
388     TRY(gras_dd_send_int(sock, field_num));
389     
390     /* Send the content */
391     field = xbt_dynar_get_as(union_data.fields, field_num, gras_dd_cat_field_t);
392     sub_type = field->type;
393     
394     if (field->pre)
395       field->pre(state,data);
396     
397     TRY(gras_datadesc_send_rec(sock,state,refs, sub_type, data, detect_cycle || sub_type->cycle));
398       
399     if (field->post)
400       field->post(state,data);
401     
402     break;
403   }
404     
405   case e_gras_datadesc_type_cat_ref: {
406     gras_dd_cat_ref_t      ref_data;
407
408     void                 **ref=(void**)data;
409     void *dummy;
410     
411     ref_data = type->category.ref_data;
412     
413     /* Detect the referenced type and send it to peer if needed */
414     sub_type = ref_data.type;
415     if (sub_type == NULL) {
416       sub_type = (*ref_data.selector)(state,data);
417       TRY(gras_dd_send_int(sock, sub_type->code));
418     }
419     
420     /* Send the actual value of the pointer for cycle handling */
421     if (!pointer_type) {
422       pointer_type = gras_datadesc_by_name("data pointer");
423       xbt_assert(pointer_type);
424     }
425      
426     TRY(gras_trp_chunk_send(sock, (char*)data,
427                             pointer_type->size[GRAS_THISARCH]));
428     
429     /* Send the pointed data only if not already sent */
430     if (*(void**)data == NULL) {
431       VERB0("Not sending NULL referenced data");
432       break;
433     }
434     errcode = detect_cycle 
435             ? xbt_dict_get_ext(refs,(char*)ref, sizeof(void*), &dummy)
436             : mismatch_error;
437     if (errcode == mismatch_error) {
438        VERB1("Sending data referenced at %p", (void*)*ref);
439        if (detect_cycle)
440          xbt_dict_set_ext(refs, (char*)ref, sizeof(void*), ref, NULL);
441        TRY(gras_datadesc_send_rec(sock,state,refs, sub_type, *ref, detect_cycle || sub_type->cycle));
442           
443     } else if (errcode == no_error) {
444        VERB1("Not sending data referenced at %p (already done)", (void*)*ref);
445     } else {
446        return errcode;
447     }
448     
449     break;
450   }
451
452   case e_gras_datadesc_type_cat_array: {
453     gras_dd_cat_array_t    array_data;
454     long int               count;
455     char                  *ptr=data;
456     long int               elm_size;
457     
458     array_data = type->category.array_data;
459     
460     /* determine and send the element count */
461     count = array_data.fixed_size;
462     if (count == 0) {
463       count = array_data.dynamic_size(state,data);
464       xbt_assert1(count >=0,
465                    "Invalid (negative) array size for type %s",type->name);
466       TRY(gras_dd_send_int(sock, count));
467     }
468     
469     /* send the content */
470     sub_type = array_data.type;
471     elm_size = sub_type->aligned_size[GRAS_THISARCH];
472     if (sub_type->category_code == e_gras_datadesc_type_cat_scalar) {
473       VERB1("Array of %ld scalars, send it in one shot",count);
474       TRY(gras_trp_chunk_send(sock, data, 
475                               sub_type->aligned_size[GRAS_THISARCH] * count));
476     } else if (sub_type->category_code == e_gras_datadesc_type_cat_array &&
477                sub_type->category.array_data.fixed_size > 0 &&
478                sub_type->category.array_data.type->category_code == e_gras_datadesc_type_cat_scalar) {
479        
480       VERB1("Array of %ld fixed array of scalars, send it in one shot",count);
481       TRY(gras_trp_chunk_send(sock, data, 
482                               sub_type->category.array_data.type->aligned_size[GRAS_THISARCH] 
483                                  * count * sub_type->category.array_data.fixed_size));
484        
485     } else {
486       for (cpt=0; cpt<count; cpt++) {
487         TRY(gras_datadesc_send_rec(sock,state,refs, sub_type, ptr, detect_cycle || sub_type->cycle));
488         ptr += elm_size;
489       }
490     }
491     break;
492   }
493
494   default:
495     xbt_assert0(0, "Invalid type");
496   }
497
498   return no_error;
499 }
500
501 /**
502  * gras_datadesc_send:
503  *
504  * Copy the data pointed by src and described by type to the socket
505  *
506  */
507 xbt_error_t gras_datadesc_send(gras_socket_t        sock, 
508                                 gras_datadesc_type_t type, 
509                                 void *src) {
510
511   xbt_error_t errcode;
512   gras_cbps_t  state;
513   xbt_dict_t  refs; /* all references already sent */
514  
515   refs = xbt_dict_new();
516   state = gras_cbps_new();
517    
518   errcode = gras_datadesc_send_rec(sock,state,refs,type,(char*)src, type->cycle);
519
520   xbt_dict_free(&refs);
521   gras_cbps_free(&state);
522
523   return errcode;
524 }
525
526 /**
527  * gras_datadesc_recv_rec:
528  *
529  * Do the data reception job recursively.
530  *
531  * subsize used only to deal with vicious case of reference to dynamic array.
532  *  This size is needed at the reference reception level (to allocate enough 
533  * space) and at the array reception level (to fill enough room). 
534  * 
535  * Having this size passed as an argument of the recursive function is a crude
536  * hack, but I was told that working code is sometimes better than neat one ;)
537  */
538 xbt_error_t
539 gras_datadesc_recv_rec(gras_socket_t         sock, 
540                        gras_cbps_t           state,
541                        xbt_dict_t           refs,
542                        gras_datadesc_type_t  type,
543                        int                   r_arch,
544                        char                **r_data,
545                        long int              r_lgr,
546                        char                 *l_data,
547                        int                   subsize,
548                        int                   detect_cycle) {
549
550   xbt_error_t         errcode;
551   int                  cpt;
552   gras_datadesc_type_t sub_type;
553
554   VERB2("Recv a %s @%p", type->name, (void*)l_data);
555   xbt_assert(l_data);
556
557   switch (type->category_code) {
558   case e_gras_datadesc_type_cat_scalar:
559     if (type->size[GRAS_THISARCH] == type->size[r_arch]) {
560       TRY(gras_trp_chunk_recv(sock, (char*)l_data, type->size[r_arch]));
561       if (r_arch != GRAS_THISARCH)
562         TRY(gras_dd_convert_elm(type,1,r_arch, l_data,l_data));
563     } else {
564       void *ptr = xbt_malloc(type->size[r_arch]);
565
566       TRY(gras_trp_chunk_recv(sock, (char*)ptr, type->size[r_arch]));
567       if (r_arch != GRAS_THISARCH)
568         TRY(gras_dd_convert_elm(type,1,r_arch, ptr,l_data));
569       xbt_free(ptr);
570     }
571     break;
572
573   case e_gras_datadesc_type_cat_struct: {
574     gras_dd_cat_struct_t struct_data;
575     gras_dd_cat_field_t  field;
576
577     struct_data = type->category.struct_data;
578
579     xbt_assert1(struct_data.closed,
580                 "Please call gras_datadesc_declare_struct_close on %s before receiving it",
581                 type->name);
582     VERB1(">> Receive all fields of the structure %s",type->name);
583     xbt_dynar_foreach(struct_data.fields, cpt, field) {
584       char                 *field_data = l_data + field->offset[GRAS_THISARCH];
585
586       sub_type = field->type;
587
588       TRY(gras_datadesc_recv_rec(sock,state,refs, sub_type,
589                                  r_arch,NULL,0,
590                                  field_data,-1, 
591                                  detect_cycle || sub_type->cycle));
592     }
593     VERB1("<< Received all fields of the structure %s", type->name);
594     
595     break;
596   }
597
598   case e_gras_datadesc_type_cat_union: {
599     gras_dd_cat_union_t union_data;
600     gras_dd_cat_field_t field=NULL;
601     int                 field_num;
602
603     union_data = type->category.union_data;
604
605     xbt_assert1(union_data.closed,
606                 "Please call gras_datadesc_declare_union_close on %s before receiving it",
607                 type->name);
608     /* retrieve the field number */
609     TRY(gras_dd_recv_int(sock, r_arch, &field_num));
610     if (field_num < 0)
611       RAISE1(mismatch_error,
612              "Received union field for %s is negative", type->name);
613     if (field_num < xbt_dynar_length(union_data.fields)) 
614       RAISE3(mismatch_error,
615              "Received union field for %s is %d but there is only %lu fields",
616              type->name, field_num, xbt_dynar_length(union_data.fields));
617     
618     /* Recv the content */
619     field = xbt_dynar_get_as(union_data.fields, field_num, gras_dd_cat_field_t);
620     sub_type = field->type;
621     
622     TRY(gras_datadesc_recv_rec(sock,state,refs, sub_type,
623                                r_arch,NULL,0,
624                                l_data,-1, 
625                                detect_cycle || sub_type->cycle));
626     break;
627   }
628
629   case e_gras_datadesc_type_cat_ref: {
630     char             **r_ref = NULL;
631     char             **l_ref = NULL;
632     gras_dd_cat_ref_t  ref_data;
633     
634     ref_data = type->category.ref_data;
635
636     /* Get the referenced type locally or from peer */
637     sub_type = ref_data.type;
638     if (sub_type == NULL) {
639       int ref_code;
640       TRY(gras_dd_recv_int(sock, r_arch, &ref_code));
641       TRY(gras_datadesc_by_id(ref_code, &sub_type));
642     }
643
644     /* Get the actual value of the pointer for cycle handling */
645     if (!pointer_type) {
646       pointer_type = gras_datadesc_by_name("data pointer");
647       xbt_assert(pointer_type);
648     }
649
650     r_ref = xbt_malloc(pointer_type->size[r_arch]);
651
652     TRY(gras_trp_chunk_recv(sock, (char*)r_ref,
653                             pointer_type->size[r_arch]));
654
655     /* Receive the pointed data only if not already sent */
656     if (gras_dd_is_r_null(r_ref, pointer_type->size[r_arch])) {
657       VERB1("Not receiving data remotely referenced @%p since it's NULL",
658             *(void **)r_ref);
659       *(void**)l_data = NULL;
660       xbt_free(r_ref);
661       break;
662     }
663          
664     errcode = detect_cycle
665             ? xbt_dict_get_ext(refs,
666                                 (char*)r_ref, pointer_type->size[r_arch],
667                                 (void**)&l_ref)
668             : mismatch_error;
669
670     if (errcode == mismatch_error) {
671       int subsubcount = 0;
672       void *l_referenced=NULL;
673
674       VERB2("Receiving a ref to '%s', remotely @%p",
675             sub_type->name, *(void**)r_ref);
676       if (sub_type->category_code == e_gras_datadesc_type_cat_array) {
677         /* Damn. Reference to a dynamic array. Allocating the size for it 
678            is more complicated */
679         gras_dd_cat_array_t array_data = sub_type->category.array_data;
680         gras_datadesc_type_t subsub_type;
681
682         subsubcount = array_data.fixed_size;
683         if (subsubcount == 0)
684           TRY(gras_dd_recv_int(sock, r_arch, &subsubcount));
685
686         subsub_type = array_data.type;
687
688
689         TRY(gras_dd_alloc_ref(refs,
690                               subsub_type->size[GRAS_THISARCH] * subsubcount, 
691                               r_ref,pointer_type->size[r_arch], 
692                               (char**)&l_referenced,
693                               detect_cycle));
694       } else {
695         TRY(gras_dd_alloc_ref(refs,sub_type->size[GRAS_THISARCH], 
696                               r_ref,pointer_type->size[r_arch], 
697                               (char**)&l_referenced,
698                               detect_cycle));
699       }
700
701       TRY(gras_datadesc_recv_rec(sock,state,refs, sub_type,
702                                  r_arch,r_ref,pointer_type->size[r_arch],
703                                  (char*)l_referenced, subsubcount, 
704                                  detect_cycle || sub_type->cycle));
705       *(void**)l_data=l_referenced;
706       VERB3("'%s' remotely referenced at %p locally at %p",
707             sub_type->name, *(void**)r_ref, l_referenced);
708       
709     } else if (errcode == no_error) {
710       VERB2("NOT receiving data remotely referenced @%p (already done, @%p here)",
711             *(void**)r_ref, *(void**)l_ref);
712
713       *(void**)l_data=*l_ref;
714
715     } else {
716       return errcode;
717     }
718     xbt_free(r_ref);
719     break;
720   }
721
722   case e_gras_datadesc_type_cat_array: {
723     gras_dd_cat_array_t    array_data;
724     int       count;
725     char     *ptr;
726     long int  elm_size;
727
728     array_data = type->category.array_data;
729     /* determine element count locally, or from caller, or from peer */
730     count = array_data.fixed_size;
731     if (count == 0)
732       count = subsize;
733     if (count == 0)
734       TRY(gras_dd_recv_int(sock, r_arch, &count));
735     if (count == 0)
736       RAISE1(mismatch_error,
737              "Invalid (=0) array size for type %s",type->name);
738
739     /* receive the content */
740     sub_type = array_data.type;
741     if (sub_type->category_code == e_gras_datadesc_type_cat_scalar) {
742       VERB1("Array of %d scalars, get it in one shoot", count);
743       if (sub_type->aligned_size[GRAS_THISARCH] >= 
744           sub_type->aligned_size[r_arch]) {
745         TRY(gras_trp_chunk_recv(sock, (char*)l_data, 
746                                 sub_type->aligned_size[r_arch] * count));
747         if (r_arch != GRAS_THISARCH)
748           TRY(gras_dd_convert_elm(sub_type,count,r_arch, l_data,l_data));
749       } else {
750         ptr = xbt_malloc(sub_type->aligned_size[r_arch] * count);
751
752         TRY(gras_trp_chunk_recv(sock, (char*)ptr, 
753                                 sub_type->size[r_arch] * count));
754         if (r_arch != GRAS_THISARCH)
755           TRY(gras_dd_convert_elm(sub_type,count,r_arch, ptr,l_data));
756         xbt_free(ptr);
757       }
758     } else if (sub_type->category_code == e_gras_datadesc_type_cat_array &&
759                sub_type->category.array_data.fixed_size > 0 &&
760                sub_type->category.array_data.type->category_code == e_gras_datadesc_type_cat_scalar) {
761       gras_datadesc_type_t subsub_type = array_data.type;
762       array_data = sub_type->category.array_data;
763        
764       VERB1("Array of %d fixed array of scalars, get it in one shot",count);
765       if (subsub_type->aligned_size[GRAS_THISARCH] >= 
766           subsub_type->aligned_size[r_arch]) {
767         TRY(gras_trp_chunk_recv(sock, (char*)l_data, 
768                                 subsub_type->aligned_size[r_arch] * count * 
769                                   array_data.fixed_size));
770         if (r_arch != GRAS_THISARCH)
771           TRY(gras_dd_convert_elm(subsub_type,count*array_data.fixed_size,r_arch, l_data,l_data));
772       } else {
773         ptr = xbt_malloc(subsub_type->aligned_size[r_arch] * count*array_data.fixed_size);
774
775         TRY(gras_trp_chunk_recv(sock, (char*)ptr, 
776                                 subsub_type->size[r_arch] * count*array_data.fixed_size));
777         if (r_arch != GRAS_THISARCH)
778           TRY(gras_dd_convert_elm(subsub_type,count*array_data.fixed_size,r_arch, ptr,l_data));
779         xbt_free(ptr);
780       }
781       
782        
783     } else {
784       /* not scalar content, get it recursively (may contain pointers) */
785       elm_size = sub_type->aligned_size[GRAS_THISARCH];
786       VERB2("Receive a %d-long array of %s",count, sub_type->name);
787
788       ptr = l_data;
789       for (cpt=0; cpt<count; cpt++) {
790         TRY(gras_datadesc_recv_rec(sock,state,refs, sub_type,
791                                    r_arch, NULL, 0, ptr,-1,
792                                    detect_cycle || sub_type->cycle));
793         ptr += elm_size;
794       }
795     }
796     break;
797   }
798         
799   default:
800     xbt_assert0(0, "Invalid type");
801   }
802   
803   if (type->recv)
804     type->recv(state,l_data);
805
806   return no_error;
807 }
808
809 /**
810  * gras_datadesc_recv:
811  *
812  * Get an instance of the datatype described by @type from the @socket, 
813  * and store a pointer to it in @dst
814  *
815  */
816 xbt_error_t
817 gras_datadesc_recv(gras_socket_t         sock, 
818                    gras_datadesc_type_t  type,
819                    int                   r_arch,
820                    void                 *dst) {
821
822   xbt_error_t errcode;
823   gras_cbps_t  state; /* callback persistent state */
824   xbt_dict_t  refs;  /* all references already sent */
825
826   refs = xbt_dict_new();
827   state = gras_cbps_new();
828
829   errcode = gras_datadesc_recv_rec(sock, state, refs, type, 
830                                    r_arch, NULL, 0,
831                                    (char *) dst,-1, 
832                                    type->cycle);
833
834   xbt_dict_free(&refs);
835   gras_cbps_free(&state);
836
837   return errcode;
838 }