X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/9089ba6d1c093456af4b2ba8015599f94f39f797..60f31f9d24bd348ccad2ea99ba96424360b11a92:/src/gras/DataDesc/ddt_create.c diff --git a/src/gras/DataDesc/ddt_create.c b/src/gras/DataDesc/ddt_create.c index 415a05c260..a4bb66b362 100644 --- a/src/gras/DataDesc/ddt_create.c +++ b/src/gras/DataDesc/ddt_create.c @@ -10,7 +10,7 @@ #include "DataDesc/datadesc_private.h" -GRAS_LOG_NEW_DEFAULT_SUBCATEGORY(new,datadesc); +GRAS_LOG_NEW_DEFAULT_SUBCATEGORY(ddt_create,datadesc); /** * gras_ddt_freev: @@ -21,17 +21,17 @@ void gras_ddt_freev(void *ddt) { gras_datadesc_type_t *type= (gras_datadesc_type_t *)ddt; if (type) { - gras_datadesc_unref(type); + gras_datadesc_free(type); } } static gras_error_t gras_ddt_new(const char *name, gras_datadesc_type_t **dst) { - gras_error_t errcode; gras_datadesc_type_t *res; + GRAS_IN1("(%s)",name); res=malloc(sizeof(gras_datadesc_type_t)); if (!res) RAISE_MALLOC; @@ -39,12 +39,11 @@ gras_ddt_new(const char *name, memset(res, 0, sizeof(gras_datadesc_type_t)); res->name = strdup(name); res->name_len = strlen(name); - res->refcounter = 1; - + + *dst=res; TRY(gras_set_add(gras_datadesc_set_local, (gras_set_elm_t*)res,&gras_ddt_freev)); - - *dst=res; + GRAS_OUT; return no_error; } @@ -57,10 +56,13 @@ gras_datadesc_type_t *gras_datadesc_by_name(const char *name) { gras_datadesc_type_t *type; + GRAS_IN1("(%s)",name); if (gras_set_get_by_name(gras_datadesc_set_local, name,(gras_set_elm_t**)&type) == no_error) { + GRAS_OUT; return type; } else { + GRAS_OUT; return NULL; } } @@ -72,26 +74,39 @@ gras_datadesc_type_t *gras_datadesc_by_name(const char *name) { */ gras_error_t gras_datadesc_by_id(long int code, gras_datadesc_type_t **type) { + GRAS_IN; return gras_set_get_by_id(gras_datadesc_set_local, code,(gras_set_elm_t**)type); } /** - * gras_datadesc_declare_scalar: + * gras_datadesc_scalar: * * Create a new scalar and give a pointer to it */ gras_error_t -gras_datadesc_declare_scalar(const char *name, - gras_ddt_scalar_type_t type, - enum e_gras_dd_scalar_encoding encoding, - gras_datadesc_type_cb_void_t cb, - gras_datadesc_type_t **dst) { +gras_datadesc_scalar(const char *name, + gras_ddt_scalar_type_t type, + enum e_gras_dd_scalar_encoding encoding, + gras_datadesc_type_t **dst) { gras_error_t errcode; gras_datadesc_type_t *res; long int arch; + GRAS_IN; + res = gras_datadesc_by_name(name); + if (res) { + gras_assert1(res->category_code == e_gras_datadesc_type_cat_scalar, + "Redefinition of type %s does not match", name); + gras_assert1(res->category.scalar_data.encoding == encoding, + "Redefinition of type %s does not match", name); + gras_assert1(res->category.scalar_data.type == type, + "Redefinition of type %s does not match", name); + VERB1("Discarding redefinition of %s",name); + *dst=res; + return no_error; + } TRY(gras_ddt_new(name,dst)); res=*dst; @@ -132,8 +147,8 @@ gras_datadesc_declare_scalar(const char *name, res->category_code = e_gras_datadesc_type_cat_scalar; res->category.scalar_data.encoding = encoding; - - res->pre = cb; + res->category.scalar_data.type = type; + GRAS_OUT; return no_error; } @@ -145,26 +160,38 @@ gras_datadesc_declare_scalar(const char *name, */ void gras_dd_cat_field_free(void *f) { gras_dd_cat_field_t *field = *(gras_dd_cat_field_t **)f; + GRAS_IN; if (field) { if (field->name) free(field->name); free(field); } + GRAS_OUT; } /** - * gras_datadesc_declare_struct: + * gras_datadesc_struct: * * Create a new struct and give a pointer to it */ gras_error_t -gras_datadesc_declare_struct(const char *name, - gras_datadesc_type_t **dst) { +gras_datadesc_struct(const char *name, + gras_datadesc_type_t **dst) { gras_error_t errcode; gras_datadesc_type_t *res; long int arch; - + + GRAS_IN1("(%s)",name); + res = gras_datadesc_by_name(name); + if (res) { + /* FIXME: Check that field redefinition matches */ + gras_assert1(res->category_code == e_gras_datadesc_type_cat_struct, + "Redefinition of type %s does not match", name); + VERB1("Discarding redefinition of %s",name); + *dst=res; + return no_error; + } TRY(gras_ddt_new(name,dst)); res=*dst; @@ -178,29 +205,34 @@ gras_datadesc_declare_struct(const char *name, sizeof(gras_dd_cat_field_t*), &gras_dd_cat_field_free)); + GRAS_OUT; return no_error; } /** - * gras_datadesc_declare_struct_append: + * gras_datadesc_struct_append: * * Append a field to the struct */ gras_error_t -gras_datadesc_declare_struct_append(gras_datadesc_type_t *struct_type, - const char *name, - gras_datadesc_type_t *field_type) { +gras_datadesc_struct_append(gras_datadesc_type_t *struct_type, + const char *name, + gras_datadesc_type_t *field_type) { gras_error_t errcode; gras_dd_cat_field_t *field; int arch; - - gras_assert1(!struct_type->category.struct_data.closed, - "Cannot add anything to the already closed struct %s", - struct_type->name); - gras_assert1(field_type->size >= 0, - "Cannot add a dynamically sized field in structure %s", - struct_type->name); + + GRAS_IN3("(%s %s.%s;)",field_type->name,struct_type->name,name); + if (struct_type->category.struct_data.closed) { + VERB1("Ignoring request to add field to struct %s (closed. Redefinition?)", + struct_type->name); + return no_error; + } + + gras_assert1(field_type->size >= 0, + "Cannot add a dynamically sized field in structure %s", + struct_type->name); field=malloc(sizeof(gras_dd_cat_field_t)); if (!field) @@ -208,57 +240,80 @@ gras_datadesc_declare_struct_append(gras_datadesc_type_t *struct_type, field->name = strdup(name); + DEBUG0("----------------"); + DEBUG4("PRE s={size=%ld,align=%ld,asize=%ld} struct_boundary=%d", + struct_type->size[GRAS_THISARCH], + struct_type->alignment[GRAS_THISARCH], + struct_type->aligned_size[GRAS_THISARCH], + gras_arches[GRAS_THISARCH].struct_boundary); + + for (arch=0; archoffset[arch] = aligned(struct_type->size[arch], - field_type->alignment[arch]); - } - field->code = field_type->code; - field->pre = NULL; - field->post = NULL; - - TRY(gras_dynar_push(struct_type->category.struct_data.fields, &field)); + min(field_type->alignment[arch], + gras_arches[arch].struct_boundary)); - for (arch=0; archsize[arch] = field->offset[arch] + field_type->size[arch]; struct_type->alignment[arch] = max(struct_type->alignment[arch], field_type->alignment[arch]); struct_type->aligned_size[arch] = aligned(struct_type->size[arch], struct_type->alignment[arch]); } + field->type = field_type; + field->pre = NULL; + field->post = NULL; + + TRY(gras_dynar_push(struct_type->category.struct_data.fields, &field)); - DEBUG3("Push a %s into %s at offset %d.", + DEBUG3("Push a %s into %s at offset %ld.", field_type->name, struct_type->name,field->offset[GRAS_THISARCH]); - DEBUG3(" f={size=%d,align=%d,asize=%d}", + DEBUG3(" f={size=%ld,align=%ld,asize=%ld}", field_type->size[GRAS_THISARCH], - field_type->alignment, field_type->aligned_size); - DEBUG3(" s={size=%d,align=%d,asize=%d}", + field_type->alignment[GRAS_THISARCH], + field_type->aligned_size[GRAS_THISARCH]); + DEBUG3(" s={size=%ld,align=%ld,asize=%ld}", struct_type->size[GRAS_THISARCH], - struct_type->alignment, struct_type->aligned_size); + struct_type->alignment[GRAS_THISARCH], + struct_type->aligned_size[GRAS_THISARCH]); + GRAS_OUT; return no_error; } void -gras_datadesc_declare_struct_close(gras_datadesc_type_t *struct_type) { - struct_type->category.struct_data.closed = 1; - INFO0("FIXME: Do something in gras_datadesc_declare_struct_close"); +gras_datadesc_struct_close(gras_datadesc_type_t *struct_type) { + GRAS_IN; + struct_type->category.struct_data.closed = 1; } /** - * gras_datadesc_declare_union: + * gras_datadesc_union: * * Create a new union and give a pointer to it */ gras_error_t -gras_datadesc_declare_union(const char *name, - gras_datadesc_type_cb_int_t selector, - gras_datadesc_type_t **dst) { +gras_datadesc_union(const char *name, + gras_datadesc_type_cb_int_t selector, + gras_datadesc_type_t **dst) { gras_error_t errcode; gras_datadesc_type_t *res; int arch; + GRAS_IN1("(%s)",name); gras_assert0(selector, "Attempt to creat an union without field_count function"); + res = gras_datadesc_by_name(name); + if (res) { + /* FIXME: Check that field redefinition matches */ + gras_assert1(res->category_code == e_gras_datadesc_type_cat_union, + "Redefinition of type %s does not match", name); + gras_assert1(res->category.union_data.selector == selector, + "Redefinition of type %s does not match", name); + VERB1("Discarding redefinition of %s",name); + *dst=res; + return no_error; + } + TRY(gras_ddt_new(name,dst)); res=*dst; @@ -278,25 +333,29 @@ gras_datadesc_declare_union(const char *name, } /** - * gras_datadesc_declare_union_append: + * gras_datadesc_union_append: * * Append a field to the union */ gras_error_t -gras_datadesc_declare_union_append(gras_datadesc_type_t *union_type, - const char *name, - gras_datadesc_type_t *field_type) { +gras_datadesc_union_append(gras_datadesc_type_t *union_type, + const char *name, + gras_datadesc_type_t *field_type) { gras_error_t errcode; gras_dd_cat_field_t *field; int arch; - gras_assert1(!union_type->category.union_data.closed, - "Cannot add anything to the already closed union %s", - union_type->name); + GRAS_IN3("(%s %s.%s;)",field_type->name,union_type->name,name); gras_assert1(field_type->size >= 0, "Cannot add a dynamically sized field in union %s", union_type->name); + + if (union_type->category.union_data.closed) { + VERB1("Ignoring request to add field to union %s (closed)", + union_type->name); + return no_error; + } field=malloc(sizeof(gras_dd_cat_field_t)); if (!field) @@ -306,7 +365,7 @@ gras_datadesc_declare_union_append(gras_datadesc_type_t *union_type, for (arch=0; archoffset[arch] = 0; /* that's the purpose of union ;) */ } - field->code = field_type->code; + field->type = field_type; field->pre = NULL; field->post = NULL; @@ -324,25 +383,38 @@ gras_datadesc_declare_union_append(gras_datadesc_type_t *union_type, } void -gras_datadesc_declare_union_close(gras_datadesc_type_t *union_type) { +gras_datadesc_union_close(gras_datadesc_type_t *union_type) { union_type->category.union_data.closed = 1; - INFO0("FIXME: Do something in gras_datadesc_declare_array_close"); } /** - * gras_datadesc_declare_ref: + * gras_datadesc_ref: * * Create a new ref to a fixed type and give a pointer to it */ gras_error_t -gras_datadesc_declare_ref(const char *name, - gras_datadesc_type_t *referenced_type, - gras_datadesc_type_t **dst) { +gras_datadesc_ref(const char *name, + gras_datadesc_type_t *referenced_type, + gras_datadesc_type_t **dst) { gras_error_t errcode; gras_datadesc_type_t *res; gras_datadesc_type_t *pointer_type = gras_datadesc_by_name("data pointer"); int arch; + GRAS_IN1("(%s)",name); + res = gras_datadesc_by_name(name); + if (res) { + gras_assert1(res->category_code == e_gras_datadesc_type_cat_ref, + "Redefinition of %s does not match",name); + gras_assert1(res->category.ref_data.type == referenced_type, + "Redefinition of %s does not match",name); + gras_assert1(res->category.ref_data.selector == NULL, + "Redefinition of %s does not match",name); + VERB1("Discarding redefinition of %s",name); + *dst=res; + return no_error; + } + TRY(gras_ddt_new(name,dst)); res=*dst; @@ -353,29 +425,41 @@ gras_datadesc_declare_ref(const char *name, res->alignment[arch] = pointer_type->alignment[arch]; res->aligned_size[arch] = pointer_type->aligned_size[arch]; } - - res->category_code = e_gras_datadesc_type_cat_ref; - - res->category.ref_data.code = referenced_type->code; + + res->category_code = e_gras_datadesc_type_cat_ref; + res->category.ref_data.type = referenced_type; res->category.ref_data.selector = NULL; return no_error; } /** - * gras_datadesc_declare_ref_generic: + * gras_datadesc_ref_generic: * * Create a new ref to a type given at use time, and give a pointer to it */ gras_error_t -gras_datadesc_declare_ref_generic(const char *name, - gras_datadesc_type_cb_int_t selector, - gras_datadesc_type_t **dst) { +gras_datadesc_ref_generic(const char *name, + gras_datadesc_selector_t selector, + gras_datadesc_type_t **dst) { gras_error_t errcode; gras_datadesc_type_t *res; gras_datadesc_type_t *pointer_type = gras_datadesc_by_name("data pointer"); int arch; + GRAS_IN1("(%s)",name); + res = gras_datadesc_by_name(name); + if (res) { + gras_assert1(res->category_code == e_gras_datadesc_type_cat_ref, + "Redefinition of type %s does not match", name); + gras_assert1(res->category.ref_data.type == NULL, + "Redefinition of type %s does not match", name); + gras_assert1(res->category.ref_data.selector == selector, + "Redefinition of type %s does not match", name); + VERB1("Discarding redefinition of %s",name); + *dst=res; + return no_error; + } TRY(gras_ddt_new(name,dst)); res=*dst; @@ -389,27 +473,43 @@ gras_datadesc_declare_ref_generic(const char *name, res->category_code = e_gras_datadesc_type_cat_ref; - res->category.ref_data.code = -1; + res->category.ref_data.type = NULL; res->category.ref_data.selector = selector; return no_error; } /** - * gras_datadesc_declare_array_fixed: + * gras_datadesc_array_fixed: * * Create a new array and give a pointer to it */ gras_error_t -gras_datadesc_declare_array_fixed(const char *name, - gras_datadesc_type_t *element_type, - long int fixed_size, - gras_datadesc_type_t **dst) { +gras_datadesc_array_fixed(const char *name, + gras_datadesc_type_t *element_type, + long int fixed_size, + gras_datadesc_type_t **dst) { gras_error_t errcode; gras_datadesc_type_t *res; int arch; + GRAS_IN1("(%s)",name); + res = gras_datadesc_by_name(name); + if (res) { + gras_assert1(res->category_code == e_gras_datadesc_type_cat_array, + "Redefinition of type %s does not match", name); + gras_assert1(res->category.array_data.type == element_type, + "Redefinition of type %s does not match", name); + gras_assert1(res->category.array_data.fixed_size == fixed_size, + "Redefinition of type %s does not match", name); + gras_assert1(res->category.array_data.dynamic_size == NULL, + "Redefinition of type %s does not match", name); + VERB1("Discarding redefinition of %s",name); + + *dst=res; + return no_error; + } TRY(gras_ddt_new(name,dst)); res=*dst; @@ -422,31 +522,48 @@ gras_datadesc_declare_array_fixed(const char *name, res->category_code = e_gras_datadesc_type_cat_array; - res->category.array_data.code = element_type->code; + res->category.array_data.type = element_type; res->category.array_data.fixed_size = fixed_size; res->category.array_data.dynamic_size = NULL; return no_error; } /** - * gras_datadesc_declare_array_dyn: + * gras_datadesc_array_dyn: * * Create a new array and give a pointer to it */ gras_error_t -gras_datadesc_declare_array_dyn(const char *name, - gras_datadesc_type_t *element_type, - gras_datadesc_type_cb_int_t dynamic_size, - gras_datadesc_type_t **dst) { +gras_datadesc_array_dyn(const char *name, + gras_datadesc_type_t *element_type, + gras_datadesc_type_cb_int_t dynamic_size, + gras_datadesc_type_t **dst) { gras_error_t errcode; gras_datadesc_type_t *res; int arch; + GRAS_IN1("(%s)",name); gras_assert1(dynamic_size, "'%s' is a dynamic array without size discriminant", name); + res = gras_datadesc_by_name(name); + if (res) { + gras_assert1(res->category_code == e_gras_datadesc_type_cat_array, + "Redefinition of type %s does not match", name); + gras_assert1(res->category.array_data.type == element_type, + "Redefinition of type %s does not match", name); + gras_assert1(res->category.array_data.fixed_size == -1, + "Redefinition of type %s does not match", name); + gras_assert1(res->category.array_data.dynamic_size == dynamic_size, + "Redefinition of type %s does not match", name); + VERB1("Discarding redefinition of %s",name); + + *dst=res; + return no_error; + } + TRY(gras_ddt_new(name,dst)); res=*dst; @@ -458,13 +575,54 @@ gras_datadesc_declare_array_dyn(const char *name, res->category_code = e_gras_datadesc_type_cat_array; - res->category.array_data.code = element_type->code; + res->category.array_data.type = element_type; res->category.array_data.fixed_size = -1; res->category.array_data.dynamic_size = dynamic_size; return no_error; } +/** + * gras_datadesc_ref_pop_arr: + * + * Most of the time, you want to include a reference in your structure which + * is a pointer to a dynamic array whose size is fixed by another field of + * your structure. + * + * This case pops up so often that this function was created to take care of + * this case. It creates a dynamic array type whose size is poped from the + * current cbps, and then create a reference to it. + * + * The name of the created datatype will be the name of the element type, with + * '[]*' appended to it. + * + * Then to use it, you just have to make sure that your structure pre-callback + * does push the size of the array in the cbps (using #gras_cbps_i_push), and + * you are set. + * + * But be remember that this is a stack. If you have two different pop_arr, you + * should push the second one first, so that the first one is on the top of the + * list when the first field gets transfered. + * + */ +gras_error_t +gras_datadesc_ref_pop_arr(gras_datadesc_type_t *element_type, + gras_datadesc_type_t **dst) { + gras_error_t errcode; + char *name=malloc(strlen(element_type->name) + 4); + + sprintf(name,"%s[]",element_type->name); + + TRY(gras_datadesc_array_dyn(name,element_type, + gras_datadesc_cb_pop, dst)); + + sprintf(name,"%s[]*",element_type->name); + TRY(gras_datadesc_ref(name,*dst,dst)); + + free(name); + + return no_error; +} gras_error_t gras_datadesc_import_nws(const char *name, const DataDescriptor *desc, @@ -474,73 +632,62 @@ gras_datadesc_import_nws(const char *name, } /** - * gras_datadesc_cb_set_pre: + * gras_datadesc_cb_send: * - * Add a pre-send callback to this datadexc + * Add a pre-send callback to this datadexc. + * (useful to push the sizes of the upcoming arrays, for example) */ -void gras_datadesc_cb_set_pre (gras_datadesc_type_t *type, - gras_datadesc_type_cb_void_t pre) { - type->pre = pre; +void gras_datadesc_cb_send (gras_datadesc_type_t *type, + gras_datadesc_type_cb_void_t send) { + type->send = send; } /** - * gras_datadesc_cb_set_post: + * gras_datadesc_cb_recv: * - * Add a post-send callback to this datadexc + * Add a post-receive callback to this datadesc. + * (useful to put the function pointers to the rigth value, for example) */ -void gras_datadesc_cb_set_post(gras_datadesc_type_t *type, - gras_datadesc_type_cb_void_t post) { - type->post = post; -} - -/** - * gras_datadesc_ref: - * - * Adds a reference to the datastruct. - * ddt will be freed only when the refcount becomes 0. - */ -void gras_datadesc_ref(gras_datadesc_type_t *type) { - type->refcounter ++; +void gras_datadesc_cb_recv(gras_datadesc_type_t *type, + gras_datadesc_type_cb_void_t recv) { + type->recv = recv; } /** * gras_datadesc_unref: * - * Adds a reference to the datastruct. + * Removes a reference to the datastruct. * ddt will be freed only when the refcount becomes 0. */ -void gras_datadesc_unref(gras_datadesc_type_t *type) { - type->refcounter--; - if (!type->refcounter) { - /* even the set of ddt released that type. Let's free it */ - DEBUG1("Let's free ddt %s",type->name); - - free(type->name); - switch (type->category_code) { - case e_gras_datadesc_type_cat_scalar: - case e_gras_datadesc_type_cat_ref: - case e_gras_datadesc_type_cat_array: - /* nothing to free in there */ - break; - - case e_gras_datadesc_type_cat_ignored: - if (type->category.ignored_data.free_func) { - type->category.ignored_data.free_func - (type->category.ignored_data.default_value); - } - break; - - case e_gras_datadesc_type_cat_struct: - gras_dynar_free(type->category.struct_data.fields); - break; - - case e_gras_datadesc_type_cat_union: - gras_dynar_free(type->category.union_data.fields); - break; - - default: - /* datadesc was invalid. Killing it is like euthanasy, I guess */ - break; +void gras_datadesc_free(gras_datadesc_type_t *type) { + + DEBUG1("Let's free ddt %s",type->name); + + switch (type->category_code) { + case e_gras_datadesc_type_cat_scalar: + case e_gras_datadesc_type_cat_ref: + case e_gras_datadesc_type_cat_array: + /* nothing to free in there */ + break; + + case e_gras_datadesc_type_cat_ignored: + if (type->category.ignored_data.free_func) { + type->category.ignored_data.free_func + (type->category.ignored_data.default_value); } - free(type); + break; + + case e_gras_datadesc_type_cat_struct: + gras_dynar_free(type->category.struct_data.fields); + break; + + case e_gras_datadesc_type_cat_union: + gras_dynar_free(type->category.union_data.fields); + break; + + default: + /* datadesc was invalid. Killing it is like euthanasy, I guess */ + break; } + free(type->name); + free(type); }