From 6716ae8429b63b32623f1de1d0a6235c559e6e9c Mon Sep 17 00:00:00 2001 From: Quincey Koziol Date: Thu, 12 Oct 2006 13:42:02 -0500 Subject: [svn-r12756] Description: Clean up some object header code in advance of more major changes in the near future. Fix small initialization error in attribute message name buffer copy. Tweak down the default # of messages for new object headers. Tested on: FreeBSD/32 4.11 (sleipnir) w/threadsafe Linux/32 2.4 (heping) w/FORTRAN & C++ Mac OS/32 10.4.8 (amazon) --- src/H5D.c | 2 +- src/H5Gobj.c | 4 +-- src/H5O.c | 104 +++++++++++++++++++++++++------------------------------ src/H5Oattr.c | 29 ++++++++-------- src/H5Ocache.c | 61 +++++++++++++++----------------- src/H5Opkg.h | 4 +-- src/H5Oprivate.h | 3 +- 7 files changed, 94 insertions(+), 113 deletions(-) diff --git a/src/H5D.c b/src/H5D.c index fe36702..49f9c52 100644 --- a/src/H5D.c +++ b/src/H5D.c @@ -2515,7 +2515,7 @@ H5D_create(H5F_t *file, hid_t type_id, const H5S_t *space, /* Verify data size is smaller than maximum header message size * (64KB) minus other layout message fields. */ - comp_data_size=H5O_MAX_SIZE-H5O_layout_meta_size(file, &(new_dset->shared->layout)); + comp_data_size=H5O_MESG_MAX_SIZE-H5O_layout_meta_size(file, &(new_dset->shared->layout)); if(new_dset->shared->layout.u.compact.size > comp_data_size) HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, NULL, "compact dataset size is bigger than header message maximum size") diff --git a/src/H5Gobj.c b/src/H5Gobj.c index 4500ed4..b6abe4c 100644 --- a/src/H5Gobj.c +++ b/src/H5Gobj.c @@ -536,7 +536,7 @@ H5G_obj_insert(H5O_loc_t *grp_oloc, const char *name, H5O_link_t *obj_lnk, */ if(H5F_addr_defined(linfo.link_fheap_addr)) use_new_dense = TRUE; - else if(linfo.nlinks < ginfo.max_compact && link_msg_size < H5O_MAX_SIZE) + else if(linfo.nlinks < ginfo.max_compact && link_msg_size < H5O_MESG_MAX_SIZE) use_new_dense = FALSE; else { H5G_obj_oh_it_ud1_t udata; /* User data for iteration */ @@ -942,7 +942,7 @@ H5G_obj_remove(H5O_loc_t *oloc, const char *name, H5G_obj_t *obj_type, hid_t dxp * into an object header message) */ for(u = 0; u < linfo.nlinks; u++) - if(H5O_mesg_size(H5O_LINK_ID, oloc->file, &(ltable.lnks[u]), (size_t)0) >= H5O_MAX_SIZE) { + if(H5O_mesg_size(H5O_LINK_ID, oloc->file, &(ltable.lnks[u]), (size_t)0) >= H5O_MESG_MAX_SIZE) { can_convert = FALSE; break; } /* end if */ diff --git a/src/H5O.c b/src/H5O.c index 2e865f7..ecc294c 100644 --- a/src/H5O.c +++ b/src/H5O.c @@ -44,6 +44,7 @@ #endif /* H5_HAVE_GETTIMEOFDAY */ /* Local macros */ +#define H5O_MIN_SIZE 32 /*min obj header data size */ /* Load native information for a message, if it's not already present */ /* (Only works for messages with decode callback) */ @@ -653,7 +654,7 @@ done: herr_t H5O_create(H5F_t *f, hid_t dxpl_id, size_t size_hint, H5O_loc_t *loc/*out*/) { - haddr_t header; + haddr_t header; /* Address of object header */ herr_t ret_value = SUCCEED; /* return value */ FUNC_ENTER_NOAPI(H5O_create, FAIL) @@ -662,6 +663,7 @@ H5O_create(H5F_t *f, hid_t dxpl_id, size_t size_hint, H5O_loc_t *loc/*out*/) HDassert(f); HDassert(loc); + /* Make certain we allocate at least a reasonable size for the object header */ size_hint = H5O_ALIGN(MAX(H5O_MIN_SIZE, size_hint)); /* allocate disk space for header and first chunk */ @@ -697,10 +699,10 @@ done: *------------------------------------------------------------------------- */ static herr_t -H5O_new(H5F_t *f, hid_t dxpl_id, size_t size_hint, H5O_loc_t *loc/*out*/, haddr_t header) +H5O_new(H5F_t *f, hid_t dxpl_id, size_t size_hint, H5O_loc_t *loc/*out*/, + haddr_t header) { H5O_t *oh = NULL; - haddr_t tmp_addr; herr_t ret_value = SUCCEED; /* return value */ FUNC_ENTER_NOAPI_NOINIT(H5O_new) @@ -709,7 +711,6 @@ H5O_new(H5F_t *f, hid_t dxpl_id, size_t size_hint, H5O_loc_t *loc/*out*/, haddr_ HDassert(f); HDassert(loc); - size_hint = H5O_ALIGN(MAX(H5O_MIN_SIZE, size_hint)); loc->file = f; loc->addr = header; @@ -727,9 +728,8 @@ H5O_new(H5F_t *f, hid_t dxpl_id, size_t size_hint, H5O_loc_t *loc/*out*/, haddr_ if(NULL == (oh->chunk = H5FL_SEQ_MALLOC(H5O_chunk_t, (size_t)oh->alloc_nchunks))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed") - tmp_addr = loc->addr + (hsize_t)H5O_SIZEOF_HDR(f); oh->chunk[0].dirty = TRUE; - oh->chunk[0].addr = tmp_addr; + oh->chunk[0].addr = loc->addr + (hsize_t)H5O_SIZEOF_HDR(f); oh->chunk[0].size = size_hint; if(NULL == (oh->chunk[0].image = H5FL_BLK_CALLOC(chunk_image, size_hint))) @@ -1077,7 +1077,7 @@ H5O_copy (unsigned type_id, const void *mesg, void *dst) /* Call the "real" copy routine */ if((ret_value=H5O_copy_real(type, mesg, dst))==NULL) - HGOTO_ERROR(H5E_OHDR, H5E_CANTCOPY, NULL, "unable to copy object header message"); + HGOTO_ERROR(H5E_OHDR, H5E_CANTCOPY, NULL, "unable to copy object header message") done: FUNC_LEAVE_NOAPI(ret_value); @@ -1565,7 +1565,7 @@ H5O_find_in_ohdr(H5F_t *f, hid_t dxpl_id, H5O_t *oh, const H5O_msg_class_t **typ } if (sequence >= 0) - HGOTO_ERROR(H5E_OHDR, H5E_NOTFOUND, UFAIL, "unable to find object header message"); + HGOTO_ERROR(H5E_OHDR, H5E_NOTFOUND, UFAIL, "unable to find object header message") /* * Decode the message if necessary. If the message is shared then decode @@ -1879,7 +1879,7 @@ H5O_append(H5F_t *f, hid_t dxpl_id, H5O_t *oh, unsigned type_id, unsigned flags, /* Call the "real" append routine */ if((ret_value=H5O_append_real( f, dxpl_id, oh, type, flags, mesg, oh_flags_ptr)) < 0) - HGOTO_ERROR(H5E_OHDR, H5E_WRITEERROR, FAIL, "unable to append to object header"); + HGOTO_ERROR(H5E_OHDR, H5E_WRITEERROR, FAIL, "unable to append to object header") done: FUNC_LEAVE_NOAPI(ret_value); @@ -1923,11 +1923,11 @@ H5O_append_real(H5F_t *f, hid_t dxpl_id, H5O_t *oh, const H5O_msg_class_t *type, /* Create a new message */ if((idx=H5O_new_mesg(f,oh,&flags,type,mesg,&sh_mesg,&type,&mesg,dxpl_id,oh_flags_ptr))==UFAIL) - HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, FAIL, "unable to create new message"); + HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, FAIL, "unable to create new message") /* Write the information to the message */ if(H5O_write_mesg(oh,idx,type,mesg,flags,0,oh_flags_ptr) < 0) - HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, FAIL, "unable to write message"); + HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, FAIL, "unable to write message") /* Set return value */ ret_value = idx; @@ -1976,7 +1976,7 @@ H5O_new_mesg(H5F_t *f, H5O_t *oh, unsigned *flags, const H5O_msg_class_t *orig_t HDmemset(sh_mesg,0,sizeof(H5O_shared_t)); if (NULL==orig_type->get_share) - HGOTO_ERROR(H5E_OHDR, H5E_UNSUPPORTED, UFAIL, "message class is not sharable"); + HGOTO_ERROR(H5E_OHDR, H5E_UNSUPPORTED, UFAIL, "message class is not sharable") if ((orig_type->get_share)(f, orig_mesg, sh_mesg/*out*/) < 0) { /* * If the message isn't shared then turn off the shared bit @@ -1996,16 +1996,16 @@ H5O_new_mesg(H5F_t *f, H5O_t *oh, unsigned *flags, const H5O_msg_class_t *orig_t } /* end else */ /* Compute the size needed to store the message on disk */ - if((size = ((*new_type)->raw_size)(f, *new_mesg)) >=H5O_MAX_SIZE) + if((size = ((*new_type)->raw_size)(f, *new_mesg)) >=H5O_MESG_MAX_SIZE) HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, UFAIL, "object header message is too large") /* Allocate space in the object headed for the message */ if((ret_value = H5O_alloc(f, dxpl_id, oh, orig_type, size, oh_flags_ptr)) == UFAIL) - HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, UFAIL, "unable to allocate space for message"); + HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, UFAIL, "unable to allocate space for message") /* Increment any links in message */ if((*new_type)->link && ((*new_type)->link)(f,dxpl_id,(*new_mesg)) < 0) - HGOTO_ERROR(H5E_OHDR, H5E_LINKCOUNT, UFAIL, "unable to adjust shared object link count"); + HGOTO_ERROR(H5E_OHDR, H5E_LINKCOUNT, UFAIL, "unable to adjust shared object link count") done: FUNC_LEAVE_NOAPI(ret_value); @@ -2049,7 +2049,7 @@ H5O_write_mesg(H5O_t *oh, unsigned idx, const H5O_msg_class_t *type, /* Copy the native value for the message */ if (NULL == (idx_msg->native = (type->copy) (mesg, idx_msg->native, update_flags))) - HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, FAIL, "unable to copy message to object header"); + HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, FAIL, "unable to copy message to object header") idx_msg->flags = flags; idx_msg->dirty = TRUE; @@ -2115,13 +2115,13 @@ H5O_touch_oh(H5F_t *f, size = (H5O_MSG_MTIME_NEW->raw_size)(f, &now); if((idx = H5O_alloc(f, dxpl_id, oh, H5O_MSG_MTIME_NEW, size, oh_flags_ptr)) == UFAIL) - HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, FAIL, "unable to allocate space for modification time message"); + HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, FAIL, "unable to allocate space for modification time message") } /* end if */ /* Update the native part */ if(NULL==oh->mesg[idx].native) { if(NULL==(oh->mesg[idx].native = H5FL_MALLOC(time_t))) - HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, FAIL, "memory allocation failed for modification time message"); + HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, FAIL, "memory allocation failed for modification time message") } *((time_t*)(oh->mesg[idx].native)) = now; oh->mesg[idx].dirty = TRUE; @@ -2632,7 +2632,7 @@ H5O_move_msgs_forward(H5F_t *f, H5O_t *oh, hid_t dxpl_id) /* Adjust null message's offset in chunk */ curr_msg->raw = nonnull_msg->raw + - nonnull_msg->raw_size + H5O_SIZEOF_MSGHDR(f); + nonnull_msg->raw_size + H5O_SIZEOF_MSGHDR(f); /* Mark messages dirty */ curr_msg->dirty = TRUE; @@ -3144,9 +3144,9 @@ H5O_alloc_extend_chunk(H5F_t *f, /* If we can extend an existing null message, adjust the delta appropriately */ if(extend_msg >= 0) - delta = MAX(H5O_MIN_SIZE, aligned_size - oh->mesg[extend_msg].raw_size); + delta = aligned_size - oh->mesg[extend_msg].raw_size; else - delta = MAX(H5O_MIN_SIZE, aligned_size + H5O_SIZEOF_MSGHDR(f)); + delta = aligned_size + H5O_SIZEOF_MSGHDR(f); delta = H5O_ALIGN(delta); /* determine whether the chunk can be extended */ @@ -3270,9 +3270,9 @@ H5O_alloc_new_chunk(H5F_t *f, uint8_t *p = NULL; /*ptr into new chunk */ H5O_cont_t *cont = NULL; /*native continuation message */ int chunkno; - unsigned u; haddr_t new_chunk_addr; - unsigned ret_value; /*return value */ + unsigned u; /* Local index variable */ + unsigned ret_value; /* Return value */ FUNC_ENTER_NOAPI_NOINIT(H5O_alloc_new_chunk) @@ -3289,7 +3289,7 @@ H5O_alloc_new_chunk(H5F_t *f, * Prioritize attribute and link messages moving to later chunks, * instead of more "important" messages. */ - cont_size = H5O_ALIGN (H5F_SIZEOF_ADDR(f) + H5F_SIZEOF_SIZE(f)); + cont_size = H5O_ALIGN(H5F_SIZEOF_ADDR(f) + H5F_SIZEOF_SIZE(f)); for(u = 0; u < oh->nmesgs; u++) { int msg_id = oh->mesg[u].type->id; /* Temp. copy of message type ID */ @@ -3347,7 +3347,7 @@ H5O_alloc_new_chunk(H5F_t *f, * multiple of the alignment size. */ size = MAX(H5O_MIN_SIZE, size + H5O_SIZEOF_MSGHDR(f)); - HDassert(size == H5O_ALIGN (size)); + HDassert(size == H5O_ALIGN(size)); /* allocate space in file to hold the new chunk */ new_chunk_addr = H5MF_alloc(f, H5FD_MEM_OHDR, dxpl_id, (hsize_t)size); @@ -3424,8 +3424,7 @@ H5O_alloc_new_chunk(H5F_t *f, oh->mesg[u].dirty = TRUE; oh->mesg[u].native = NULL; oh->mesg[u].raw = oh->mesg[found_null].raw + - cont_size + - H5O_SIZEOF_MSGHDR(f); + cont_size + H5O_SIZEOF_MSGHDR(f); oh->mesg[u].raw_size = oh->mesg[found_null].raw_size - (cont_size + H5O_SIZEOF_MSGHDR(f)); oh->mesg[u].chunkno = oh->mesg[found_null].chunkno; @@ -3496,16 +3495,6 @@ H5O_alloc(H5F_t *f, break; } /* end for */ -#ifdef LATER - /* - * Perhaps if we join adjacent null messages we could make one - * large enough... we leave this as an exercise for future - * programmers :-) This isn't a high priority because when an - * object header is read from disk the null messages are combined - * anyway. - */ -#endif - /* if we didn't find one, then allocate more header space */ if(idx >= oh->nmesgs) { unsigned chunkno; @@ -3618,11 +3607,11 @@ H5O_share (H5F_t *f, hid_t dxpl_id, const H5O_msg_class_t *type, const void *mes /* Encode the message put it in the global heap */ if ((size = (type->raw_size)(f, mesg))>0) { if (NULL==(buf = H5MM_malloc (size))) - HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed"); + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed") if ((type->encode)(f, buf, mesg) < 0) - HGOTO_ERROR(H5E_OHDR, H5E_CANTENCODE, FAIL, "unable to encode message"); + HGOTO_ERROR(H5E_OHDR, H5E_CANTENCODE, FAIL, "unable to encode message") if (H5HG_insert (f, dxpl_id, size, buf, hobj) < 0) - HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, FAIL, "unable to store message in global heap"); + HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, FAIL, "unable to store message in global heap") } done: @@ -4003,7 +3992,7 @@ H5O_encode(H5F_t *f, unsigned char *buf, const void *obj, unsigned type_id) /* Encode */ if((type->encode)(f, buf, obj) < 0) - HGOTO_ERROR (H5E_OHDR, H5E_CANTENCODE, FAIL, "unable to encode message") + HGOTO_ERROR(H5E_OHDR, H5E_CANTENCODE, FAIL, "unable to encode message") done: FUNC_LEAVE_NOAPI(ret_value) @@ -4045,7 +4034,7 @@ H5O_decode(H5F_t *f, hid_t dxpl_id, const unsigned char *buf, unsigned type_id) /* decode */ if((ret_value = (type->decode)(f, dxpl_id, buf)) == NULL) - HGOTO_ERROR (H5E_OHDR, H5E_CANTDECODE, NULL, "unable to decode message") + HGOTO_ERROR(H5E_OHDR, H5E_CANTDECODE, NULL, "unable to decode message") done: FUNC_LEAVE_NOAPI(ret_value) @@ -4166,7 +4155,7 @@ H5O_iterate_real(const H5O_loc_t *loc, const H5O_msg_class_t *type, H5AC_protect /* Protect the object header to iterate over */ if (NULL == (oh = H5AC_protect(loc->file, dxpl_id, H5AC_OHDR, loc->addr, NULL, NULL, prot))) - HGOTO_ERROR(H5E_OHDR, H5E_CANTLOAD, FAIL, "unable to load object header"); + HGOTO_ERROR(H5E_OHDR, H5E_CANTLOAD, FAIL, "unable to load object header") /* Iterate over messages */ for(sequence = 0, idx = 0, idx_msg = &oh->mesg[0]; idx < oh->nmesgs && !ret_value; idx++, idx_msg++) { @@ -4493,7 +4482,7 @@ H5O_loc_free(H5O_loc_t *loc) loc->holding_file = FALSE; if(loc->file->nopen_objs <= 0) { if(H5F_try_close(loc->file) < 0) - HGOTO_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, FAIL, "can't close file"); + HGOTO_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, FAIL, "can't close file") } } @@ -4561,7 +4550,6 @@ H5O_copy_header_real(const H5O_loc_t *oloc_src, H5O_loc_t *oloc_dst /*out */, H5O_t *oh_src = NULL; /* Object header for source object */ H5O_t *oh_dst = NULL; /* Object header for destination object */ unsigned chunkno = 0, mesgno = 0; - size_t hdr_size; haddr_t addr_new = HADDR_UNDEF; H5O_mesg_t *mesg_src; /* Message in source object header */ H5O_mesg_t *mesg_dst; /* Message in source object header */ @@ -4595,9 +4583,6 @@ H5O_copy_header_real(const H5O_loc_t *oloc_src, H5O_loc_t *oloc_dst /*out */, if(H5O_flush_msgs(oloc_src->file, oh_src) < 0) HGOTO_ERROR(H5E_OHDR, H5E_CANTFLUSH, FAIL, "unable to flush object header messages") - /* get the size of the file header of the destination file */ - hdr_size = H5O_SIZEOF_HDR(oloc_dst->file); - /* Allocate the destination object header and fill in header fields */ if(NULL == (oh_dst = H5FL_MALLOC(H5O_t))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed") @@ -4622,6 +4607,11 @@ H5O_copy_header_real(const H5O_loc_t *oloc_src, H5O_loc_t *oloc_dst /*out */, /* '0th' chunk is preceded by object header prefix */ if(0 == chunkno) { + size_t hdr_size; + + /* get the size of the file header of the destination file */ + hdr_size = H5O_SIZEOF_HDR(oloc_dst->file); + /* Allocate file space for the first chunk & object header prefix */ if(HADDR_UNDEF == (addr_new = H5MF_alloc(oloc_dst->file, H5FD_MEM_OHDR, dxpl_id, (hsize_t)hdr_size + chunk_size))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "file allocation failed for object header") @@ -5242,7 +5232,7 @@ H5O_debug_id(unsigned type_id, H5F_t *f, hid_t dxpl_id, const void *mesg, FILE * /* Call the debug method in the class */ if ((ret_value = (type->debug)(f, dxpl_id, mesg, stream, indent, fwidth)) < 0) - HGOTO_ERROR(H5E_OHDR, H5E_BADTYPE, FAIL, "unable to debug message"); + HGOTO_ERROR(H5E_OHDR, H5E_BADTYPE, FAIL, "unable to debug message") done: FUNC_LEAVE_NOAPI(ret_value); @@ -5289,21 +5279,21 @@ H5O_debug_real(H5F_t *f, hid_t dxpl_id, H5O_t *oh, haddr_t addr, FILE *stream, i HDfprintf(stream, "%*s%-*s %d\n", indent, "", fwidth, "Dirty:", (int) (oh->cache_info.is_dirty)); - HDfprintf(stream, "%*s%-*s %d\n", indent, "", fwidth, + HDfprintf(stream, "%*s%-*s %u\n", indent, "", fwidth, "Version:", - (int) (oh->version)); + oh->version); HDfprintf(stream, "%*s%-*s %u\n", indent, "", fwidth, "Header size (in bytes):", (unsigned) H5O_SIZEOF_HDR(f)); HDfprintf(stream, "%*s%-*s %d\n", indent, "", fwidth, "Number of links:", - (int) (oh->nlink)); - HDfprintf(stream, "%*s%-*s %u (%u)\n", indent, "", fwidth, + oh->nlink); + HDfprintf(stream, "%*s%-*s %Zu (%Zu)\n", indent, "", fwidth, "Number of messages (allocated):", - (unsigned) (oh->nmesgs), (unsigned) (oh->alloc_nmesgs)); - HDfprintf(stream, "%*s%-*s %u (%u)\n", indent, "", fwidth, + oh->nmesgs, oh->alloc_nmesgs); + HDfprintf(stream, "%*s%-*s %Zu (%Zu)\n", indent, "", fwidth, "Number of chunks (allocated):", - (unsigned) (oh->nchunks), (unsigned) (oh->alloc_nchunks)); + oh->nchunks, oh->alloc_nchunks); /* debug each chunk */ for (i=0, chunk_total=0; i < oh->nchunks; i++) { @@ -5327,7 +5317,7 @@ H5O_debug_real(H5F_t *f, hid_t dxpl_id, H5O_t *oh, haddr_t addr, FILE *stream, i /* debug each message */ if (NULL==(sequence = H5MM_calloc(NELMTS(H5O_msg_class_g)*sizeof(int)))) - HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed"); + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed") for (i=0, mesg_total=0; i < oh->nmesgs; i++) { mesg_total += H5O_SIZEOF_MSGHDR(f) + oh->mesg[i].raw_size; HDfprintf(stream, "%*sMessage %d...\n", indent, "", i); diff --git a/src/H5Oattr.c b/src/H5Oattr.c index 24e4769..02299d4 100644 --- a/src/H5Oattr.c +++ b/src/H5Oattr.c @@ -29,19 +29,19 @@ #include "H5Spkg.h" /* Dataspaces */ /* PRIVATE PROTOTYPES */ -static herr_t H5O_attr_encode (H5F_t *f, uint8_t *p, const void *mesg); -static void *H5O_attr_decode (H5F_t *f, hid_t dxpl_id, const uint8_t *p); -static void *H5O_attr_copy (const void *_mesg, void *_dest, unsigned update_flags); -static size_t H5O_attr_size (const H5F_t *f, const void *_mesg); -static herr_t H5O_attr_reset (void *_mesg); -static herr_t H5O_attr_free (void *mesg); -static herr_t H5O_attr_delete (H5F_t *f, hid_t dxpl_id, const void *_mesg, hbool_t adj_link); +static herr_t H5O_attr_encode(H5F_t *f, uint8_t *p, const void *mesg); +static void *H5O_attr_decode(H5F_t *f, hid_t dxpl_id, const uint8_t *p); +static void *H5O_attr_copy(const void *_mesg, void *_dest, unsigned update_flags); +static size_t H5O_attr_size(const H5F_t *f, const void *_mesg); +static herr_t H5O_attr_reset(void *_mesg); +static herr_t H5O_attr_free(void *mesg); +static herr_t H5O_attr_delete(H5F_t *f, hid_t dxpl_id, const void *_mesg, hbool_t adj_link); static herr_t H5O_attr_link(H5F_t *f, hid_t dxpl_id, const void *_mesg); static herr_t H5O_attr_pre_copy_file(H5F_t *file_src, const H5O_msg_class_t *type, void *mesg_src, hbool_t *deleted, const H5O_copy_t *cpy_info, void *udata); static void *H5O_attr_copy_file(H5F_t *file_src, void *native_src, H5F_t *file_dst, hid_t dxpl_id, H5O_copy_t *cpy_info, void *udata); -static herr_t H5O_attr_debug (H5F_t *f, hid_t dxpl_id, const void *_mesg, +static herr_t H5O_attr_debug(H5F_t *f, hid_t dxpl_id, const void *_mesg, FILE * stream, int indent, int fwidth); /* This message derives from H5O message class */ @@ -331,16 +331,15 @@ H5O_attr_encode(H5F_t *f, uint8_t *p, const void *mesg) * Also add several "reserved" fields to pad to 16 bytes. */ if(version >= H5O_ATTR_VERSION_3) - *p++ = attr->encoding; + *p++ = attr->encoding; - /* - * Write the name including null terminator padded to the correct number - * of bytes. - */ + /* Write the name including null terminator */ HDmemcpy(p, attr->name, name_len); - HDmemset(p + name_len, 0, H5O_ALIGN(name_len) - name_len); - if(version < H5O_ATTR_VERSION_2) + if(version < H5O_ATTR_VERSION_2) { + /* Pad to the correct number of bytes */ + HDmemset(p + name_len, 0, H5O_ALIGN(name_len) - name_len); p += H5O_ALIGN(name_len); + } /* end if */ else p += name_len; diff --git a/src/H5Ocache.c b/src/H5Ocache.c index 23f714a..7970e70 100644 --- a/src/H5Ocache.c +++ b/src/H5Ocache.c @@ -40,7 +40,7 @@ static H5O_t *H5O_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void *_udata void *_udata2); static herr_t H5O_flush(H5F_t *f, hid_t dxpl_id, hbool_t destroy, haddr_t addr, H5O_t *oh); static herr_t H5O_clear(H5F_t *f, H5O_t *oh, hbool_t destroy); -static herr_t H5O_compute_size(const H5F_t *f, const H5O_t *oh, size_t *size_ptr); +static herr_t H5O_size(const H5F_t *f, const H5O_t *oh, size_t *size_ptr); /* H5O inherits cache-like properties from H5AC */ const H5AC_class_t H5AC_OHDR[1] = {{ @@ -49,7 +49,7 @@ const H5AC_class_t H5AC_OHDR[1] = {{ (H5AC_flush_func_t)H5O_flush, (H5AC_dest_func_t)H5O_dest, (H5AC_clear_func_t)H5O_clear, - (H5AC_size_func_t)H5O_compute_size, + (H5AC_size_func_t)H5O_size, }}; @@ -89,7 +89,7 @@ H5O_flush_msgs(H5F_t *f, H5O_t *oh) id = curr_msg->type->id; UINT16ENCODE(p, id); - HDassert(curr_msg->raw_size < H5O_MAX_SIZE); + HDassert(curr_msg->raw_size < H5O_MESG_MAX_SIZE); UINT16ENCODE(p, curr_msg->raw_size); *p++ = curr_msg->flags; *p++ = 0; /*reserved*/ @@ -181,19 +181,19 @@ H5O_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void UNUSED * _udata1, /* allocate ohdr and init chunk list */ if (NULL==(oh = H5FL_CALLOC(H5O_t))) - HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed"); + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") - /* read fixed-lenth part of object header */ + /* read fixed-length part of object header */ hdr_size = H5O_SIZEOF_HDR(f); assert(hdr_size<=sizeof(buf)); if (H5F_block_read(f, H5FD_MEM_OHDR, addr, hdr_size, dxpl_id, buf) < 0) - HGOTO_ERROR(H5E_OHDR, H5E_READERROR, NULL, "unable to read object header"); + HGOTO_ERROR(H5E_OHDR, H5E_READERROR, NULL, "unable to read object header") p = buf; /* decode version */ oh->version = *p++; if (H5O_VERSION != oh->version) - HGOTO_ERROR(H5E_OHDR, H5E_VERSION, NULL, "bad object header version number"); + HGOTO_ERROR(H5E_OHDR, H5E_VERSION, NULL, "bad object header version number") /* reserved */ p++; @@ -210,8 +210,8 @@ H5O_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void UNUSED * _udata1, /* build the message array */ oh->alloc_nmesgs = nmesgs; - if (NULL==(oh->mesg=H5FL_SEQ_CALLOC(H5O_mesg_t,(size_t)oh->alloc_nmesgs))) - HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed"); + if (NULL==(oh->mesg=H5FL_SEQ_MALLOC(H5O_mesg_t,(size_t)oh->alloc_nmesgs))) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") /* read each chunk from disk */ while(H5F_addr_defined(chunk_addr)) { @@ -221,7 +221,7 @@ H5O_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void UNUSED * _udata1, H5O_chunk_t *x = H5FL_SEQ_REALLOC (H5O_chunk_t, oh->chunk, (size_t)na); if(!x) - HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed"); + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") oh->alloc_nchunks = na; oh->chunk = x; } /* end if */ @@ -232,9 +232,9 @@ H5O_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void UNUSED * _udata1, oh->chunk[chunkno].addr = chunk_addr; oh->chunk[chunkno].size = chunk_size; if(NULL==(oh->chunk[chunkno].image = H5FL_BLK_MALLOC(chunk_image, chunk_size))) - HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed"); + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") if(H5F_block_read(f, H5FD_MEM_OHDR, chunk_addr, chunk_size, dxpl_id, oh->chunk[chunkno].image) < 0) - HGOTO_ERROR(H5E_OHDR, H5E_READERROR, NULL, "unable to read object header data"); + HGOTO_ERROR(H5E_OHDR, H5E_READERROR, NULL, "unable to read object header data") /* load messages from this chunk */ for(p = oh->chunk[chunkno].image; p < oh->chunk[chunkno].image + chunk_size; p += mesg_size) { @@ -267,7 +267,7 @@ H5O_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void UNUSED * _udata1, } else { /* new message */ if (oh->nmesgs >= nmesgs) - HGOTO_ERROR(H5E_OHDR, H5E_CANTLOAD, NULL, "corrupt object header - too many messages"); + HGOTO_ERROR(H5E_OHDR, H5E_CANTLOAD, NULL, "corrupt object header - too many messages") mesgno = oh->nmesgs++; oh->mesg[mesgno].type = H5O_msg_class_g[id]; oh->mesg[mesgno].dirty = FALSE; @@ -369,14 +369,13 @@ H5O_flush(H5F_t *f, hid_t dxpl_id, hbool_t destroy, haddr_t addr, H5O_t *oh) UINT32ENCODE(p, oh->chunk[0].size); /* zero to alignment */ - HDmemset (p, 0, (size_t)(H5O_SIZEOF_HDR(f)-12)); + HDmemset(p, 0, (size_t)(H5O_SIZEOF_HDR(f)-12)); /* write the object header prefix */ /* Check if we can combine the object header prefix & the first chunk into one I/O operation */ - if(oh->chunk[0].dirty && (addr + H5O_SIZEOF_HDR(f)) == oh->chunk[0].addr) { + if(oh->chunk[0].dirty && (addr + H5O_SIZEOF_HDR(f)) == oh->chunk[0].addr) combine = TRUE; - } /* end if */ else { if(H5F_block_write(f, H5FD_MEM_OHDR, addr, (size_t)H5O_SIZEOF_HDR(f), dxpl_id, buf) < 0) HGOTO_ERROR(H5E_OHDR, H5E_WRITEERROR, FAIL, "unable to write object header hdr to disk") @@ -388,7 +387,7 @@ H5O_flush(H5F_t *f, hid_t dxpl_id, hbool_t destroy, haddr_t addr, H5O_t *oh) HDassert(H5F_addr_defined(oh->chunk[u].addr)); if(u == 0 && combine) { /* Allocate space for the combined prefix and first chunk */ - if((p = H5FL_BLK_MALLOC(chunk_image,(H5O_SIZEOF_HDR(f)+oh->chunk[u].size))) == NULL) + if((p = H5FL_BLK_MALLOC(chunk_image, (H5O_SIZEOF_HDR(f) + oh->chunk[u].size))) == NULL) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed") /* Copy in the prefix */ @@ -516,7 +515,7 @@ H5O_clear(H5F_t *f, H5O_t *oh, hbool_t destroy) if (destroy) if (H5O_dest(f, oh) < 0) - HGOTO_ERROR(H5E_OHDR, H5E_CANTFREE, FAIL, "unable to destroy object header data"); + HGOTO_ERROR(H5E_OHDR, H5E_CANTFREE, FAIL, "unable to destroy object header data") done: FUNC_LEAVE_NOAPI(ret_value); @@ -524,18 +523,12 @@ done: /*------------------------------------------------------------------------- - * Function: H5O_compute_size + * Function: H5O_size * * Purpose: Compute the size in bytes of the specified instance of * H5O_t on disk, and return it in *len_ptr. On failure, * the value of *len_ptr is undefined. * - * The value returned will probably be low unless the object - * has just been flushed, as we simply total up the size of - * the header with the sizes of the chunks. Thus any message - * that has been added since the last flush will not be - * reflected in the total. - * * Return: Non-negative on success/Negative on failure * * Programmer: John Mainzer @@ -544,27 +537,27 @@ done: *------------------------------------------------------------------------- */ static herr_t -H5O_compute_size(const H5F_t *f, const H5O_t *oh, size_t *size_ptr) +H5O_size(const H5F_t *f, const H5O_t *oh, size_t *size_ptr) { - unsigned u; - size_t size; + size_t size; /* Running sum of the object header's size */ + unsigned u; /* Local index variable */ - FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5O_compute_size); + FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5O_size) /* check args */ HDassert(f); HDassert(oh); HDassert(size_ptr); + /* Size of object header "prefix" */ size = H5O_SIZEOF_HDR(f); - for (u = 0; u < oh->nchunks; u++) + /* Add sizes of all the chunks */ + for(u = 0; u < oh->nchunks; u++) size += oh->chunk[u].size; - HDassert(size >= H5O_SIZEOF_HDR(f)); - *size_ptr = size; - FUNC_LEAVE_NOAPI(SUCCEED); -} /* H5O_compute_size() */ + FUNC_LEAVE_NOAPI(SUCCEED) +} /* H5O_size() */ diff --git a/src/H5Opkg.h b/src/H5Opkg.h index 56353ed..62dc8ed 100644 --- a/src/H5Opkg.h +++ b/src/H5Opkg.h @@ -34,7 +34,7 @@ #define H5O_ALIGN(X) (8*(((X)+8-1)/8)) /* Object header macros */ -#define H5O_NMESGS 32 /*initial number of messages */ +#define H5O_NMESGS 8 /*initial number of messages */ #define H5O_NCHUNKS 2 /*initial number of chunks */ /* Version of object header structure */ @@ -45,7 +45,7 @@ */ #define H5O_SIZEOF_HDR(F) \ H5O_ALIGN(1 + /*version number */ \ - 1 + /*alignment */ \ + 1 + /*reserved */ \ 2 + /*number of messages */ \ 4 + /*reference count */ \ 4) /*header data size */ diff --git a/src/H5Oprivate.h b/src/H5Oprivate.h index fd226f1..2912ff1 100644 --- a/src/H5Oprivate.h +++ b/src/H5Oprivate.h @@ -46,8 +46,7 @@ typedef struct H5O_msg_class_t H5O_msg_class_t; typedef struct H5O_t H5O_t; /* Object header macros */ -#define H5O_MIN_SIZE H5O_ALIGN(32) /*min obj header data size */ -#define H5O_MAX_SIZE 65536 /*max obj header data size */ +#define H5O_MESG_MAX_SIZE 65536 /*max obj header message size */ #define H5O_NEW_MESG (-1) /*new message */ #define H5O_ALL (-1) /* Operate on all messages of type */ #define H5O_FIRST (-2) /* Operate on first message of type */ -- cgit v0.12