X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/e2577d0360f31128b87c748dc9a3253b2ed87727..704a0f5dead4ac665eb65bdd686d0bfab8d52f83:/src/gras/DataDesc/ddt_exchange.c diff --git a/src/gras/DataDesc/ddt_exchange.c b/src/gras/DataDesc/ddt_exchange.c index f9304d6dde..3727964ea1 100644 --- a/src/gras/DataDesc/ddt_exchange.c +++ b/src/gras/DataDesc/ddt_exchange.c @@ -12,7 +12,7 @@ GRAS_LOG_NEW_DEFAULT_SUBCATEGORY(exchange,DataDesc); -static const char *gras_datadesc_cat_names[9] = { +const char *gras_datadesc_cat_names[9] = { "undefined", "scalar", "struct", "union", "ref", "array", "ignored", "invalid"}; @@ -43,7 +43,8 @@ gras_datadesc_recv_rec(gras_socket_t *sock, int r_arch, char **r_data, long int r_lgr, - char **dst); + char *dst, + int subsize); static gras_error_t @@ -122,12 +123,12 @@ gras_dd_alloc_ref(gras_dict_t *refs, void *ptr = malloc(sizeof(void *)); if (!ptr) RAISE_MALLOC; - // memcpy(ptr,&l_data, sizeof(void *)); + memcpy(ptr,l_ref, sizeof(void *)); DEBUG2("Insert %p under %p",*(void**)ptr, *(void**)r_ref); - /* FIXME: Leaking on the ptr. Do I really need to copy it? */ - TRY(gras_dict_set_ext(refs,(const char *) r_ref, r_len, ptr, NULL)); + + TRY(gras_dict_set_ext(refs,(const char *) r_ref, r_len, ptr, free)); } return no_error; } @@ -146,25 +147,62 @@ int gras_datadesc_type_cmp(const gras_datadesc_type_t *d1, gras_dd_cat_field_t *field1,*field2; gras_datadesc_type_t *field_desc_1,*field_desc_2; + if (d1 == d2) return 0; /* easy optimization */ - if (!d1 && d2) return 1; - if (!d1 && !d2) return 0; - if ( d1 && !d2) return -1; + if (!d1 && d2) { + DEBUG0("ddt_cmp: !d1 && d2 => 1"); + return 1; + } + if (!d1 && !d2) { + DEBUG0("ddt_cmp: !d1 && !d2 => 0"); + return 0; + } + if ( d1 && !d2) { + DEBUG0("ddt_cmp: d1 && !d2 => -1"); + return -1; + } - if (d1->size != d2->size ) - return d1->size > d2->size ? 1 : -1; - if (d1->alignment != d2->alignment) - return d1->alignment > d2->alignment ? 1 : -1; - if (d1->aligned_size != d2->aligned_size) - return d1->aligned_size > d2->aligned_size ? 1 : -1; + for (cpt=0; cptsize[cpt] != d2->size[cpt]) { + DEBUG5("ddt_cmp: %s->size=%d != %s->size=%d (on %s)", + d1->name,d1->size[cpt],d2->name,d2->size[cpt], + gras_arches[cpt].name); + return d1->size[cpt] > d2->size[cpt] ? 1 : -1; + } - if (d1->category_code != d2->category_code) - return d1->category_code > d2->category_code ? 1 : -1; + if (d1->alignment[cpt] != d2->alignment[cpt]) { + DEBUG5("ddt_cmp: %s->alignment=%d != %s->alignment=%d (on %s)", + d1->name,d1->alignment[cpt],d2->name,d2->alignment[cpt], + gras_arches[cpt].name); + return d1->alignment[cpt] > d2->alignment[cpt] ? 1 : -1; + } - if (d1->pre != d2->pre) - return d1->pre > d2->pre ? 1 : -1; - if (d1->post != d2->post) - return d1->post > d2->post ? 1 : -1; + if (d1->aligned_size[cpt] != d2->aligned_size[cpt]) { + DEBUG5("ddt_cmp: %s->aligned_size=%d != %s->aligned_size=%d (on %s)", + d1->name,d1->aligned_size[cpt],d2->name,d2->aligned_size[cpt], + gras_arches[cpt].name); + return d1->aligned_size[cpt] > d2->aligned_size[cpt] ? 1 : -1; + } + } + + if (d1->category_code != d2->category_code) { + DEBUG4("ddt_cmp: %s->cat=%s != %s->cat=%s", + d1->name,gras_datadesc_cat_names[d1->category_code], + d2->name,gras_datadesc_cat_names[d2->category_code]); + return d1->category_code > d2->category_code ? 1 : -1; + } + + if (d1->pre != d2->pre) { + DEBUG4("ddt_cmp: %s->pre=%p != %s->pre=%p", + d1->name,d1->pre, d2->name,d2->pre); + return d1->pre > d2->pre ? 1 : -1; + } + + if (d1->post != d2->post) { + DEBUG4("ddt_cmp: %s->post=%p != %s->post=%p", + d1->name,d1->post, d2->name,d2->post); + return d1->post > d2->post ? 1 : -1; + } switch (d1->category_code) { case e_gras_datadesc_type_cat_scalar: @@ -174,19 +212,27 @@ int gras_datadesc_type_cmp(const gras_datadesc_type_t *d1, case e_gras_datadesc_type_cat_struct: if (gras_dynar_length(d1->category.struct_data.fields) != - gras_dynar_length(d2->category.struct_data.fields)) + gras_dynar_length(d2->category.struct_data.fields)) { + DEBUG4("ddt_cmp: %s (having %d fields) != %s (having %d fields)", + d1->name, gras_dynar_length(d1->category.struct_data.fields), + d2->name, gras_dynar_length(d2->category.struct_data.fields)); + return gras_dynar_length(d1->category.struct_data.fields) > gras_dynar_length(d2->category.struct_data.fields) ? 1 : -1; - + } gras_dynar_foreach(d1->category.struct_data.fields, cpt, field1) { - gras_dynar_get(d2->category.struct_data.fields, cpt, field2); + gras_dynar_get(d2->category.struct_data.fields, cpt, &field2); gras_datadesc_by_id(field1->code,&field_desc_1); /* FIXME: errcode ignored */ gras_datadesc_by_id(field2->code,&field_desc_2); ret = gras_datadesc_type_cmp(field_desc_1,field_desc_2); - if (ret) + if (ret) { + DEBUG6("%s->field[%d]=%s != %s->field[%d]=%s", + d1->name,cpt,field1->name, + d2->name,cpt,field2->name); return ret; + } } break; @@ -455,6 +501,13 @@ gras_error_t gras_datadesc_send(gras_socket_t *sock, * gras_datadesc_recv_rec: * * Do the data reception job recursively. + * + * subsize used only to deal with vicious case of reference to dynamic array. + * This size is needed at the reference reception level (to allocate enough + * space) and at the array reception level (to fill enough room). + * + * Having this size passed as an argument of the recursive function is a crude + * hack, but I was told that working code is sometimes better than neat one ;) */ gras_error_t gras_datadesc_recv_rec(gras_socket_t *sock, @@ -464,22 +517,18 @@ gras_datadesc_recv_rec(gras_socket_t *sock, int r_arch, char **r_data, long int r_lgr, - char **dst) { + char *l_data, + int subsize) { gras_error_t errcode; - char *l_data = *dst; /* dereference to avoid typo */ int cpt; gras_datadesc_type_t *sub_type; - VERB1("Recv a %s", type->name); + VERB2("Recv a %s @%p", type->name, l_data); + gras_assert(l_data); switch (type->category_code) { case e_gras_datadesc_type_cat_scalar: - if (!l_data) { - TRY(gras_dd_alloc_ref(refs,type->size[GRAS_THISARCH],r_data,r_lgr, dst)); - l_data = *dst; - } - if (type->size[GRAS_THISARCH] >= type->size[r_arch]) { TRY(gras_trp_chunk_recv(sock, (char*)l_data, type->size[r_arch])); TRY(gras_dd_convert_elm(type,r_arch, l_data,l_data)); @@ -498,11 +547,6 @@ gras_datadesc_recv_rec(gras_socket_t *sock, struct_data = type->category.struct_data; - if (!l_data) { - TRY(gras_dd_alloc_ref(refs,type->size[GRAS_THISARCH],r_data,r_lgr, dst)); - l_data = *dst; - } - VERB1(">> Receive all fields of the structure %s",type->name); gras_dynar_foreach(struct_data.fields, cpt, field) { char *field_data = l_data + field->offset[GRAS_THISARCH]; @@ -511,7 +555,7 @@ gras_datadesc_recv_rec(gras_socket_t *sock, TRY(gras_datadesc_recv_rec(sock,state,refs, sub_type, r_arch,NULL,0, - &field_data)); + field_data,-1)); } VERB1("<< Received all fields of the structure %s", type->name); @@ -525,11 +569,6 @@ gras_datadesc_recv_rec(gras_socket_t *sock, union_data = type->category.union_data; - if (!l_data) { - TRY(gras_dd_alloc_ref(refs,type->size[GRAS_THISARCH],r_data,r_lgr, dst)); - l_data = *dst; - } - /* retrieve the field number */ TRY(gras_dd_recv_int(sock, r_arch, &field_num)); if (field_num < 0) @@ -546,7 +585,7 @@ gras_datadesc_recv_rec(gras_socket_t *sock, TRY(gras_datadesc_recv_rec(sock,state,refs, sub_type, r_arch,NULL,0, - dst)); + l_data,-1)); break; } @@ -574,16 +613,12 @@ gras_datadesc_recv_rec(gras_socket_t *sock, TRY(gras_trp_chunk_recv(sock, (char*)r_ref, pointer_type->size[r_arch])); - if (!l_data) { - TRY(gras_dd_alloc_ref(refs,type->size[GRAS_THISARCH],r_data,r_lgr, dst)); - l_data = *dst; - } - /* Receive the pointed data only if not already sent */ if (gras_dd_is_r_null(r_ref, pointer_type->size[r_arch])) { - VERB1("Not receiving data remotely referenced at %p since it's NULL", + VERB1("Not receiving data remotely referenced @%p since it's NULL", *(void **)r_ref); *(void**)l_data = NULL; + free(r_ref); break; } errcode = gras_dict_get_ext(refs, @@ -592,28 +627,53 @@ gras_datadesc_recv_rec(gras_socket_t *sock, if (errcode == mismatch_error) { + int subsubcount = -1; void *l_referenced=NULL; - VERB1("Receiving data remotely referenced at %p", *(void**)r_ref); TRY(gras_datadesc_by_id(ref_code, &sub_type)); - // DEBUG2("l_ref= %p; &l_ref=%p",l_referenced,&l_referenced); + + VERB2("Receiving a ref to '%s', remotely @%p", + sub_type->name, *(void**)r_ref); + if (sub_type->category_code == e_gras_datadesc_type_cat_array) { + /* Damn. Reference to a dynamic array. Allocating the size for it + is more complicated */ + gras_dd_cat_array_t array_data = sub_type->category.array_data; + gras_datadesc_type_t *subsub_type; + + subsubcount = array_data.fixed_size; + if (subsubcount < 0) + TRY(gras_dd_recv_int(sock, r_arch, &subsubcount)); + + TRY(gras_datadesc_by_id(array_data.code, &subsub_type)); + + + TRY(gras_dd_alloc_ref(refs, + subsub_type->size[GRAS_THISARCH] * subsubcount, + r_ref,pointer_type->size[r_arch], + (char**)&l_referenced)); + } else { + TRY(gras_dd_alloc_ref(refs,sub_type->size[GRAS_THISARCH], + r_ref,pointer_type->size[r_arch], + (char**)&l_referenced)); + } + TRY(gras_datadesc_recv_rec(sock,state,refs, sub_type, r_arch,r_ref,pointer_type->size[r_arch], - (char**)&l_referenced)); + (char*)l_referenced, subsubcount)); *(void**)l_data=l_referenced; + VERB3("'%s' remotely referenced at %p locally at %p", + sub_type->name, *(void**)r_ref, l_referenced); } else if (errcode == no_error) { - VERB1("NOT receiving data remotely referenced at %p (already done). ", - *(void**)r_ref); - - VERB2("l_ref=%p; *l_ref=%p", l_ref,*l_ref); + VERB2("NOT receiving data remotely referenced @%p (already done, @%p here)", + *(void**)r_ref, *(void**)l_ref); *(void**)l_data=*l_ref; } else { return errcode; } - VERB1("*l_data=%p",*(void**)l_data); + free(r_ref); break; } @@ -624,8 +684,10 @@ gras_datadesc_recv_rec(gras_socket_t *sock, long int elm_size; array_data = type->category.array_data; - /* determine element count locally or from peer */ + /* determine element count locally, or from caller, or from peer */ count = array_data.fixed_size; + if (count <= 0) + count = subsize; if (count <= 0) TRY(gras_dd_recv_int(sock, r_arch, &count)); if (count < 0) @@ -635,16 +697,12 @@ gras_datadesc_recv_rec(gras_socket_t *sock, /* receive the content */ TRY(gras_datadesc_by_id(array_data.code, &sub_type)); elm_size = sub_type->aligned_size[GRAS_THISARCH]; - - if (!l_data) { - TRY(gras_dd_alloc_ref(refs,elm_size*count,r_data,r_lgr, dst)); - l_data = *dst; - } + VERB2("Receive a %d-long array of %s",count, sub_type->name); ptr = l_data; for (cpt=0; cpt