GRAS_LOG_NEW_DEFAULT_SUBCATEGORY(ddt_exchange,datadesc,
"Sending data over the network");
-
-#undef DETECT_CYCLE
-/* CRUDE HACK to turn all cycle detection of */
-#ifndef DETECT_CYCLE
-#define gras_dict_get_ext(a,b,c,d) mismatch_error
-#define gras_dict_set_ext(a,b,c,d,e) no_error
-#endif
-
const char *gras_datadesc_cat_names[9] = {
"undefined",
"scalar", "struct", "union", "ref", "array", "ignored",
static gras_datadesc_type_t *int_type = NULL;
static gras_datadesc_type_t *pointer_type = NULL;
-static inline gras_error_t gras_dd_send_int(gras_socket_t *sock, int i);
-static inline gras_error_t gras_dd_recv_int(gras_socket_t *sock, int r_arch, int *i);
+static _GRAS_INLINE gras_error_t gras_dd_send_int(gras_socket_t *sock, int i);
+static _GRAS_INLINE gras_error_t gras_dd_recv_int(gras_socket_t *sock, int r_arch, int *i);
-static inline gras_error_t
+static _GRAS_INLINE gras_error_t
gras_dd_alloc_ref(gras_dict_t *refs, long int size,
char **r_ref, long int r_len,
- char **l_ref);
-static inline int
+ char **l_ref, int detect_cycle);
+
+static _GRAS_INLINE int
gras_dd_is_r_null(char **r_ptr, long int length);
static gras_error_t
gras_cbps_t *state,
gras_dict_t *refs,
gras_datadesc_type_t *type,
- char *data);
+ char *data,
+ int detect_cycle);
static gras_error_t
gras_datadesc_recv_rec(gras_socket_t *sock,
gras_cbps_t *state,
char **r_data,
long int r_lgr,
char *dst,
- int subsize);
+ int subsize,
+ int detect_cycle);
-static inline gras_error_t
+static _GRAS_INLINE gras_error_t
gras_dd_send_int(gras_socket_t *sock,int i) {
if (!int_type) {
return gras_trp_chunk_send(sock, (char*)&i, int_type->size[GRAS_THISARCH]);
}
-static inline gras_error_t
+static _GRAS_INLINE gras_error_t
gras_dd_recv_int(gras_socket_t *sock, int r_arch, int *i) {
gras_error_t errcode;
TRY(gras_dd_convert_elm(int_type,1,r_arch, i,i));
} else {
void *ptr = gras_malloc(int_type->size[r_arch]);
- if (!ptr)
- RAISE_MALLOC;
+
TRY(gras_trp_chunk_recv(sock, (char*)ptr, int_type->size[r_arch]));
if (r_arch != GRAS_THISARCH)
TRY(gras_dd_convert_elm(int_type,1,r_arch, ptr,i));
* of 'length' bytes set to 0.
* FIXME: Check in configure?
*/
-static inline int
+static _GRAS_INLINE int
gras_dd_is_r_null(char **r_ptr, long int length) {
int i;
return 1;
}
-static inline gras_error_t
+static _GRAS_INLINE gras_error_t
gras_dd_alloc_ref(gras_dict_t *refs,
long int size,
char **r_ref,
long int r_len, /* pointer_type->size[r_arch] */
- char **l_ref) {
+ char **l_ref,
+ int detect_cycle) {
char *l_data = NULL;
gras_assert1(size>0,"Cannot allocate %ld bytes!", size);
- if (! (l_data = gras_malloc((size_t)size)) )
- RAISE_MALLOC;
+ l_data = gras_malloc((size_t)size);
*l_ref = l_data;
- DEBUG2("l_data=%p, &l_data=%p",l_data,&l_data);
+ DEBUG2("l_data=%p, &l_data=%p",(void*)l_data,(void*)&l_data);
DEBUG3("alloc_ref: r_ref=%p; *r_ref=%p, r_len=%ld",
- r_ref, r_ref?*r_ref:NULL, r_len);
-#ifdef DETECT_CYCLE
- if (r_ref && !gras_dd_is_r_null( r_ref, r_len)) {
+ (void*)r_ref, (void*)(r_ref?*r_ref:NULL), r_len);
+ if (detect_cycle && r_ref && !gras_dd_is_r_null( r_ref, r_len)) {
gras_error_t errcode;
void *ptr = gras_malloc(sizeof(void *));
- if (!ptr)
- RAISE_MALLOC;
memcpy(ptr,l_ref, sizeof(void *));
DEBUG2("Insert %p under %p",*(void**)ptr, *(void**)r_ref);
- TRY(gras_dict_set_ext(refs,(const char *) r_ref, r_len, ptr, gras_free));
+ if (detect_cycle)
+ gras_dict_set_ext(refs,(const char *) r_ref, r_len, ptr, gras_free);
}
-#endif
return no_error;
}
if (d1->send != d2->send) {
DEBUG4("ddt_cmp: %s->send=%p != %s->send=%p",
- d1->name,d1->send, d2->name,d2->send);
- return d1->send > d2->send ? 1 : -1;
+ d1->name,(void*)d1->send, d2->name,(void*)d2->send);
+ return 1; /* ISO C forbids ordered comparisons of pointers to functions */
}
if (d1->recv != d2->recv) {
DEBUG4("ddt_cmp: %s->recv=%p != %s->recv=%p",
- d1->name,d1->recv, d2->name,d2->recv);
- return d1->recv > d2->recv ? 1 : -1;
+ d1->name,(void*)d1->recv, d2->name,(void*)d2->recv);
+ return 1; /* ISO C forbids ordered comparisons of pointers to functions */
}
switch (d1->category_code) {
case e_gras_datadesc_type_cat_union:
if (d1->category.union_data.selector != d2->category.union_data.selector)
- return d1->category.union_data.selector > d2->category.union_data.selector ? 1 : -1;
+ return 1; /* ISO C forbids ordered comparisons of pointers to functions */
if (gras_dynar_length(d1->category.union_data.fields) !=
gras_dynar_length(d2->category.union_data.fields))
case e_gras_datadesc_type_cat_ref:
if (d1->category.ref_data.selector != d2->category.ref_data.selector)
- return d1->category.ref_data.selector > d2->category.ref_data.selector ? 1 : -1;
+ return 1; /* ISO C forbids ordered comparisons of pointers to functions */
if (d1->category.ref_data.type != d2->category.ref_data.type)
return d1->category.ref_data.type > d2->category.ref_data.type ? 1 : -1;
return d1->category.array_data.fixed_size > d2->category.array_data.fixed_size ? 1 : -1;
if (d1->category.array_data.dynamic_size != d2->category.array_data.dynamic_size)
- return d1->category.array_data.dynamic_size > d2->category.array_data.dynamic_size ? 1 : -1;
+ return 1; /* ISO C forbids ordered comparisons of pointers to functions */
break;
gras_cbps_t *state,
gras_dict_t *refs,
gras_datadesc_type_t *type,
- char *data) {
+ char *data,
+ int detect_cycle) {
gras_error_t errcode;
int cpt;
field->pre(state,field_data);
VERB1("Send field %s",field->name);
- TRY(gras_datadesc_send_rec(sock,state,refs,sub_type, field_data));
+ TRY(gras_datadesc_send_rec(sock,state,refs,sub_type, field_data, detect_cycle || sub_type->cycle));
if (field->post)
field->post(state,field_data);
if (field->pre)
field->pre(state,data);
- TRY(gras_datadesc_send_rec(sock,state,refs, sub_type, data));
+ TRY(gras_datadesc_send_rec(sock,state,refs, sub_type, data, detect_cycle || sub_type->cycle));
if (field->post)
field->post(state,data);
gras_dd_cat_ref_t ref_data;
void **ref=(void**)data;
-#ifdef DETECT_CYCLE
void *dummy;
-#endif
ref_data = type->category.ref_data;
VERB0("Not sending NULL referenced data");
break;
}
- errcode = gras_dict_get_ext(refs,(char*)ref, sizeof(void*), &dummy);
+ errcode = detect_cycle
+ ? gras_dict_get_ext(refs,(char*)ref, sizeof(void*), &dummy)
+ : mismatch_error;
if (errcode == mismatch_error) {
- VERB1("Sending data referenced at %p", *ref);
- TRY(gras_dict_set_ext(refs, (char*)ref, sizeof(void*), ref, NULL));
- TRY(gras_datadesc_send_rec(sock,state,refs, sub_type, *ref));
-
+ VERB1("Sending data referenced at %p", (void*)*ref);
+ if (detect_cycle)
+ gras_dict_set_ext(refs, (char*)ref, sizeof(void*), ref, NULL);
+ TRY(gras_datadesc_send_rec(sock,state,refs, sub_type, *ref, detect_cycle || sub_type->cycle));
+
} else if (errcode == no_error) {
- VERB1("Not sending data referenced at %p (already done)", *ref);
+ VERB1("Not sending data referenced at %p (already done)", (void*)*ref);
} else {
- return errcode;
+ return errcode;
}
break;
/* determine and send the element count */
count = array_data.fixed_size;
- if (count <= 0) {
+ if (count == 0) {
count = array_data.dynamic_size(state,data);
gras_assert1(count >=0,
"Invalid (negative) array size for type %s",type->name);
sub_type->aligned_size[GRAS_THISARCH] * count));
} else {
for (cpt=0; cpt<count; cpt++) {
- TRY(gras_datadesc_send_rec(sock,state,refs, sub_type, ptr));
+ TRY(gras_datadesc_send_rec(sock,state,refs, sub_type, ptr, detect_cycle || sub_type->cycle));
ptr += elm_size;
}
}
gras_cbps_t *state = NULL;
gras_dict_t *refs; /* all references already sent */
- TRY(gras_dict_new(&refs));
- TRY(gras_cbps_new(&state));
+ refs = gras_dict_new();
+ state = gras_cbps_new();
- errcode = gras_datadesc_send_rec(sock,state,refs,type,(char*)src);
+ errcode = gras_datadesc_send_rec(sock,state,refs,type,(char*)src, type->cycle);
gras_dict_free(&refs);
gras_cbps_free(&state);
char **r_data,
long int r_lgr,
char *l_data,
- int subsize) {
+ int subsize,
+ int detect_cycle) {
gras_error_t errcode;
int cpt;
gras_datadesc_type_t *sub_type;
- VERB2("Recv a %s @%p", type->name, l_data);
+ VERB2("Recv a %s @%p", type->name, (void*)l_data);
gras_assert(l_data);
switch (type->category_code) {
TRY(gras_dd_convert_elm(type,1,r_arch, l_data,l_data));
} else {
void *ptr = gras_malloc(type->size[r_arch]);
- if (!ptr)
- RAISE_MALLOC;
+
TRY(gras_trp_chunk_recv(sock, (char*)ptr, type->size[r_arch]));
if (r_arch != GRAS_THISARCH)
TRY(gras_dd_convert_elm(type,1,r_arch, ptr,l_data));
TRY(gras_datadesc_recv_rec(sock,state,refs, sub_type,
r_arch,NULL,0,
- field_data,-1));
+ field_data,-1,
+ detect_cycle || sub_type->cycle));
}
VERB1("<< Received all fields of the structure %s", type->name);
TRY(gras_datadesc_recv_rec(sock,state,refs, sub_type,
r_arch,NULL,0,
- l_data,-1));
+ l_data,-1,
+ detect_cycle || sub_type->cycle));
break;
}
gras_assert(pointer_type);
}
- if (! (r_ref = gras_malloc(pointer_type->size[r_arch])) )
- RAISE_MALLOC;
+ r_ref = gras_malloc(pointer_type->size[r_arch]);
+
TRY(gras_trp_chunk_recv(sock, (char*)r_ref,
pointer_type->size[r_arch]));
gras_free(r_ref);
break;
}
- errcode = gras_dict_get_ext(refs,
+
+ errcode = detect_cycle
+ ? gras_dict_get_ext(refs,
(char*)r_ref, pointer_type->size[r_arch],
- (void**)&l_ref);
-
+ (void**)&l_ref)
+ : mismatch_error;
if (errcode == mismatch_error) {
- int subsubcount = -1;
+ int subsubcount = 0;
void *l_referenced=NULL;
VERB2("Receiving a ref to '%s', remotely @%p",
gras_datadesc_type_t *subsub_type;
subsubcount = array_data.fixed_size;
- if (subsubcount < 0)
+ if (subsubcount == 0)
TRY(gras_dd_recv_int(sock, r_arch, &subsubcount));
subsub_type = array_data.type;
TRY(gras_dd_alloc_ref(refs,
subsub_type->size[GRAS_THISARCH] * subsubcount,
r_ref,pointer_type->size[r_arch],
- (char**)&l_referenced));
+ (char**)&l_referenced,
+ detect_cycle));
} else {
TRY(gras_dd_alloc_ref(refs,sub_type->size[GRAS_THISARCH],
r_ref,pointer_type->size[r_arch],
- (char**)&l_referenced));
+ (char**)&l_referenced,
+ detect_cycle));
}
TRY(gras_datadesc_recv_rec(sock,state,refs, sub_type,
r_arch,r_ref,pointer_type->size[r_arch],
- (char*)l_referenced, subsubcount));
+ (char*)l_referenced, subsubcount,
+ detect_cycle || sub_type->cycle));
*(void**)l_data=l_referenced;
VERB3("'%s' remotely referenced at %p locally at %p",
sub_type->name, *(void**)r_ref, l_referenced);
array_data = type->category.array_data;
/* determine element count locally, or from caller, or from peer */
count = array_data.fixed_size;
- if (count <= 0)
+ if (count == 0)
count = subsize;
- if (count < 0)
+ if (count == 0)
TRY(gras_dd_recv_int(sock, r_arch, &count));
- if (count < 0)
+ if (count == 0)
RAISE1(mismatch_error,
- "Invalid (negative) array size for type %s",type->name);
+ "Invalid (=0) array size for type %s",type->name);
/* receive the content */
sub_type = array_data.type;
TRY(gras_dd_convert_elm(sub_type,count,r_arch, l_data,l_data));
} else {
ptr = gras_malloc(sub_type->aligned_size[r_arch] * count);
- if (!ptr)
- RAISE_MALLOC;
+
TRY(gras_trp_chunk_recv(sock, (char*)ptr,
sub_type->size[r_arch] * count));
if (r_arch != GRAS_THISARCH)
ptr = l_data;
for (cpt=0; cpt<count; cpt++) {
TRY(gras_datadesc_recv_rec(sock,state,refs, sub_type,
- r_arch, NULL, 0, ptr,-1));
+ r_arch, NULL, 0, ptr,-1,
+ detect_cycle || sub_type->cycle));
ptr += elm_size;
}
}
gras_cbps_t *state = NULL; /* callback persistent state */
gras_dict_t *refs; /* all references already sent */
- TRY(gras_dict_new(&refs));
- TRY(gras_cbps_new(&state));
+ refs = gras_dict_new();
+ state = gras_cbps_new();
errcode = gras_datadesc_recv_rec(sock, state, refs, type,
r_arch, NULL, 0,
- (char *) dst,-1);
+ (char *) dst,-1,
+ type->cycle);
gras_dict_free(&refs);
gras_cbps_free(&state);
