Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Add the IDL compilation. But since it's WAYS broken, put it between #if 0/#endif
[simgrid.git] / src / gras / DataDesc / ddt_exchange.c
1 /* $Id$ */
2
3 /* ddt_exchange - send/recv data described                                  */
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 "gras/DataDesc/datadesc_private.h"
13 #include "gras/Transport/transport_interface.h" /* gras_trp_chunk_send/recv */
14
15 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(ddt_exchange,datadesc,
16                                  "Sending data over the network");
17 const char *gras_datadesc_cat_names[9] = { 
18   "undefined", 
19   "scalar", "struct", "union", "ref", "array", "ignored",
20   "invalid"};
21
22 static gras_datadesc_type_t int_type = NULL;
23 static gras_datadesc_type_t pointer_type = NULL;    
24 static _XBT_INLINE xbt_error_t gras_dd_send_int(gras_socket_t sock,             int  i);
25 static _XBT_INLINE xbt_error_t gras_dd_recv_int(gras_socket_t sock, int r_arch, int *i);
26
27 static _XBT_INLINE xbt_error_t
28 gras_dd_alloc_ref(xbt_dict_t  refs,  long int     size,
29                   char       **r_ref, long int     r_len,
30                   char       **l_ref, int detect_cycle);
31
32 static _XBT_INLINE int
33 gras_dd_is_r_null(char **r_ptr, long int length);
34
35 static _XBT_INLINE xbt_error_t
36 gras_dd_send_int(gras_socket_t sock,int i) {
37
38   if (!int_type) {
39     int_type = gras_datadesc_by_name("int");
40      xbt_assert(int_type);  
41   }
42    
43   DEBUG1("send_int(%d)",i);
44   return gras_trp_chunk_send(sock, (char*)&i, int_type->size[GRAS_THISARCH]);
45 }
46
47 static _XBT_INLINE xbt_error_t
48 gras_dd_recv_int(gras_socket_t sock, int r_arch, int *i) {
49   xbt_error_t errcode;
50
51   if (!int_type) {
52      int_type = gras_datadesc_by_name("int");
53      xbt_assert(int_type);
54   }
55
56   if (int_type->size[GRAS_THISARCH] >= int_type->size[r_arch]) {
57     TRY(gras_trp_chunk_recv(sock, (char*)i, int_type->size[r_arch]));
58     if (r_arch != GRAS_THISARCH)
59       TRY(gras_dd_convert_elm(int_type,1,r_arch, i,i));
60   } else {
61     void *ptr = xbt_malloc(int_type->size[r_arch]);
62
63     TRY(gras_trp_chunk_recv(sock, (char*)ptr, int_type->size[r_arch]));
64     if (r_arch != GRAS_THISARCH)
65       TRY(gras_dd_convert_elm(int_type,1,r_arch, ptr,i));
66     xbt_free(ptr);
67   }
68   DEBUG1("recv_int(%d)",*i);
69
70   return no_error;
71 }
72
73 /*
74  * Note: here we suppose that the remote NULL is a sequence 
75  *       of 'length' bytes set to 0.
76  * FIXME: Check in configure?
77  */
78 static _XBT_INLINE int 
79 gras_dd_is_r_null(char **r_ptr, long int length) {
80   int i;
81
82   for (i=0; i<length; i++) {
83     if ( ((unsigned char*)r_ptr) [i]) {
84       return 0;
85     }
86   }
87
88   return 1;
89 }
90
91 static _XBT_INLINE xbt_error_t
92 gras_dd_alloc_ref(xbt_dict_t  refs,
93                   long int     size,
94                   char       **r_ref,
95                   long int     r_len, /* pointer_type->size[r_arch] */
96                   char       **l_ref,
97                   int          detect_cycle) {
98   char *l_data = NULL;
99
100   xbt_assert1(size>0,"Cannot allocate %ld bytes!", size);
101   l_data = xbt_malloc((size_t)size);
102
103   *l_ref = l_data;
104   DEBUG2("l_data=%p, &l_data=%p",(void*)l_data,(void*)&l_data);
105
106   DEBUG3("alloc_ref: r_ref=%p; *r_ref=%p, r_len=%ld",
107          (void*)r_ref, (void*)(r_ref?*r_ref:NULL), r_len);
108   if (detect_cycle && r_ref && !gras_dd_is_r_null( r_ref, r_len)) {
109     void *ptr = xbt_malloc(sizeof(void *));
110
111     CRITICAL0("detect_cycle");
112     memcpy(ptr,l_ref, sizeof(void *));
113
114     DEBUG2("Insert %p under %p",*(void**)ptr, *(void**)r_ref);
115
116     if (detect_cycle)
117        xbt_dict_set_ext(refs,(const char *) r_ref, r_len, ptr, xbt_free_fct);
118   }
119   return no_error;
120 }
121
122 /**
123  * gras_datadesc_cpy:
124  *
125  * Copy the data pointed by src and described by type 
126  * to a new location, and store a pointer to it in dst.
127  *
128  */
129 xbt_error_t gras_datadesc_cpy(gras_datadesc_type_t type, 
130                                void *src, 
131                                void **dst) {
132   RAISE_UNIMPLEMENTED;
133 }
134
135 /***
136  *** Direct use functions
137  ***/
138
139 static xbt_error_t 
140 gras_datadesc_send_rec(gras_socket_t         sock,
141                        gras_cbps_t           state,
142                        xbt_dict_t           refs,
143                        gras_datadesc_type_t  type, 
144                        char                 *data,
145                        int                   detect_cycle) {
146
147   xbt_error_t         errcode;
148   int                  cpt;
149   gras_datadesc_type_t sub_type; /* type on which we recurse */
150   
151   VERB2("Send a %s (%s)", 
152         type->name, gras_datadesc_cat_names[type->category_code]);
153
154   if (type->send) {
155     type->send(state,data);
156   }
157
158   switch (type->category_code) {
159   case e_gras_datadesc_type_cat_scalar:
160     TRY(gras_trp_chunk_send(sock, data, type->size[GRAS_THISARCH]));
161     break;
162
163   case e_gras_datadesc_type_cat_struct: {
164     gras_dd_cat_struct_t struct_data;
165     gras_dd_cat_field_t  field;
166     char                *field_data;
167     
168     struct_data = type->category.struct_data;
169     xbt_assert1(struct_data.closed,
170       "Please call gras_datadesc_declare_struct_close on %s before sending it",
171                 type->name);
172     VERB1(">> Send all fields of the structure %s",type->name);
173     xbt_dynar_foreach(struct_data.fields, cpt, field) {
174       field_data = data;
175       field_data += field->offset[GRAS_THISARCH];
176       
177       sub_type = field->type;
178       
179       if (field->pre)
180         field->pre(state,field_data);
181       
182       VERB1("Send field %s",field->name);
183       TRY(gras_datadesc_send_rec(sock,state,refs,sub_type, field_data, detect_cycle || sub_type->cycle));
184       
185       if (field->post)
186         field->post(state,field_data);
187     }
188     VERB1("<< Sent all fields of the structure %s", type->name);
189     
190     break;
191   }
192
193   case e_gras_datadesc_type_cat_union: {
194     gras_dd_cat_union_t union_data;
195     gras_dd_cat_field_t field=NULL;
196     int                 field_num;
197     
198     union_data = type->category.union_data;
199     
200     xbt_assert1(union_data.closed,
201                 "Please call gras_datadesc_declare_union_close on %s before sending it",
202                 type->name);
203     /* retrieve the field number */
204     field_num = union_data.selector(state, data);
205     
206     xbt_assert1(field_num > 0,
207                  "union field selector of %s gave a negative value", 
208                  type->name);
209     
210     xbt_assert3(field_num < xbt_dynar_length(union_data.fields),
211          "union field selector of %s returned %d but there is only %lu fields",
212                  type->name, field_num, xbt_dynar_length(union_data.fields));
213
214     /* Send the field number */
215     TRY(gras_dd_send_int(sock, field_num));
216     
217     /* Send the content */
218     field = xbt_dynar_get_as(union_data.fields, field_num, gras_dd_cat_field_t);
219     sub_type = field->type;
220     
221     if (field->pre)
222       field->pre(state,data);
223     
224     TRY(gras_datadesc_send_rec(sock,state,refs, sub_type, data, detect_cycle || sub_type->cycle));
225       
226     if (field->post)
227       field->post(state,data);
228     
229     break;
230   }
231     
232   case e_gras_datadesc_type_cat_ref: {
233     gras_dd_cat_ref_t      ref_data;
234
235     void                 **ref=(void**)data;
236     void *dummy;
237     
238     ref_data = type->category.ref_data;
239     
240     /* Detect the referenced type and send it to peer if needed */
241     sub_type = ref_data.type;
242     if (sub_type == NULL) {
243       sub_type = (*ref_data.selector)(state,data);
244       TRY(gras_dd_send_int(sock, sub_type->code));
245     }
246     
247     /* Send the actual value of the pointer for cycle handling */
248     if (!pointer_type) {
249       pointer_type = gras_datadesc_by_name("data pointer");
250       xbt_assert(pointer_type);
251     }
252      
253     TRY(gras_trp_chunk_send(sock, (char*)data,
254                             pointer_type->size[GRAS_THISARCH]));
255     
256     /* Send the pointed data only if not already sent */
257     if (*(void**)data == NULL) {
258       VERB0("Not sending NULL referenced data");
259       break;
260     }
261     errcode = detect_cycle 
262             ? xbt_dict_get_ext(refs,(char*)ref, sizeof(void*), &dummy)
263             : mismatch_error;
264     if (errcode == mismatch_error) {
265        VERB1("Sending data referenced at %p", (void*)*ref);
266        if (detect_cycle)
267          xbt_dict_set_ext(refs, (char*)ref, sizeof(void*), ref, NULL);
268        TRY(gras_datadesc_send_rec(sock,state,refs, sub_type, *ref, detect_cycle || sub_type->cycle));
269           
270     } else if (errcode == no_error) {
271        VERB1("Not sending data referenced at %p (already done)", (void*)*ref);
272     } else {
273        return errcode;
274     }
275     
276     break;
277   }
278
279   case e_gras_datadesc_type_cat_array: {
280     gras_dd_cat_array_t    array_data;
281     long int               count;
282     char                  *ptr=data;
283     long int               elm_size;
284     
285     array_data = type->category.array_data;
286     
287     /* determine and send the element count */
288     count = array_data.fixed_size;
289     if (count == 0) {
290       count = array_data.dynamic_size(state,data);
291       xbt_assert1(count >=0,
292                    "Invalid (negative) array size for type %s",type->name);
293       TRY(gras_dd_send_int(sock, count));
294     }
295     
296     /* send the content */
297     sub_type = array_data.type;
298     elm_size = sub_type->aligned_size[GRAS_THISARCH];
299     if (sub_type->category_code == e_gras_datadesc_type_cat_scalar) {
300       VERB1("Array of %ld scalars, send it in one shot",count);
301       TRY(gras_trp_chunk_send(sock, data, 
302                               sub_type->aligned_size[GRAS_THISARCH] * count));
303     } else if (sub_type->category_code == e_gras_datadesc_type_cat_array &&
304                sub_type->category.array_data.fixed_size > 0 &&
305                sub_type->category.array_data.type->category_code == e_gras_datadesc_type_cat_scalar) {
306        
307       VERB1("Array of %ld fixed array of scalars, send it in one shot",count);
308       TRY(gras_trp_chunk_send(sock, data, 
309                               sub_type->category.array_data.type->aligned_size[GRAS_THISARCH] 
310                                  * count * sub_type->category.array_data.fixed_size));
311        
312     } else {
313       for (cpt=0; cpt<count; cpt++) {
314         TRY(gras_datadesc_send_rec(sock,state,refs, sub_type, ptr, detect_cycle || sub_type->cycle));
315         ptr += elm_size;
316       }
317     }
318     break;
319   }
320
321   default:
322     xbt_assert0(0, "Invalid type");
323   }
324
325   return no_error;
326 }
327
328 /**
329  * gras_datadesc_send:
330  *
331  * Copy the data pointed by src and described by type to the socket
332  *
333  */
334 xbt_error_t gras_datadesc_send(gras_socket_t        sock, 
335                                 gras_datadesc_type_t type, 
336                                 void *src) {
337
338   xbt_error_t errcode;
339   gras_cbps_t  state;
340   xbt_dict_t  refs; /* all references already sent */
341  
342   refs = xbt_dict_new();
343   state = gras_cbps_new();
344    
345   errcode = gras_datadesc_send_rec(sock,state,refs,type,(char*)src, type->cycle);
346
347   xbt_dict_free(&refs);
348   gras_cbps_free(&state);
349
350   return errcode;
351 }
352
353 /**
354  * gras_datadesc_recv_rec:
355  *
356  * Do the data reception job recursively.
357  *
358  * subsize used only to deal with vicious case of reference to dynamic array.
359  *  This size is needed at the reference reception level (to allocate enough 
360  * space) and at the array reception level (to fill enough room). 
361  * 
362  * Having this size passed as an argument of the recursive function is a crude
363  * hack, but I was told that working code is sometimes better than neat one ;)
364  */
365 static xbt_error_t
366 gras_datadesc_recv_rec(gras_socket_t         sock, 
367                        gras_cbps_t           state,
368                        xbt_dict_t           refs,
369                        gras_datadesc_type_t  type,
370                        int                   r_arch,
371                        char                **r_data,
372                        long int              r_lgr,
373                        char                 *l_data,
374                        int                   subsize,
375                        int                   detect_cycle) {
376
377   xbt_error_t         errcode;
378   int                  cpt;
379   gras_datadesc_type_t sub_type;
380
381   VERB2("Recv a %s @%p", type->name, (void*)l_data);
382   xbt_assert(l_data);
383
384   switch (type->category_code) {
385   case e_gras_datadesc_type_cat_scalar:
386     if (type->size[GRAS_THISARCH] == type->size[r_arch]) {
387       TRY(gras_trp_chunk_recv(sock, (char*)l_data, type->size[r_arch]));
388       if (r_arch != GRAS_THISARCH)
389         TRY(gras_dd_convert_elm(type,1,r_arch, l_data,l_data));
390     } else {
391       void *ptr = xbt_malloc(type->size[r_arch]);
392
393       TRY(gras_trp_chunk_recv(sock, (char*)ptr, type->size[r_arch]));
394       if (r_arch != GRAS_THISARCH)
395         TRY(gras_dd_convert_elm(type,1,r_arch, ptr,l_data));
396       xbt_free(ptr);
397     }
398     break;
399
400   case e_gras_datadesc_type_cat_struct: {
401     gras_dd_cat_struct_t struct_data;
402     gras_dd_cat_field_t  field;
403
404     struct_data = type->category.struct_data;
405
406     xbt_assert1(struct_data.closed,
407                 "Please call gras_datadesc_declare_struct_close on %s before receiving it",
408                 type->name);
409     VERB1(">> Receive all fields of the structure %s",type->name);
410     xbt_dynar_foreach(struct_data.fields, cpt, field) {
411       char                 *field_data = l_data + field->offset[GRAS_THISARCH];
412
413       sub_type = field->type;
414
415       TRY(gras_datadesc_recv_rec(sock,state,refs, sub_type,
416                                  r_arch,NULL,0,
417                                  field_data,-1, 
418                                  detect_cycle || sub_type->cycle));
419     }
420     VERB1("<< Received all fields of the structure %s", type->name);
421     
422     break;
423   }
424
425   case e_gras_datadesc_type_cat_union: {
426     gras_dd_cat_union_t union_data;
427     gras_dd_cat_field_t field=NULL;
428     int                 field_num;
429
430     union_data = type->category.union_data;
431
432     xbt_assert1(union_data.closed,
433                 "Please call gras_datadesc_declare_union_close on %s before receiving it",
434                 type->name);
435     /* retrieve the field number */
436     TRY(gras_dd_recv_int(sock, r_arch, &field_num));
437     if (field_num < 0)
438       RAISE1(mismatch_error,
439              "Received union field for %s is negative", type->name);
440     if (field_num < xbt_dynar_length(union_data.fields)) 
441       RAISE3(mismatch_error,
442              "Received union field for %s is %d but there is only %lu fields",
443              type->name, field_num, xbt_dynar_length(union_data.fields));
444     
445     /* Recv the content */
446     field = xbt_dynar_get_as(union_data.fields, field_num, gras_dd_cat_field_t);
447     sub_type = field->type;
448     
449     TRY(gras_datadesc_recv_rec(sock,state,refs, sub_type,
450                                r_arch,NULL,0,
451                                l_data,-1, 
452                                detect_cycle || sub_type->cycle));
453     break;
454   }
455
456   case e_gras_datadesc_type_cat_ref: {
457     char             **r_ref = NULL;
458     char             **l_ref = NULL;
459     gras_dd_cat_ref_t  ref_data;
460     
461     ref_data = type->category.ref_data;
462
463     /* Get the referenced type locally or from peer */
464     sub_type = ref_data.type;
465     if (sub_type == NULL) {
466       int ref_code;
467       TRY(gras_dd_recv_int(sock, r_arch, &ref_code));
468       TRY(gras_datadesc_by_id(ref_code, &sub_type));
469     }
470
471     /* Get the actual value of the pointer for cycle handling */
472     if (!pointer_type) {
473       pointer_type = gras_datadesc_by_name("data pointer");
474       xbt_assert(pointer_type);
475     }
476
477     r_ref = xbt_malloc(pointer_type->size[r_arch]);
478
479     TRY(gras_trp_chunk_recv(sock, (char*)r_ref,
480                             pointer_type->size[r_arch]));
481
482     /* Receive the pointed data only if not already sent */
483     if (gras_dd_is_r_null(r_ref, pointer_type->size[r_arch])) {
484       VERB1("Not receiving data remotely referenced @%p since it's NULL",
485             *(void **)r_ref);
486       *(void**)l_data = NULL;
487       xbt_free(r_ref);
488       break;
489     }
490          
491     errcode = detect_cycle
492             ? xbt_dict_get_ext(refs,
493                                 (char*)r_ref, pointer_type->size[r_arch],
494                                 (void**)&l_ref)
495             : mismatch_error;
496
497     if (errcode == mismatch_error) {
498       int subsubcount = 0;
499       void *l_referenced=NULL;
500
501       VERB2("Receiving a ref to '%s', remotely @%p",
502             sub_type->name, *(void**)r_ref);
503       if (sub_type->category_code == e_gras_datadesc_type_cat_array) {
504         /* Damn. Reference to a dynamic array. Allocating the size for it 
505            is more complicated */
506         gras_dd_cat_array_t array_data = sub_type->category.array_data;
507         gras_datadesc_type_t subsub_type;
508
509         subsubcount = array_data.fixed_size;
510         if (subsubcount == 0)
511           TRY(gras_dd_recv_int(sock, r_arch, &subsubcount));
512
513         subsub_type = array_data.type;
514
515
516         TRY(gras_dd_alloc_ref(refs,
517                               subsub_type->size[GRAS_THISARCH] * subsubcount, 
518                               r_ref,pointer_type->size[r_arch], 
519                               (char**)&l_referenced,
520                               detect_cycle));
521       } else {
522         TRY(gras_dd_alloc_ref(refs,sub_type->size[GRAS_THISARCH], 
523                               r_ref,pointer_type->size[r_arch], 
524                               (char**)&l_referenced,
525                               detect_cycle));
526       }
527
528       TRY(gras_datadesc_recv_rec(sock,state,refs, sub_type,
529                                  r_arch,r_ref,pointer_type->size[r_arch],
530                                  (char*)l_referenced, subsubcount, 
531                                  detect_cycle || sub_type->cycle));
532       *(void**)l_data=l_referenced;
533       VERB3("'%s' remotely referenced at %p locally at %p",
534             sub_type->name, *(void**)r_ref, l_referenced);
535       
536     } else if (errcode == no_error) {
537       VERB2("NOT receiving data remotely referenced @%p (already done, @%p here)",
538             *(void**)r_ref, *(void**)l_ref);
539
540       *(void**)l_data=*l_ref;
541
542     } else {
543       return errcode;
544     }
545     xbt_free(r_ref);
546     break;
547   }
548
549   case e_gras_datadesc_type_cat_array: {
550     gras_dd_cat_array_t    array_data;
551     int       count;
552     char     *ptr;
553     long int  elm_size;
554
555     array_data = type->category.array_data;
556     /* determine element count locally, or from caller, or from peer */
557     count = array_data.fixed_size;
558     if (count == 0)
559       count = subsize;
560     if (count == 0)
561       TRY(gras_dd_recv_int(sock, r_arch, &count));
562     if (count == 0)
563       RAISE1(mismatch_error,
564              "Invalid (=0) array size for type %s",type->name);
565
566     /* receive the content */
567     sub_type = array_data.type;
568     if (sub_type->category_code == e_gras_datadesc_type_cat_scalar) {
569       VERB1("Array of %d scalars, get it in one shoot", count);
570       if (sub_type->aligned_size[GRAS_THISARCH] >= 
571           sub_type->aligned_size[r_arch]) {
572         TRY(gras_trp_chunk_recv(sock, (char*)l_data, 
573                                 sub_type->aligned_size[r_arch] * count));
574         if (r_arch != GRAS_THISARCH)
575           TRY(gras_dd_convert_elm(sub_type,count,r_arch, l_data,l_data));
576       } else {
577         ptr = xbt_malloc(sub_type->aligned_size[r_arch] * count);
578
579         TRY(gras_trp_chunk_recv(sock, (char*)ptr, 
580                                 sub_type->size[r_arch] * count));
581         if (r_arch != GRAS_THISARCH)
582           TRY(gras_dd_convert_elm(sub_type,count,r_arch, ptr,l_data));
583         xbt_free(ptr);
584       }
585     } else if (sub_type->category_code == e_gras_datadesc_type_cat_array &&
586                sub_type->category.array_data.fixed_size > 0 &&
587                sub_type->category.array_data.type->category_code == e_gras_datadesc_type_cat_scalar) {
588       gras_datadesc_type_t subsub_type;
589       array_data = sub_type->category.array_data;
590       subsub_type = array_data.type;
591        
592       VERB1("Array of %d fixed array of scalars, get it in one shot",count);
593       if (subsub_type->aligned_size[GRAS_THISARCH] >= 
594           subsub_type->aligned_size[r_arch]) {
595         TRY(gras_trp_chunk_recv(sock, (char*)l_data, 
596                                 subsub_type->aligned_size[r_arch] * count * 
597                                   array_data.fixed_size));
598         if (r_arch != GRAS_THISARCH)
599           TRY(gras_dd_convert_elm(subsub_type,count*array_data.fixed_size,r_arch, l_data,l_data));
600       } else {
601         ptr = xbt_malloc(subsub_type->aligned_size[r_arch] * count*array_data.fixed_size);
602
603         TRY(gras_trp_chunk_recv(sock, (char*)ptr, 
604                                 subsub_type->size[r_arch] * count*array_data.fixed_size));
605         if (r_arch != GRAS_THISARCH)
606           TRY(gras_dd_convert_elm(subsub_type,count*array_data.fixed_size,r_arch, ptr,l_data));
607         xbt_free(ptr);
608       }
609       
610        
611     } else {
612       /* not scalar content, get it recursively (may contain pointers) */
613       elm_size = sub_type->aligned_size[GRAS_THISARCH];
614       VERB2("Receive a %d-long array of %s",count, sub_type->name);
615
616       ptr = l_data;
617       for (cpt=0; cpt<count; cpt++) {
618         TRY(gras_datadesc_recv_rec(sock,state,refs, sub_type,
619                                    r_arch, NULL, 0, ptr,-1,
620                                    detect_cycle || sub_type->cycle));
621         ptr += elm_size;
622       }
623     }
624     break;
625   }
626         
627   default:
628     xbt_assert0(0, "Invalid type");
629   }
630   
631   if (type->recv)
632     type->recv(state,l_data);
633
634   return no_error;
635 }
636
637 /**
638  * gras_datadesc_recv:
639  *
640  * Get an instance of the datatype described by @type from the @socket, 
641  * and store a pointer to it in @dst
642  *
643  */
644 xbt_error_t
645 gras_datadesc_recv(gras_socket_t         sock, 
646                    gras_datadesc_type_t  type,
647                    int                   r_arch,
648                    void                 *dst) {
649
650   xbt_error_t errcode;
651   gras_cbps_t  state; /* callback persistent state */
652   xbt_dict_t  refs;  /* all references already sent */
653
654   refs = xbt_dict_new();
655   state = gras_cbps_new();
656
657   errcode = gras_datadesc_recv_rec(sock, state, refs, type, 
658                                    r_arch, NULL, 0,
659                                    (char *) dst,-1, 
660                                    type->cycle);
661
662   xbt_dict_free(&refs);
663   gras_cbps_free(&state);
664
665   return errcode;
666 }
667
668 #if 0
669 /***
670  *** IDL compiling functions
671  ***/
672
673 #define gras_datadesc_send_rec foo /* Just to make sure the copypast was ok */
674 #define gras_datadesc_send     foo /* Just to make sure the copypast was ok */
675 #define gras_datadesc_recv_rec foo /* Just to make sure the copypast was ok */
676 #define gras_datadesc_recv     foo /* Just to make sure the copypast was ok */
677
678 static xbt_error_t 
679 gras_datadesc_gen_send_rec(gras_socket_t         sock,
680                            gras_cbps_t           state,
681                            xbt_dict_t           refs,
682                            gras_datadesc_type_t  type, 
683                            char                 *data,
684                            int                   detect_cycle) {
685
686   xbt_error_t         errcode;
687   int                  cpt;
688   gras_datadesc_type_t sub_type; /* type on which we recurse */
689   
690   printf("  VERB2(\"Send a %s (%s)\");\n", 
691          type->name, gras_datadesc_cat_names[type->category_code]);
692
693   xbt_assert0(!type->send, "Callbacks not implemented in IDL compiler");
694
695   switch (type->category_code) {
696   case e_gras_datadesc_type_cat_scalar:
697     printf("  TRY(gras_trp_chunk_send(sock, data, %lu));\n",type->size[GRAS_THISARCH]);
698     break;
699
700   case e_gras_datadesc_type_cat_struct: {
701     gras_dd_cat_struct_t struct_data;
702     gras_dd_cat_field_t  field;
703     char                *field_data;
704     
705     struct_data = type->category.struct_data;
706     xbt_assert1(struct_data.closed,
707       "Please call gras_datadesc_declare_struct_close on %s before sending it",
708                 type->name);
709     printf("  VERB1(\">> Send all fields of the structure %s\");\n",type->name);
710     xbt_dynar_foreach(struct_data.fields, cpt, field) {
711       field_data = data;
712       field_data += field->offset[GRAS_THISARCH];
713       
714       sub_type = field->type;
715       
716       xbt_assert0(!field->pre, "Callbacks not implemented in IDL compiler");
717       
718       printf("  VERB1(\"Send field %s\");\n",field->name);
719       printf("  data += %lu;\n",field->offset[GRAS_THISARCH]);
720       TRY(gras_datadesc_gen_send_rec(sock,state,refs,sub_type, field_data, detect_cycle || sub_type->cycle));
721       printf("  data -= %lu;\n",field->offset[GRAS_THISARCH]);
722       
723       xbt_assert0(!field->post, "Callbacks not implemented in IDL compiler");
724     }
725     printf("  VERB1(\"<< Sent all fields of the structure %s\"", type->name);
726     
727     break;
728   }
729
730   case e_gras_datadesc_type_cat_union: {
731     gras_dd_cat_union_t union_data;
732     gras_dd_cat_field_t field=NULL;
733     int                 field_num;
734     
735     union_data = type->category.union_data;
736     
737     xbt_assert1(union_data.closed,
738                 "Please call gras_datadesc_declare_union_close on %s before sending it",
739                 type->name);
740     /* retrieve the field number */
741     printf("  field_num = union_data.selector(state, data);\n");
742     
743     printf("  xbt_assert0(field_num > 0,\n");
744     printf("              \"union field selector of %s gave a negative value\");\n",type->name);
745     
746     printf("  xbt_assert3(field_num < xbt_dynar_length(union_data.fields),\n");
747     printf("              \"union field selector of %s returned %%d but there is only %lu fields\",field_num);\n",
748                  type->name, xbt_dynar_length(union_data.fields));
749
750     /* Send the field number */
751     printf("TRY(gras_dd_send_int(sock, field_num));\n");
752     
753     /* Send the content */
754     field = xbt_dynar_get_as(union_data.fields, field_num, gras_dd_cat_field_t);
755     sub_type = field->type;
756     
757     if (field->pre)
758       field->pre(state,data);
759     
760     TRY(gras_datadesc_gen_send_rec(sock,state,refs, sub_type, data, detect_cycle || sub_type->cycle));
761       
762     if (field->post)
763       field->post(state,data);
764     
765     break;
766   }
767     
768   case e_gras_datadesc_type_cat_ref: {
769     gras_dd_cat_ref_t      ref_data;
770
771     void                 **ref=(void**)data;
772     void *dummy;
773     
774     ref_data = type->category.ref_data;
775     
776     /* Detect the referenced type and send it to peer if needed */
777     sub_type = ref_data.type;
778     if (sub_type == NULL) {
779       sub_type = (*ref_data.selector)(state,data);
780       TRY(gras_dd_send_int(sock, sub_type->code));
781     }
782     
783     /* Send the actual value of the pointer for cycle handling */
784     if (!pointer_type) {
785       pointer_type = gras_datadesc_by_name("data pointer");
786       xbt_assert(pointer_type);
787     }
788      
789     TRY(gras_trp_chunk_send(sock, (char*)data,
790                             pointer_type->size[GRAS_THISARCH]));
791     
792     /* Send the pointed data only if not already sent */
793     if (*(void**)data == NULL) {
794       VERB0("Not sending NULL referenced data");
795       break;
796     }
797     errcode = detect_cycle 
798             ? xbt_dict_get_ext(refs,(char*)ref, sizeof(void*), &dummy)
799             : mismatch_error;
800     if (errcode == mismatch_error) {
801        VERB1("Sending data referenced at %p", (void*)*ref);
802        if (detect_cycle)
803          xbt_dict_set_ext(refs, (char*)ref, sizeof(void*), ref, NULL);
804        TRY(gras_datadesc_gen_send_rec(sock,state,refs, sub_type, *ref, detect_cycle || sub_type->cycle));
805           
806     } else if (errcode == no_error) {
807        VERB1("Not sending data referenced at %p (already done)", (void*)*ref);
808     } else {
809        return errcode;
810     }
811     
812     break;
813   }
814
815   case e_gras_datadesc_type_cat_array: {
816     gras_dd_cat_array_t    array_data;
817     long int               count;
818     char                  *ptr=data;
819     long int               elm_size;
820     
821     array_data = type->category.array_data;
822     
823     /* determine and send the element count */
824     count = array_data.fixed_size;
825     if (count == 0) {
826       count = array_data.dynamic_size(state,data);
827       xbt_assert1(count >=0,
828                    "Invalid (negative) array size for type %s",type->name);
829       TRY(gras_dd_send_int(sock, count));
830     }
831     
832     /* send the content */
833     sub_type = array_data.type;
834     elm_size = sub_type->aligned_size[GRAS_THISARCH];
835     if (sub_type->category_code == e_gras_datadesc_type_cat_scalar) {
836       VERB1("Array of %ld scalars, send it in one shot",count);
837       TRY(gras_trp_chunk_send(sock, data, 
838                               sub_type->aligned_size[GRAS_THISARCH] * count));
839     } else if (sub_type->category_code == e_gras_datadesc_type_cat_array &&
840                sub_type->category.array_data.fixed_size > 0 &&
841                sub_type->category.array_data.type->category_code == e_gras_datadesc_type_cat_scalar) {
842        
843       VERB1("Array of %ld fixed array of scalars, send it in one shot",count);
844       TRY(gras_trp_chunk_send(sock, data, 
845                               sub_type->category.array_data.type->aligned_size[GRAS_THISARCH] 
846                                  * count * sub_type->category.array_data.fixed_size));
847        
848     } else {
849       for (cpt=0; cpt<count; cpt++) {
850         TRY(gras_datadesc_gen_send_rec(sock,state,refs, sub_type, ptr, detect_cycle || sub_type->cycle));
851         ptr += elm_size;
852       }
853     }
854     break;
855   }
856
857   default:
858     xbt_assert0(0, "Invalid type");
859   }
860
861   return no_error;
862 }
863
864 /**
865  * gras_datadesc_gen_send:
866  *
867  * Copy the data pointed by src and described by type to the socket
868  *
869  */
870 xbt_error_t gras_datadesc_gen_send(gras_socket_t        sock, 
871                                    gras_datadesc_type_t type, 
872                                    void *src) {
873
874   xbt_error_t errcode;
875   gras_cbps_t  state;
876   xbt_dict_t  refs; /* all references already sent */
877  
878   refs = xbt_dict_new();
879   state = gras_cbps_new();
880    
881   printf("xbt_error_t gras_%s_send(gras_socket_t sock,void *dst){\n",
882          type->name);
883   errcode = gras_datadesc_gen_send_rec(sock,state,refs,type,(char*)src, type->cycle);
884   printf("}\n");
885   
886   xbt_dict_free(&refs);
887   gras_cbps_free(&state);
888
889   return errcode;
890 }
891
892 /**
893  * gras_datadesc_gen_recv_rec:
894  *
895  * Do the data reception job recursively.
896  *
897  * subsize used only to deal with vicious case of reference to dynamic array.
898  *  This size is needed at the reference reception level (to allocate enough 
899  * space) and at the array reception level (to fill enough room). 
900  * 
901  * Having this size passed as an argument of the recursive function is a crude
902  * hack, but I was told that working code is sometimes better than neat one ;)
903  */
904 static xbt_error_t
905 gras_datadesc_gen_recv_rec(gras_socket_t         sock, 
906                            gras_cbps_t           state,
907                            xbt_dict_t           refs,
908                            gras_datadesc_type_t  type,
909                            int                   r_arch,
910                            char                **r_data,
911                            long int              r_lgr,
912                            char                 *l_data,
913                            int                   subsize,
914                            int                   detect_cycle) {
915
916   xbt_error_t         errcode;
917   int                  cpt;
918   gras_datadesc_type_t sub_type;
919
920   VERB2("Recv a %s @%p", type->name, (void*)l_data);
921   xbt_assert(l_data);
922
923   switch (type->category_code) {
924   case e_gras_datadesc_type_cat_scalar:
925     if (type->size[GRAS_THISARCH] == type->size[r_arch]) {
926       TRY(gras_trp_chunk_recv(sock, (char*)l_data, type->size[r_arch]));
927       if (r_arch != GRAS_THISARCH)
928         TRY(gras_dd_convert_elm(type,1,r_arch, l_data,l_data));
929     } else {
930       void *ptr = xbt_malloc(type->size[r_arch]);
931
932       TRY(gras_trp_chunk_recv(sock, (char*)ptr, type->size[r_arch]));
933       if (r_arch != GRAS_THISARCH)
934         TRY(gras_dd_convert_elm(type,1,r_arch, ptr,l_data));
935       xbt_free(ptr);
936     }
937     break;
938
939   case e_gras_datadesc_type_cat_struct: {
940     gras_dd_cat_struct_t struct_data;
941     gras_dd_cat_field_t  field;
942
943     struct_data = type->category.struct_data;
944
945     xbt_assert1(struct_data.closed,
946                 "Please call gras_datadesc_declare_struct_close on %s before receiving it",
947                 type->name);
948     VERB1(">> Receive all fields of the structure %s",type->name);
949     xbt_dynar_foreach(struct_data.fields, cpt, field) {
950       char                 *field_data = l_data + field->offset[GRAS_THISARCH];
951
952       sub_type = field->type;
953
954       TRY(gras_datadesc_gen_recv_rec(sock,state,refs, sub_type,
955                                      r_arch,NULL,0,
956                                      field_data,-1, 
957                                      detect_cycle || sub_type->cycle));
958     }
959     VERB1("<< Received all fields of the structure %s", type->name);
960     
961     break;
962   }
963
964   case e_gras_datadesc_type_cat_union: {
965     gras_dd_cat_union_t union_data;
966     gras_dd_cat_field_t field=NULL;
967     int                 field_num;
968
969     union_data = type->category.union_data;
970
971     xbt_assert1(union_data.closed,
972                 "Please call gras_datadesc_declare_union_close on %s before receiving it",
973                 type->name);
974     /* retrieve the field number */
975     TRY(gras_dd_recv_int(sock, r_arch, &field_num));
976     if (field_num < 0)
977       RAISE1(mismatch_error,
978              "Received union field for %s is negative", type->name);
979     if (field_num < xbt_dynar_length(union_data.fields)) 
980       RAISE3(mismatch_error,
981              "Received union field for %s is %d but there is only %lu fields",
982              type->name, field_num, xbt_dynar_length(union_data.fields));
983     
984     /* Recv the content */
985     field = xbt_dynar_get_as(union_data.fields, field_num, gras_dd_cat_field_t);
986     sub_type = field->type;
987     
988     TRY(gras_datadesc_gen_recv_rec(sock,state,refs, sub_type,
989                                    r_arch,NULL,0,
990                                    l_data,-1, 
991                                    detect_cycle || sub_type->cycle));
992     break;
993   }
994
995   case e_gras_datadesc_type_cat_ref: {
996     char             **r_ref = NULL;
997     char             **l_ref = NULL;
998     gras_dd_cat_ref_t  ref_data;
999     
1000     ref_data = type->category.ref_data;
1001
1002     /* Get the referenced type locally or from peer */
1003     sub_type = ref_data.type;
1004     if (sub_type == NULL) {
1005       int ref_code;
1006       TRY(gras_dd_recv_int(sock, r_arch, &ref_code));
1007       TRY(gras_datadesc_by_id(ref_code, &sub_type));
1008     }
1009
1010     /* Get the actual value of the pointer for cycle handling */
1011     if (!pointer_type) {
1012       pointer_type = gras_datadesc_by_name("data pointer");
1013       xbt_assert(pointer_type);
1014     }
1015
1016     r_ref = xbt_malloc(pointer_type->size[r_arch]);
1017
1018     TRY(gras_trp_chunk_recv(sock, (char*)r_ref,
1019                             pointer_type->size[r_arch]));
1020
1021     /* Receive the pointed data only if not already sent */
1022     if (gras_dd_is_r_null(r_ref, pointer_type->size[r_arch])) {
1023       VERB1("Not receiving data remotely referenced @%p since it's NULL",
1024             *(void **)r_ref);
1025       *(void**)l_data = NULL;
1026       xbt_free(r_ref);
1027       break;
1028     }
1029          
1030     errcode = detect_cycle
1031             ? xbt_dict_get_ext(refs,
1032                                 (char*)r_ref, pointer_type->size[r_arch],
1033                                 (void**)&l_ref)
1034             : mismatch_error;
1035
1036     if (errcode == mismatch_error) {
1037       int subsubcount = 0;
1038       void *l_referenced=NULL;
1039
1040       VERB2("Receiving a ref to '%s', remotely @%p",
1041             sub_type->name, *(void**)r_ref);
1042       if (sub_type->category_code == e_gras_datadesc_type_cat_array) {
1043         /* Damn. Reference to a dynamic array. Allocating the size for it 
1044            is more complicated */
1045         gras_dd_cat_array_t array_data = sub_type->category.array_data;
1046         gras_datadesc_type_t subsub_type;
1047
1048         subsubcount = array_data.fixed_size;
1049         if (subsubcount == 0)
1050           TRY(gras_dd_recv_int(sock, r_arch, &subsubcount));
1051
1052         subsub_type = array_data.type;
1053
1054
1055         TRY(gras_dd_alloc_ref(refs,
1056                               subsub_type->size[GRAS_THISARCH] * subsubcount, 
1057                               r_ref,pointer_type->size[r_arch], 
1058                               (char**)&l_referenced,
1059                               detect_cycle));
1060       } else {
1061         TRY(gras_dd_alloc_ref(refs,sub_type->size[GRAS_THISARCH], 
1062                               r_ref,pointer_type->size[r_arch], 
1063                               (char**)&l_referenced,
1064                               detect_cycle));
1065       }
1066
1067       TRY(gras_datadesc_gen_recv_rec(sock,state,refs, sub_type,
1068                                      r_arch,r_ref,pointer_type->size[r_arch],
1069                                      (char*)l_referenced, subsubcount, 
1070                                      detect_cycle || sub_type->cycle));
1071       *(void**)l_data=l_referenced;
1072       VERB3("'%s' remotely referenced at %p locally at %p",
1073             sub_type->name, *(void**)r_ref, l_referenced);
1074       
1075     } else if (errcode == no_error) {
1076       VERB2("NOT receiving data remotely referenced @%p (already done, @%p here)",
1077             *(void**)r_ref, *(void**)l_ref);
1078
1079       *(void**)l_data=*l_ref;
1080
1081     } else {
1082       return errcode;
1083     }
1084     xbt_free(r_ref);
1085     break;
1086   }
1087
1088   case e_gras_datadesc_type_cat_array: {
1089     gras_dd_cat_array_t    array_data;
1090     int       count;
1091     char     *ptr;
1092     long int  elm_size;
1093
1094     array_data = type->category.array_data;
1095     /* determine element count locally, or from caller, or from peer */
1096     count = array_data.fixed_size;
1097     if (count == 0)
1098       count = subsize;
1099     if (count == 0)
1100       TRY(gras_dd_recv_int(sock, r_arch, &count));
1101     if (count == 0)
1102       RAISE1(mismatch_error,
1103              "Invalid (=0) array size for type %s",type->name);
1104
1105     /* receive the content */
1106     sub_type = array_data.type;
1107     if (sub_type->category_code == e_gras_datadesc_type_cat_scalar) {
1108       VERB1("Array of %d scalars, get it in one shoot", count);
1109       if (sub_type->aligned_size[GRAS_THISARCH] >= 
1110           sub_type->aligned_size[r_arch]) {
1111         TRY(gras_trp_chunk_recv(sock, (char*)l_data, 
1112                                 sub_type->aligned_size[r_arch] * count));
1113         if (r_arch != GRAS_THISARCH)
1114           TRY(gras_dd_convert_elm(sub_type,count,r_arch, l_data,l_data));
1115       } else {
1116         ptr = xbt_malloc(sub_type->aligned_size[r_arch] * count);
1117
1118         TRY(gras_trp_chunk_recv(sock, (char*)ptr, 
1119                                 sub_type->size[r_arch] * count));
1120         if (r_arch != GRAS_THISARCH)
1121           TRY(gras_dd_convert_elm(sub_type,count,r_arch, ptr,l_data));
1122         xbt_free(ptr);
1123       }
1124     } else if (sub_type->category_code == e_gras_datadesc_type_cat_array &&
1125                sub_type->category.array_data.fixed_size > 0 &&
1126                sub_type->category.array_data.type->category_code == e_gras_datadesc_type_cat_scalar) {
1127       gras_datadesc_type_t subsub_type;
1128       array_data = sub_type->category.array_data;
1129       subsub_type = array_data.type;
1130        
1131       VERB1("Array of %d fixed array of scalars, get it in one shot",count);
1132       if (subsub_type->aligned_size[GRAS_THISARCH] >= 
1133           subsub_type->aligned_size[r_arch]) {
1134         TRY(gras_trp_chunk_recv(sock, (char*)l_data, 
1135                                 subsub_type->aligned_size[r_arch] * count * 
1136                                   array_data.fixed_size));
1137         if (r_arch != GRAS_THISARCH)
1138           TRY(gras_dd_convert_elm(subsub_type,count*array_data.fixed_size,r_arch, l_data,l_data));
1139       } else {
1140         ptr = xbt_malloc(subsub_type->aligned_size[r_arch] * count*array_data.fixed_size);
1141
1142         TRY(gras_trp_chunk_recv(sock, (char*)ptr, 
1143                                 subsub_type->size[r_arch] * count*array_data.fixed_size));
1144         if (r_arch != GRAS_THISARCH)
1145           TRY(gras_dd_convert_elm(subsub_type,count*array_data.fixed_size,r_arch, ptr,l_data));
1146         xbt_free(ptr);
1147       }
1148       
1149        
1150     } else {
1151       /* not scalar content, get it recursively (may contain pointers) */
1152       elm_size = sub_type->aligned_size[GRAS_THISARCH];
1153       VERB2("Receive a %d-long array of %s",count, sub_type->name);
1154
1155       ptr = l_data;
1156       for (cpt=0; cpt<count; cpt++) {
1157         TRY(gras_datadesc_gen_recv_rec(sock,state,refs, sub_type,
1158                                        r_arch, NULL, 0, ptr,-1,
1159                                        detect_cycle || sub_type->cycle));
1160         ptr += elm_size;
1161       }
1162     }
1163     break;
1164   }
1165         
1166   default:
1167     xbt_assert0(0, "Invalid type");
1168   }
1169   
1170   if (type->recv)
1171     type->recv(state,l_data);
1172
1173   return no_error;
1174 }
1175
1176 /**
1177  * gras_datadesc_gen_recv:
1178  *
1179  * Get an instance of the datatype described by @type from the @socket, 
1180  * and store a pointer to it in @dst
1181  *
1182  */
1183 xbt_error_t
1184 gras_datadesc_gen_recv(gras_socket_t         sock, 
1185                        gras_datadesc_type_t  type,
1186                        int                   r_arch,
1187                        void                 *dst) {
1188
1189   xbt_error_t errcode;
1190   gras_cbps_t  state; /* callback persistent state */
1191   xbt_dict_t  refs;  /* all references already sent */
1192
1193   refs = xbt_dict_new();
1194   state = gras_cbps_new();
1195
1196   printf("xbt_error_t gras_%s_recv(gras_socket_t sock,void *dst){\n",
1197          type->name);
1198    
1199   errcode = gras_datadesc_gen_recv_rec(sock, state, refs, type, 
1200                                        r_arch, NULL, 0,
1201                                        (char *) dst,-1, 
1202                                        type->cycle);
1203
1204   printf("}\n");
1205   xbt_dict_free(&refs);
1206   gras_cbps_free(&state);
1207
1208   return errcode;
1209 }
1210 #endif