X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/25d6952dcf52e6ffc1e4a402af0e2d3c17ac3935..7d0c4c0adbba2982f29444f00d1e70ad6b6aacdf:/src/gras/DataDesc/ddt_exchange.c

diff --git a/src/gras/DataDesc/ddt_exchange.c b/src/gras/DataDesc/ddt_exchange.c
index 8f57a97391..3f3015f013 100644
--- a/src/gras/DataDesc/ddt_exchange.c
+++ b/src/gras/DataDesc/ddt_exchange.c
@@ -11,9 +11,9 @@
 
 #include "xbt/ex.h"
 #include "gras/DataDesc/datadesc_private.h"
-#include "gras/Transport/transport_interface.h" /* gras_trp_chunk_send/recv */
+#include "gras/Transport/transport_interface.h" /* gras_trp_send/recv */
 
-XBT_LOG_NEW_DEFAULT_SUBCATEGORY(ddt_exchange,datadesc,
+XBT_LOG_NEW_DEFAULT_SUBCATEGORY(gras_ddt_exchange,gras_ddt,
 				 "Sending data over the network");
 const char *gras_datadesc_cat_names[9] = { 
   "undefined", 
@@ -22,30 +22,20 @@ const char *gras_datadesc_cat_names[9] = {
 
 static gras_datadesc_type_t int_type = NULL;
 static gras_datadesc_type_t pointer_type = NULL;    
-static _XBT_INLINE void gras_dd_send_int(gras_socket_t sock,             int  i);
-static _XBT_INLINE void gras_dd_recv_int(gras_socket_t sock, int r_arch, int *i);
 
-static _XBT_INLINE void
-gras_dd_alloc_ref(xbt_dict_t  refs,  long int     size,
-		  char       **r_ref, long int     r_len,
-		  char	     **l_ref, int detect_cycle);
-
-static _XBT_INLINE int
-gras_dd_is_r_null(char **r_ptr, long int length);
-
-static _XBT_INLINE void
-gras_dd_send_int(gras_socket_t sock,int i) {
+static XBT_INLINE void
+gras_dd_send_int(gras_socket_t sock,int *i, int stable) {
 
   if (!int_type) {
     int_type = gras_datadesc_by_name("int");
      xbt_assert(int_type);  
   }
    
-  DEBUG1("send_int(%d)",i);
-  gras_trp_chunk_send(sock, (char*)&i, int_type->size[GRAS_THISARCH]);
+  DEBUG1("send_int(%d)",*i);
+  gras_trp_send(sock, (char*)i, int_type->size[GRAS_THISARCH], stable);
 }
 
-static _XBT_INLINE void
+static XBT_INLINE void
 gras_dd_recv_int(gras_socket_t sock, int r_arch, int *i) {
 
   if (!int_type) {
@@ -54,13 +44,13 @@ gras_dd_recv_int(gras_socket_t sock, int r_arch, int *i) {
   }
 
   if (int_type->size[GRAS_THISARCH] >= int_type->size[r_arch]) {
-    gras_trp_chunk_recv(sock, (char*)i, int_type->size[r_arch]);
+    gras_trp_recv(sock, (char*)i, int_type->size[r_arch]);
     if (r_arch != GRAS_THISARCH)
       gras_dd_convert_elm(int_type,1,r_arch, i,i);
   } else {
     void *ptr = xbt_malloc(int_type->size[r_arch]);
 
-    gras_trp_chunk_recv(sock, (char*)ptr, int_type->size[r_arch]);
+    gras_trp_recv(sock, (char*)ptr, int_type->size[r_arch]);
     if (r_arch != GRAS_THISARCH)
       gras_dd_convert_elm(int_type,1,r_arch, ptr,i);
     free(ptr);
@@ -73,7 +63,7 @@ gras_dd_recv_int(gras_socket_t sock, int r_arch, int *i) {
  *       of 'length' bytes set to 0.
  * FIXME: Check in configure?
  */
-static _XBT_INLINE int 
+static XBT_INLINE int 
 gras_dd_is_r_null(char **r_ptr, long int length) {
   int i;
 
@@ -86,7 +76,7 @@ gras_dd_is_r_null(char **r_ptr, long int length) {
   return 1;
 }
 
-static _XBT_INLINE void
+static XBT_INLINE void
 gras_dd_alloc_ref(xbt_dict_t  refs,
 		  long int     size,
 		  char       **r_ref,
@@ -105,27 +95,301 @@ gras_dd_alloc_ref(xbt_dict_t  refs,
   if (detect_cycle && r_ref && !gras_dd_is_r_null( r_ref, r_len)) {
     void *ptr = xbt_malloc(sizeof(void *));
 
-    CRITICAL0("Check for cycles");
     memcpy(ptr,l_ref, sizeof(void *));
 
     DEBUG2("Insert l_ref=%p under r_ref=%p",*(void**)ptr, *(void**)r_ref);
-
+     
     if (detect_cycle)
-       xbt_dict_set_ext(refs,(const char *) r_ref, r_len, ptr, free);
+       xbt_dict_set_ext(refs,(const char *) r_ref, r_len, ptr, xbt_free_f);
   }
 }
 
+static int
+gras_datadesc_memcpy_rec(gras_cbps_t           state,
+		       xbt_dict_t            refs,
+		       gras_datadesc_type_t  type, 
+		       char                 *src,
+		       char                 *dst,
+		       int                   subsize,
+		       int                   detect_cycle) {
+
+
+  xbt_ex_t             e;
+  int                  cpt;
+  gras_datadesc_type_t sub_type; /* type on which we recurse */
+  int count = 0;
+
+  VERB4("Copy a %s (%s) from %p to %p", 
+	type->name, gras_datadesc_cat_names[type->category_code],
+	src,dst);	
+   
+  if (type->send) {
+    type->send(type,state,src);
+  }
+
+  switch (type->category_code) {
+  case e_gras_datadesc_type_cat_scalar:
+    memcpy(dst,src,type->size[GRAS_THISARCH]);
+    count += type->size[GRAS_THISARCH];
+    break;
+
+  case e_gras_datadesc_type_cat_struct: {
+    gras_dd_cat_struct_t struct_data;
+    gras_dd_cat_field_t  field;
+    char                *field_src;
+    char                *field_dst;
+    
+    struct_data = type->category.struct_data;
+    xbt_assert1(struct_data.closed,
+      "Please call gras_datadesc_declare_struct_close on %s before copying it",
+		type->name);
+    VERB1(">> Copy all fields of the structure %s",type->name);
+    xbt_dynar_foreach(struct_data.fields, cpt, field) {
+      field_src = src + field->offset[GRAS_THISARCH];
+      field_dst = dst + field->offset[GRAS_THISARCH];
+      
+      sub_type = field->type;
+      
+      if (field->send)
+	field->send(type,state,field_src);
+      
+      DEBUG1("Copy field %s",field->name);
+      count += gras_datadesc_memcpy_rec(state,refs,sub_type, field_src, field_dst, 0,
+				      detect_cycle || sub_type->cycle);
+       
+       if (XBT_LOG_ISENABLED(gras_ddt_exchange,xbt_log_priority_verbose)) {
+	  if (sub_type == gras_datadesc_by_name("unsigned int")) {
+	     VERB2("Copied value for field '%s': %d (type: unsigned int)",field->name, *(unsigned int*)field_dst);
+	  } else if (sub_type == gras_datadesc_by_name("int")) {
+	     VERB2("Copied value for field '%s': %d (type: int)",field->name, *(int*)field_dst);
+	     
+	  } else if (sub_type == gras_datadesc_by_name("unsigned long int")) {
+	     VERB2("Copied value for field '%s': %ld (type: unsigned long int)",field->name, *(unsigned long int*)field_dst);
+	  } else if (sub_type == gras_datadesc_by_name("long int")) {
+	     VERB2("Copied value for field '%s': %ld (type: long int)",field->name, *(long int*)field_dst);
+
+	  } else if (sub_type == gras_datadesc_by_name("string")) {
+	     VERB2("Copied value for field '%s': '%s' (type: string)", field->name, *(char**)field_dst);	 
+	  } else {
+	     VERB1("Copied a value for field '%s' (type not scalar?)", field->name);
+	  }
+       }
+      
+    }
+    VERB1("<< Copied all fields of the structure %s", type->name);
+    
+    break;
+  }
+
+  case e_gras_datadesc_type_cat_union: {
+    gras_dd_cat_union_t union_data;
+    gras_dd_cat_field_t field=NULL;
+    int                 field_num;
+    
+    union_data = type->category.union_data;
+    
+    xbt_assert1(union_data.closed,
+		"Please call gras_datadesc_declare_union_close on %s before copying it",
+		type->name);
+    /* retrieve the field number */
+    field_num = union_data.selector(type, state, src);
+    
+    xbt_assert1(field_num > 0,
+		"union field selector of %s gave a negative value", 
+		type->name);
+    
+    xbt_assert3(field_num < (int)xbt_dynar_length(union_data.fields),
+	 "union field selector of %s returned %d but there is only %lu fields",
+		 type->name, field_num, xbt_dynar_length(union_data.fields));
+    
+    /* Copy the content */
+    field = xbt_dynar_get_as(union_data.fields, field_num, gras_dd_cat_field_t);
+    sub_type = field->type;
+    
+    if (field->send)
+      field->send(type,state,src);
+    
+    count += gras_datadesc_memcpy_rec(state,refs, sub_type, src, dst,0,
+				    detect_cycle || sub_type->cycle);
+          
+    break;
+  }
+    
+  case e_gras_datadesc_type_cat_ref: {
+    gras_dd_cat_ref_t      ref_data;
+    char                 **o_ref=NULL;
+    char                 **n_ref=NULL;
+    int                    reference_is_to_cpy;
+    
+    ref_data = type->category.ref_data;
+    
+    /* Detect the referenced type */
+    sub_type = ref_data.type;
+    if (sub_type == NULL) {
+      sub_type = (*ref_data.selector)(type,state,src);
+    }
+    
+    /* Send the pointed data only if not already sent */
+    if (*(void**)src == NULL) {
+      VERB0("Not copying NULL referenced data");
+      *(void**)dst = NULL;
+      break;
+    }
+    o_ref=(char**)src;
+
+    reference_is_to_cpy = 0;
+    TRY {
+      if (detect_cycle) {
+	/* return ignored. Just checking whether it's known or not */
+	n_ref=xbt_dict_get_ext(refs,(char*)o_ref, sizeof(char*));
+      } else {
+	reference_is_to_cpy = 1;
+      }
+    } CATCH(e) {
+      if (e.category != not_found_error)
+	RETHROW;
+      reference_is_to_cpy = 1;
+      xbt_ex_free(e);
+    }
+
+    if (reference_is_to_cpy) {
+      int subsubcount = 0;
+      void *l_referenced=NULL;
+       VERB2("Copy a ref to '%s' referenced at %p",sub_type->name, (void*)*o_ref);
+       
+       if (!pointer_type) { 
+	 pointer_type = gras_datadesc_by_name("data pointer");
+	 xbt_assert(pointer_type);
+       }
+
+       if (sub_type->category_code == e_gras_datadesc_type_cat_array) {
+	 /* Damn. Reference to a dynamic array. Allocating the space for it 
+	    is more complicated */
+	 gras_dd_cat_array_t array_data = sub_type->category.array_data;
+	 gras_datadesc_type_t subsub_type;
+	 
+	 subsub_type = array_data.type;
+	 subsubcount = array_data.fixed_size;
+	 if (subsubcount == 0)
+	   subsubcount = array_data.dynamic_size(subsub_type,state,*o_ref);
+	 
+	 gras_dd_alloc_ref(refs,
+			   subsub_type->size[GRAS_THISARCH] * subsubcount, 
+			   o_ref,pointer_type->size[GRAS_THISARCH], 
+			   (char**)&l_referenced,
+			   detect_cycle);
+       } else {
+	 gras_dd_alloc_ref(refs,sub_type->size[GRAS_THISARCH], 
+			   o_ref,pointer_type->size[GRAS_THISARCH], 
+			   (char**)&l_referenced,
+			   detect_cycle);
+       }
+       
+       count += gras_datadesc_memcpy_rec(state,refs, sub_type,
+				       *o_ref,(char*)l_referenced, subsubcount,
+				       detect_cycle || sub_type->cycle);
+			       
+       *(void**)dst=l_referenced;
+       VERB3("'%s' previously referenced at %p now at %p",
+	     sub_type->name, *(void**)o_ref, l_referenced);
+       
+    } else {
+      VERB2("NOT copying data previously referenced @%p (already done, @%p now)",
+	    *(void**)o_ref, *(void**)n_ref);
+      
+      *(void**)dst=*n_ref;
+      
+    } 
+    break;
+  }
+
+  case e_gras_datadesc_type_cat_array: {
+    gras_dd_cat_array_t    array_data;
+    long int               array_count;
+    char                  *src_ptr=src;
+    char                  *dst_ptr=dst;
+    long int               elm_size;
+    
+    array_data = type->category.array_data;
+    
+    /* determine and send the element count */
+    array_count = array_data.fixed_size;
+    if (array_count == 0)
+      array_count = subsize;
+    if (array_count == 0) {
+      array_count = array_data.dynamic_size(type,state,src);
+      xbt_assert1(array_count >=0,
+		   "Invalid (negative) array size for type %s",type->name);
+    }
+    
+    /* send the content */
+    sub_type = array_data.type;
+    elm_size = sub_type->aligned_size[GRAS_THISARCH];
+    if (sub_type->category_code == e_gras_datadesc_type_cat_scalar) {
+      VERB1("Array of %ld scalars, copy it in one shot",array_count);
+      memcpy(dst, src, sub_type->aligned_size[GRAS_THISARCH] * array_count);
+      count += sub_type->aligned_size[GRAS_THISARCH] * array_count;
+    } else if (sub_type->category_code == e_gras_datadesc_type_cat_array &&
+	       sub_type->category.array_data.fixed_size > 0 &&
+	       sub_type->category.array_data.type->category_code == e_gras_datadesc_type_cat_scalar) {
+       
+      VERB1("Array of %ld fixed array of scalars, copy it in one shot",
+	    array_count);
+      memcpy(dst,src,sub_type->category.array_data.type->aligned_size[GRAS_THISARCH] 
+		     * array_count * sub_type->category.array_data.fixed_size);
+      count += sub_type->category.array_data.type->aligned_size[GRAS_THISARCH] 
+	       * array_count * sub_type->category.array_data.fixed_size;
+       
+    } else {
+      VERB1("Array of %ld stuff, copy it in one after the other",array_count);
+      for (cpt=0; cpt<array_count; cpt++) {
+	VERB2("Copy the %dth stuff out of %ld",cpt,array_count);
+	count += gras_datadesc_memcpy_rec(state,refs, sub_type, src_ptr, dst_ptr, 0,
+					detect_cycle || sub_type->cycle);
+	src_ptr += elm_size;
+	dst_ptr += elm_size;
+      }
+    }
+    break;
+  }
+
+  default:
+    xbt_assert0(0, "Invalid type");
+  }
+   
+  return count;
+}
 /**
- * gras_datadesc_cpy:
+ * gras_datadesc_memcpy:
  *
  * Copy the data pointed by src and described by type 
  * to a new location, and store a pointer to it in dst.
  *
  */
-void gras_datadesc_cpy(gras_datadesc_type_t type, 
-		       void *src, 
-		       void **dst) {
-  THROW_UNIMPLEMENTED;
+int gras_datadesc_memcpy(gras_datadesc_type_t type, 
+		       void *src, void *dst) {
+  xbt_ex_t e;
+  static gras_cbps_t state=NULL;
+  static xbt_dict_t  refs=NULL; /* all references already sent */
+  int size=0;
+ 
+  xbt_assert0(type,"called with NULL type descriptor");
+
+  if (!state) {
+    state = gras_cbps_new();
+    refs = xbt_dict_new();
+  }
+  
+  TRY {
+    size = gras_datadesc_memcpy_rec(state,refs,type,(char*)src,(char*)dst,0, 
+				    type->cycle);
+  } CLEANUP {
+    xbt_dict_reset(refs);
+    gras_cbps_reset(state);
+  } CATCH(e) {
+    RETHROW;
+  }
+  return size;
 }
 
 /***
@@ -135,7 +399,7 @@ void gras_datadesc_cpy(gras_datadesc_type_t type,
 static void
 gras_datadesc_send_rec(gras_socket_t         sock,
 		       gras_cbps_t           state,
-		       xbt_dict_t           refs,
+		       xbt_dict_t            refs,
 		       gras_datadesc_type_t  type, 
 		       char                 *data,
 		       int                   detect_cycle) {
@@ -147,13 +411,17 @@ gras_datadesc_send_rec(gras_socket_t         sock,
   VERB2("Send a %s (%s)", 
 	type->name, gras_datadesc_cat_names[type->category_code]);
 
+  if (!strcmp(type->name,"string"))
+    VERB1("value: '%s'",*(char**)data);
+
   if (type->send) {
     type->send(type,state,data);
+    DEBUG0("Run the emission callback");
   }
 
   switch (type->category_code) {
   case e_gras_datadesc_type_cat_scalar:
-    gras_trp_chunk_send(sock, data, type->size[GRAS_THISARCH]);
+    gras_trp_send(sock, data, type->size[GRAS_THISARCH], 1);
     break;
 
   case e_gras_datadesc_type_cat_struct: {
@@ -172,8 +440,10 @@ gras_datadesc_send_rec(gras_socket_t         sock,
       
       sub_type = field->type;
       
-      if (field->send)
+      if (field->send) {
+	DEBUG1("Run the emission callback of field %s", field->name);
 	field->send(type,state,field_data);
+      }
       
       VERB1("Send field %s",field->name);
       gras_datadesc_send_rec(sock,state,refs,sub_type, field_data, 
@@ -202,12 +472,12 @@ gras_datadesc_send_rec(gras_socket_t         sock,
 		 "union field selector of %s gave a negative value", 
 		 type->name);
     
-    xbt_assert3(field_num < xbt_dynar_length(union_data.fields),
+    xbt_assert3(field_num < (int)xbt_dynar_length(union_data.fields),
 	 "union field selector of %s returned %d but there is only %lu fields",
 		 type->name, field_num, xbt_dynar_length(union_data.fields));
 
     /* Send the field number */
-    gras_dd_send_int(sock, field_num);
+    gras_dd_send_int(sock, &field_num, 0 /* not stable */);
     
     /* Send the content */
     field = xbt_dynar_get_as(union_data.fields, field_num, gras_dd_cat_field_t);
@@ -233,7 +503,7 @@ gras_datadesc_send_rec(gras_socket_t         sock,
     sub_type = ref_data.type;
     if (sub_type == NULL) {
       sub_type = (*ref_data.selector)(type,state,data);
-      gras_dd_send_int(sock, sub_type->code);
+      gras_dd_send_int(sock, (int*) &(sub_type->code),1 /*stable*/);
     }
     
     /* Send the actual value of the pointer for cycle handling */
@@ -242,8 +512,8 @@ gras_datadesc_send_rec(gras_socket_t         sock,
       xbt_assert(pointer_type);
     }
      
-    gras_trp_chunk_send(sock, (char*)data,
-			pointer_type->size[GRAS_THISARCH]);
+    gras_trp_send(sock, (char*)data,
+		  pointer_type->size[GRAS_THISARCH], 1 /*stable*/);
     
     /* Send the pointed data only if not already sent */
     if (*(void**)data == NULL) {
@@ -281,7 +551,7 @@ gras_datadesc_send_rec(gras_socket_t         sock,
 
   case e_gras_datadesc_type_cat_array: {
     gras_dd_cat_array_t    array_data;
-    long int               count;
+    int                    count;
     char                  *ptr=data;
     long int               elm_size;
     
@@ -293,24 +563,26 @@ gras_datadesc_send_rec(gras_socket_t         sock,
       count = array_data.dynamic_size(type,state,data);
       xbt_assert1(count >=0,
 		   "Invalid (negative) array size for type %s",type->name);
-      gras_dd_send_int(sock, count);
+      gras_dd_send_int(sock, &count, 0/*non-stable*/);
     }
     
     /* send the content */
     sub_type = array_data.type;
     elm_size = sub_type->aligned_size[GRAS_THISARCH];
     if (sub_type->category_code == e_gras_datadesc_type_cat_scalar) {
-      VERB1("Array of %ld scalars, send it in one shot",count);
-      gras_trp_chunk_send(sock, data, 
-			  sub_type->aligned_size[GRAS_THISARCH] * count);
+      VERB1("Array of %d scalars, send it in one shot",count);
+      gras_trp_send(sock, data, 
+		    sub_type->aligned_size[GRAS_THISARCH] * count,
+		    0 /* not stable */);
     } else if (sub_type->category_code == e_gras_datadesc_type_cat_array &&
 	       sub_type->category.array_data.fixed_size > 0 &&
 	       sub_type->category.array_data.type->category_code == e_gras_datadesc_type_cat_scalar) {
        
-      VERB1("Array of %ld fixed array of scalars, send it in one shot",count);
-      gras_trp_chunk_send(sock, data, 
-			  sub_type->category.array_data.type->aligned_size[GRAS_THISARCH] 
-			  * count * sub_type->category.array_data.fixed_size);
+      VERB1("Array of %d fixed array of scalars, send it in one shot",count);
+      gras_trp_send(sock, data, 
+		    sub_type->category.array_data.type->aligned_size[GRAS_THISARCH] 
+		    * count * sub_type->category.array_data.fixed_size,
+		    0 /* not stable */);
        
     } else {
       for (cpt=0; cpt<count; cpt++) {
@@ -338,19 +610,21 @@ void gras_datadesc_send(gras_socket_t        sock,
 			void *src) {
 
   xbt_ex_t e;
-  gras_cbps_t  state;
-  xbt_dict_t  refs; /* all references already sent */
+  static gras_cbps_t state=NULL;
+  static xbt_dict_t  refs=NULL; /* all references already sent */
  
   xbt_assert0(type,"called with NULL type descriptor");
 
-  refs = xbt_dict_new();
-  state = gras_cbps_new();
-  
+  if (!state) {
+    state = gras_cbps_new();
+    refs = xbt_dict_new();
+  }
+   
   TRY {
     gras_datadesc_send_rec(sock,state,refs,type,(char*)src, type->cycle);
   } CLEANUP {
-    xbt_dict_free(&refs);
-    gras_cbps_free(&state);
+    xbt_dict_reset(refs);
+    gras_cbps_reset(state);
   } CATCH(e) {
     RETHROW;
   }
@@ -390,13 +664,13 @@ gras_datadesc_recv_rec(gras_socket_t         sock,
   switch (type->category_code) {
   case e_gras_datadesc_type_cat_scalar:
     if (type->size[GRAS_THISARCH] == type->size[r_arch]) {
-      gras_trp_chunk_recv(sock, (char*)l_data, type->size[r_arch]);
+      gras_trp_recv(sock, (char*)l_data, type->size[r_arch]);
       if (r_arch != GRAS_THISARCH)
 	gras_dd_convert_elm(type,1,r_arch, l_data,l_data);
     } else {
       void *ptr = xbt_malloc(type->size[r_arch]);
 
-      gras_trp_chunk_recv(sock, (char*)ptr, type->size[r_arch]);
+      gras_trp_recv(sock, (char*)ptr, type->size[r_arch]);
       if (r_arch != GRAS_THISARCH)
 	gras_dd_convert_elm(type,1,r_arch, ptr,l_data);
       free(ptr);
@@ -423,8 +697,10 @@ gras_datadesc_recv_rec(gras_socket_t         sock,
 			     field_data,-1, 
 			     detect_cycle || sub_type->cycle);
        
-      if (field->recv)
+      if (field->recv) {
+	DEBUG1("Run the reception callback of field %s", field->name);
         field->recv(type,state,(void*)l_data);
+      }
     
     }
     VERB1("<< Received all fields of the structure %s", type->name);
@@ -447,7 +723,7 @@ gras_datadesc_recv_rec(gras_socket_t         sock,
     if (field_num < 0)
       THROW1(mismatch_error,0,
 	     "Received union field for %s is negative", type->name);
-    if (field_num < xbt_dynar_length(union_data.fields)) 
+    if (field_num > (int)xbt_dynar_length(union_data.fields)) 
       THROW3(mismatch_error,0,
 	     "Received union field for %s is said to be #%d but there is only %lu fields",
 	     type->name, field_num, xbt_dynar_length(union_data.fields));
@@ -490,8 +766,8 @@ gras_datadesc_recv_rec(gras_socket_t         sock,
 
     r_ref = xbt_malloc(pointer_type->size[r_arch]);
 
-    gras_trp_chunk_recv(sock, (char*)r_ref,
-			pointer_type->size[r_arch]);
+    gras_trp_recv(sock, (char*)r_ref,
+		  pointer_type->size[r_arch]);
 
     /* Receive the pointed data only if not already sent */
     if (gras_dd_is_r_null(r_ref, pointer_type->size[r_arch])) {
@@ -504,16 +780,18 @@ gras_datadesc_recv_rec(gras_socket_t         sock,
          
     reference_is_to_recv = 0;
     TRY {
-      if (detect_cycle)
+      if (detect_cycle) {
 	l_ref = xbt_dict_get_ext(refs, (char*)r_ref, pointer_type->size[r_arch]);
-      else 
+      } else {
 	reference_is_to_recv = 1;
+      }
     } CATCH(e) {
       if (e.category != not_found_error)
         RETHROW;
       reference_is_to_recv = 1;
       xbt_ex_free(e);
     }
+
     if (reference_is_to_recv) {
       int subsubcount = 0;
       void *l_referenced=NULL;
@@ -588,15 +866,15 @@ gras_datadesc_recv_rec(gras_socket_t         sock,
       VERB1("Array of %d scalars, get it in one shoot", count);
       if (sub_type->aligned_size[GRAS_THISARCH] >= 
 	  sub_type->aligned_size[r_arch]) {
-	gras_trp_chunk_recv(sock, (char*)l_data, 
-			    sub_type->aligned_size[r_arch] * count);
+	gras_trp_recv(sock, (char*)l_data, 
+		      sub_type->aligned_size[r_arch] * count);
 	if (r_arch != GRAS_THISARCH)
 	  gras_dd_convert_elm(sub_type,count,r_arch, l_data,l_data);
       } else {
 	ptr = xbt_malloc(sub_type->aligned_size[r_arch] * count);
 
-	gras_trp_chunk_recv(sock, (char*)ptr, 
-			    sub_type->size[r_arch] * count);
+	gras_trp_recv(sock, (char*)ptr, 
+		      sub_type->size[r_arch] * count);
 	if (r_arch != GRAS_THISARCH)
 	  gras_dd_convert_elm(sub_type,count,r_arch, ptr,l_data);
 	free(ptr);
@@ -611,16 +889,16 @@ gras_datadesc_recv_rec(gras_socket_t         sock,
       VERB1("Array of %d fixed array of scalars, get it in one shot",count);
       if (subsub_type->aligned_size[GRAS_THISARCH] >= 
 	  subsub_type->aligned_size[r_arch]) {
-	gras_trp_chunk_recv(sock, (char*)l_data, 
-			    subsub_type->aligned_size[r_arch] * count * 
-			    array_data.fixed_size);
+	gras_trp_recv(sock, (char*)l_data, 
+		      subsub_type->aligned_size[r_arch] * count * 
+		      array_data.fixed_size);
 	if (r_arch != GRAS_THISARCH)
 	  gras_dd_convert_elm(subsub_type,count*array_data.fixed_size,r_arch, l_data,l_data);
       } else {
 	ptr = xbt_malloc(subsub_type->aligned_size[r_arch] * count*array_data.fixed_size);
 
-	gras_trp_chunk_recv(sock, (char*)ptr, 
-			    subsub_type->size[r_arch] * count*array_data.fixed_size);
+	gras_trp_recv(sock, (char*)ptr, 
+		      subsub_type->size[r_arch] * count*array_data.fixed_size);
 	if (r_arch != GRAS_THISARCH)
 	  gras_dd_convert_elm(subsub_type,count*array_data.fixed_size,r_arch, ptr,l_data);
 	free(ptr);
@@ -651,6 +929,9 @@ gras_datadesc_recv_rec(gras_socket_t         sock,
   if (type->recv)
     type->recv(type,state,l_data);
 
+  if (!strcmp(type->name,"string"))
+    VERB1("value: '%s'",*(char**)l_data);
+
 }
 
 /**
@@ -667,12 +948,14 @@ gras_datadesc_recv(gras_socket_t         sock,
 		   void                 *dst) {
 
   xbt_ex_t e;
-  gras_cbps_t  state; /* callback persistent state */
-  xbt_dict_t  refs;  /* all references already sent */
-
-  refs = xbt_dict_new();
-  state = gras_cbps_new();
+  static gras_cbps_t state=NULL; /* callback persistent state */
+  static xbt_dict_t  refs=NULL;  /* all references already sent */
 
+  if (!state) {
+    state = gras_cbps_new();
+    refs = xbt_dict_new();
+  }
+   
   xbt_assert0(type,"called with NULL type descriptor");
   TRY {
     gras_datadesc_recv_rec(sock, state, refs, type, 
@@ -680,8 +963,8 @@ gras_datadesc_recv(gras_socket_t         sock,
 			   (char *) dst,-1, 
 			   type->cycle);
   } CLEANUP {
-    xbt_dict_free(&refs);
-    gras_cbps_free(&state);
+    xbt_dict_reset(refs);
+    gras_cbps_reset(state);
   } CATCH(e) {
     RETHROW;
   }