summaryrefslogtreecommitdiffstats
path: root/src/H5O.c
diff options
context:
space:
mode:
authorQuincey Koziol <koziol@hdfgroup.org>2001-07-10 21:19:18 (GMT)
committerQuincey Koziol <koziol@hdfgroup.org>2001-07-10 21:19:18 (GMT)
commit990fadfbe55353383639f0151990ec375fbe18cb (patch)
treea07f3b3215057bad7d46cbb9e26a4699b1fc8040 /src/H5O.c
parent0c1c23245d103927c5d59c67b84526974e6217af (diff)
downloadhdf5-990fadfbe55353383639f0151990ec375fbe18cb.zip
hdf5-990fadfbe55353383639f0151990ec375fbe18cb.tar.gz
hdf5-990fadfbe55353383639f0151990ec375fbe18cb.tar.bz2
[svn-r4181] Purpose:
Bug Fix, Code Cleanup, Code Optimization, etc. Description: Fold in the hyperslab speedups, clean up compile warnings and change a few things from using 'unsigned' or 'hsize_t' to use 'size_t' instead. Platforms tested: FreeBSD 4.3 (hawkwind), Solaris 2.7 (arabica), Irix64 6.5 (modi4)
Diffstat (limited to 'src/H5O.c')
-rw-r--r--src/H5O.c511
1 files changed, 267 insertions, 244 deletions
diff --git a/src/H5O.c b/src/H5O.c
index acf533e..a917ad7 100644
--- a/src/H5O.c
+++ b/src/H5O.c
@@ -37,12 +37,12 @@
static herr_t H5O_flush(H5F_t *f, hbool_t destroy, haddr_t addr, H5O_t *oh);
static H5O_t *H5O_load(H5F_t *f, haddr_t addr, const void *_udata1,
void *_udata2);
-static intn H5O_find_in_ohdr(H5F_t *f, haddr_t addr,
+static uintn H5O_find_in_ohdr(H5F_t *f, haddr_t addr,
const H5O_class_t **type_p, intn sequence);
-static intn H5O_alloc(H5F_t *f, H5O_t *oh, const H5O_class_t *type,
+static uintn H5O_alloc(H5F_t *f, H5O_t *oh, const H5O_class_t *type,
size_t size);
-static intn H5O_alloc_extend_chunk(H5O_t *oh, intn chunkno, size_t size);
-static intn H5O_alloc_new_chunk(H5F_t *f, H5O_t *oh, size_t size);
+static uintn H5O_alloc_extend_chunk(H5O_t *oh, uintn chunkno, size_t size);
+static uintn H5O_alloc_new_chunk(H5F_t *f, H5O_t *oh, size_t size);
static herr_t H5O_touch_oh(H5F_t *f, H5O_t *oh, hbool_t force);
/* H5O inherits cache-like properties from H5AC */
@@ -353,9 +353,11 @@ H5O_load(H5F_t *f, haddr_t addr, const void UNUSED *_udata1,
H5O_t *ret_value = NULL;
uint8_t buf[16], *p;
size_t mesg_size;
- hsize_t hdr_size;
+ size_t hdr_size;
uintn id;
- intn mesgno, chunkno, curmesg = 0, nmesgs;
+ intn mesgno;
+ uintn curmesg = 0, nmesgs;
+ uintn chunkno;
haddr_t chunk_addr;
size_t chunk_size;
H5O_cont_t *cont = NULL;
@@ -415,13 +417,14 @@ H5O_load(H5F_t *f, haddr_t addr, const void UNUSED *_udata1,
/* increase chunk array size */
if (oh->nchunks >= oh->alloc_nchunks) {
- hsize_t na = oh->alloc_nchunks + H5O_NCHUNKS;
+ size_t na = oh->alloc_nchunks + H5O_NCHUNKS;
H5O_chunk_t *x = H5FL_ARR_REALLOC (H5O_chunk_t, oh->chunk, na);
+
if (!x) {
- HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL,
+ HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL,
"memory allocation failed");
}
- oh->alloc_nchunks = (intn)na;
+ oh->alloc_nchunks = na;
oh->chunk = x;
}
@@ -434,7 +437,7 @@ H5O_load(H5F_t *f, haddr_t addr, const void UNUSED *_udata1,
HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL,
"memory allocation failed");
}
- if (H5F_block_read(f, H5FD_MEM_OHDR, chunk_addr, (hsize_t)chunk_size, H5P_DEFAULT,
+ if (H5F_block_read(f, H5FD_MEM_OHDR, chunk_addr, chunk_size, H5P_DEFAULT,
oh->chunk[chunkno].image) < 0) {
HGOTO_ERROR(H5E_OHDR, H5E_READERROR, NULL,
"unable to read object header data");
@@ -488,6 +491,7 @@ H5O_load(H5F_t *f, haddr_t addr, const void UNUSED *_udata1,
curmesg++) {
if (H5O_CONT_ID == oh->mesg[curmesg].type->id) {
uint8_t *p2 = oh->mesg[curmesg].raw;
+
cont = (H5O_CONT->decode) (f, p2, NULL);
oh->mesg[curmesg].native = cont;
chunk_addr = cont->addr;
@@ -503,10 +507,10 @@ done:
/*
* Free resources.
*/
- int i;
+ uintn u;
- for (i = 0; i < oh->nchunks; i++)
- oh->chunk[i].image = H5FL_BLK_FREE(chunk_image,oh->chunk[i].image);
+ for (u = 0; u < oh->nchunks; u++)
+ oh->chunk[u].image = H5FL_BLK_FREE(chunk_image,oh->chunk[u].image);
oh->chunk = H5FL_ARR_FREE(H5O_chunk_t,oh->chunk);
oh->mesg = H5FL_ARR_FREE(H5O_mesg_t,oh->mesg);
H5FL_FREE(H5O_t,oh);
@@ -542,7 +546,8 @@ static herr_t
H5O_flush(H5F_t *f, hbool_t destroy, haddr_t addr, H5O_t *oh)
{
uint8_t buf[16], *p;
- intn i, id;
+ intn id;
+ uintn u;
H5O_cont_t *cont = NULL;
herr_t (*encode)(H5F_t*, uint8_t*, const void*) = NULL;
uintn combine=0; /* Whether to combine the object header prefix & the first chunk */
@@ -577,125 +582,125 @@ H5O_flush(H5F_t *f, hbool_t destroy, haddr_t addr, H5O_t *oh)
HDmemset (p, 0, 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) {
- combine=1;
- } /* end if */
- else {
+
+ /* 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) {
+ combine=1;
+ } /* end if */
+ else {
#ifdef H5_HAVE_PARALLEL
- if (IS_H5FD_MPIO(f))
- H5FD_mpio_tas_allsame(f->shared->lf, TRUE); /*only p0 will write*/
+ if (IS_H5FD_MPIO(f))
+ H5FD_mpio_tas_allsame(f->shared->lf, TRUE); /*only p0 will write*/
#endif /* H5_HAVE_PARALLEL */
- if (H5F_block_write(f, H5FD_MEM_OHDR, addr, (hsize_t)H5O_SIZEOF_HDR(f),
- H5P_DEFAULT, buf) < 0) {
- HRETURN_ERROR(H5E_OHDR, H5E_WRITEERROR, FAIL,
- "unable to write object header hdr to disk");
- }
- } /* end else */
-
- /* encode messages */
- for (i = 0; i < oh->nmesgs; i++) {
- if (oh->mesg[i].dirty) {
- p = oh->mesg[i].raw - H5O_SIZEOF_MSGHDR(f);
-
- id = oh->mesg[i].type->id;
- UINT16ENCODE(p, id);
- assert (oh->mesg[i].raw_size<65536);
- UINT16ENCODE(p, oh->mesg[i].raw_size);
- *p++ = oh->mesg[i].flags;
- *p++ = 0; /*reserved*/
- *p++ = 0; /*reserved*/
- *p++ = 0; /*reserved*/
+ if (H5F_block_write(f, H5FD_MEM_OHDR, addr, H5O_SIZEOF_HDR(f),
+ H5P_DEFAULT, buf) < 0) {
+ HRETURN_ERROR(H5E_OHDR, H5E_WRITEERROR, FAIL,
+ "unable to write object header hdr to disk");
+ }
+ } /* end else */
- if (oh->mesg[i].native) {
- assert(oh->mesg[i].type->encode);
-
- /* allocate file space for chunks that have none yet */
- if (H5O_CONT_ID == oh->mesg[i].type->id &&
- !H5F_addr_defined(((H5O_cont_t *)(oh->mesg[i].native))->addr)) {
- cont = (H5O_cont_t *) (oh->mesg[i].native);
- assert(cont->chunkno >= 0);
- assert(cont->chunkno < oh->nchunks);
- assert(!H5F_addr_defined(oh->chunk[cont->chunkno].addr));
- cont->size = oh->chunk[cont->chunkno].size;
- if (HADDR_UNDEF==(cont->addr=H5MF_alloc(f,
- H5FD_MEM_OHDR, (hsize_t)cont->size))) {
- HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
- "unable to allocate space for object header data");
- }
- oh->chunk[cont->chunkno].addr = cont->addr;
- }
+ /* encode messages */
+ for (u = 0; u < oh->nmesgs; u++) {
+ if (oh->mesg[u].dirty) {
+ p = oh->mesg[u].raw - H5O_SIZEOF_MSGHDR(f);
+
+ id = oh->mesg[u].type->id;
+ UINT16ENCODE(p, id);
+ assert (oh->mesg[u].raw_size<65536);
+ UINT16ENCODE(p, oh->mesg[u].raw_size);
+ *p++ = oh->mesg[u].flags;
+ *p++ = 0; /*reserved*/
+ *p++ = 0; /*reserved*/
+ *p++ = 0; /*reserved*/
- /*
- * Encode the message. If the message is shared then we
- * encode a Shared Object message instead of the object
- * which is being shared.
- */
- assert(oh->mesg[i].raw >=
- oh->chunk[oh->mesg[i].chunkno].image);
- assert (oh->mesg[i].raw_size ==
- H5O_ALIGN (oh->mesg[i].raw_size));
- assert(oh->mesg[i].raw + oh->mesg[i].raw_size <=
- oh->chunk[oh->mesg[i].chunkno].image +
- oh->chunk[oh->mesg[i].chunkno].size);
- if (oh->mesg[i].flags & H5O_FLAG_SHARED) {
- encode = H5O_SHARED->encode;
- } else {
- encode = oh->mesg[i].type->encode;
- }
- if ((encode)(f, oh->mesg[i].raw, oh->mesg[i].native)<0) {
- HRETURN_ERROR(H5E_OHDR, H5E_CANTENCODE, FAIL,
- "unable to encode object header message");
+ if (oh->mesg[u].native) {
+ assert(oh->mesg[u].type->encode);
+
+ /* allocate file space for chunks that have none yet */
+ if (H5O_CONT_ID == oh->mesg[u].type->id &&
+ !H5F_addr_defined(((H5O_cont_t *)(oh->mesg[u].native))->addr)) {
+ cont = (H5O_cont_t *) (oh->mesg[u].native);
+ assert(cont->chunkno < oh->nchunks);
+ assert(!H5F_addr_defined(oh->chunk[cont->chunkno].addr));
+ cont->size = oh->chunk[cont->chunkno].size;
+ if (HADDR_UNDEF==(cont->addr=H5MF_alloc(f,
+ H5FD_MEM_OHDR, (hsize_t)cont->size))) {
+ HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
+ "unable to allocate space for object header data");
+ }
+ oh->chunk[cont->chunkno].addr = cont->addr;
+ }
+
+ /*
+ * Encode the message. If the message is shared then we
+ * encode a Shared Object message instead of the object
+ * which is being shared.
+ */
+ assert(oh->mesg[u].raw >=
+ oh->chunk[oh->mesg[u].chunkno].image);
+ assert (oh->mesg[u].raw_size ==
+ H5O_ALIGN (oh->mesg[u].raw_size));
+ assert(oh->mesg[u].raw + oh->mesg[u].raw_size <=
+ oh->chunk[oh->mesg[u].chunkno].image +
+ oh->chunk[oh->mesg[u].chunkno].size);
+ if (oh->mesg[u].flags & H5O_FLAG_SHARED) {
+ encode = H5O_SHARED->encode;
+ } else {
+ encode = oh->mesg[u].type->encode;
+ }
+ if ((encode)(f, oh->mesg[u].raw, oh->mesg[u].native)<0) {
+ HRETURN_ERROR(H5E_OHDR, H5E_CANTENCODE, FAIL,
+ "unable to encode object header message");
+ }
}
- }
- oh->mesg[i].dirty = FALSE;
- oh->chunk[oh->mesg[i].chunkno].dirty = TRUE;
+ oh->mesg[u].dirty = FALSE;
+ oh->chunk[oh->mesg[u].chunkno].dirty = TRUE;
}
}
/* write each chunk to disk */
- for (i = 0; i < oh->nchunks; i++) {
- if (oh->chunk[i].dirty) {
- assert(H5F_addr_defined(oh->chunk[i].addr));
- if(i==0 && combine) {
- /* Allocate space for the combined prefix and first chunk */
- if((p=H5FL_BLK_ALLOC(chunk_image,(H5O_SIZEOF_HDR(f)+oh->chunk[i].size),0))==NULL)
- HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed");
+ for (u = 0; u < oh->nchunks; u++) {
+ if (oh->chunk[u].dirty) {
+ assert(H5F_addr_defined(oh->chunk[u].addr));
+ if(u==0 && combine) {
+ /* Allocate space for the combined prefix and first chunk */
+ if((p=H5FL_BLK_ALLOC(chunk_image,(H5O_SIZEOF_HDR(f)+oh->chunk[u].size),0))==NULL)
+ HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed");
- /* Copy in the prefix */
- HDmemcpy(p,buf,H5O_SIZEOF_HDR(f));
+ /* Copy in the prefix */
+ HDmemcpy(p,buf,H5O_SIZEOF_HDR(f));
- /* Copy in the first chunk */
- HDmemcpy(p+H5O_SIZEOF_HDR(f),oh->chunk[i].image,oh->chunk[i].size);
+ /* Copy in the first chunk */
+ HDmemcpy(p+H5O_SIZEOF_HDR(f),oh->chunk[u].image,oh->chunk[u].size);
- /* Write the combined prefix/chunk out */
+ /* Write the combined prefix/chunk out */
#ifdef H5_HAVE_PARALLEL
- if (IS_H5FD_MPIO(f))
- H5FD_mpio_tas_allsame(f->shared->lf, TRUE); /*only p0 write*/
+ if (IS_H5FD_MPIO(f))
+ H5FD_mpio_tas_allsame(f->shared->lf, TRUE); /*only p0 write*/
#endif /* H5_HAVE_PARALLEL */
- if (H5F_block_write(f, H5FD_MEM_OHDR, addr,
- (hsize_t)(H5O_SIZEOF_HDR(f)+oh->chunk[i].size),
- H5P_DEFAULT, p) < 0) {
- HRETURN_ERROR(H5E_OHDR, H5E_WRITEERROR, FAIL,
- "unable to write object header data to disk");
+ if (H5F_block_write(f, H5FD_MEM_OHDR, addr,
+ (H5O_SIZEOF_HDR(f)+oh->chunk[u].size),
+ H5P_DEFAULT, p) < 0) {
+ HRETURN_ERROR(H5E_OHDR, H5E_WRITEERROR, FAIL,
+ "unable to write object header data to disk");
+ } /* end if */
+
+ /* Release the memory for the combined prefix/chunk */
+ p = H5FL_BLK_FREE(chunk_image,p);
} /* end if */
-
- /* Release the memory for the combined prefix/chunk */
- p = H5FL_BLK_FREE(chunk_image,p);
- } /* end if */
- else {
+ else {
#ifdef H5_HAVE_PARALLEL
- if (IS_H5FD_MPIO(f))
- H5FD_mpio_tas_allsame(f->shared->lf, TRUE); /*only p0 write*/
+ if (IS_H5FD_MPIO(f))
+ H5FD_mpio_tas_allsame(f->shared->lf, TRUE); /*only p0 write*/
#endif /* H5_HAVE_PARALLEL */
- if (H5F_block_write(f, H5FD_MEM_OHDR, oh->chunk[i].addr,
- (hsize_t)(oh->chunk[i].size),
- H5P_DEFAULT, oh->chunk[i].image) < 0) {
- HRETURN_ERROR(H5E_OHDR, H5E_WRITEERROR, FAIL,
- "unable to write object header data to disk");
- } /* end if */
- } /* end else */
- oh->chunk[i].dirty = FALSE;
+ if (H5F_block_write(f, H5FD_MEM_OHDR, oh->chunk[u].addr,
+ (oh->chunk[u].size),
+ H5P_DEFAULT, oh->chunk[u].image) < 0) {
+ HRETURN_ERROR(H5E_OHDR, H5E_WRITEERROR, FAIL,
+ "unable to write object header data to disk");
+ } /* end if */
+ } /* end else */
+ oh->chunk[u].dirty = FALSE;
} /* end if */
} /* end for */
oh->dirty = FALSE;
@@ -703,23 +708,23 @@ H5O_flush(H5F_t *f, hbool_t destroy, haddr_t addr, H5O_t *oh)
if (destroy) {
/* destroy chunks */
- /*the conditional below is because of the microsoft c run time library
+ /*the conditional below is because of the microsoft c run time library
it calls its own version of malloc and free and does checks on the mem.
causes problems with this code so i am taking it out for the win32 debug
version until i can figure out a way around it*/
/* I commented this back in to use the new free list routines - QAK 3/23/00 */
/* #if !defined(WIN32) && !defined(_DEBUG) */
- for (i = 0; i < oh->nchunks; i++)
- oh->chunk[i].image = H5FL_BLK_FREE(chunk_image,oh->chunk[i].image);
+ for (u = 0; u < oh->nchunks; u++)
+ oh->chunk[u].image = H5FL_BLK_FREE(chunk_image,oh->chunk[u].image);
/* #endif */
oh->chunk = H5FL_ARR_FREE(H5O_chunk_t,oh->chunk);
/* destroy messages */
- for (i = 0; i < oh->nmesgs; i++) {
- if (oh->mesg[i].flags & H5O_FLAG_SHARED) {
- H5O_free(H5O_SHARED, oh->mesg[i].native);
+ for (u = 0; u < oh->nmesgs; u++) {
+ if (oh->mesg[u].flags & H5O_FLAG_SHARED) {
+ H5O_free(H5O_SHARED, oh->mesg[u].native);
} else {
- H5O_free(oh->mesg[i].type, oh->mesg[i].native);
+ H5O_free(oh->mesg[u].type, oh->mesg[u].native);
}
}
oh->mesg = H5FL_ARR_FREE(H5O_mesg_t,oh->mesg);
@@ -931,7 +936,8 @@ intn
H5O_count (H5G_entry_t *ent, const H5O_class_t *type)
{
H5O_t *oh = NULL;
- intn i, acc;
+ intn acc;
+ uintn u;
FUNC_ENTER (H5O_count, FAIL);
@@ -947,8 +953,9 @@ H5O_count (H5G_entry_t *ent, const H5O_class_t *type)
"unable to load object header");
}
- for (i=acc=0; i<oh->nmesgs; i++) {
- if (oh->mesg[i].type==type) acc++;
+ for (u=acc=0; u<oh->nmesgs; u++) {
+ if (oh->mesg[u].type==type)
+ acc++;
}
FUNC_LEAVE (acc);
@@ -979,7 +986,7 @@ htri_t
H5O_exists(H5G_entry_t *ent, const H5O_class_t *type, intn sequence)
{
H5O_t *oh=NULL;
- intn i;
+ uintn u;
FUNC_ENTER(H5O_exists, FAIL);
assert(ent);
@@ -994,9 +1001,11 @@ H5O_exists(H5G_entry_t *ent, const H5O_class_t *type, intn sequence)
}
/* Scan through the messages looking for the right one */
- for (i=0; i<oh->nmesgs; i++) {
- if (type->id!=oh->mesg[i].type->id) continue;
- if (--sequence<0) break;
+ for (u=0; u<oh->nmesgs; u++) {
+ if (type->id!=oh->mesg[u].type->id)
+ continue;
+ if (--sequence<0)
+ break;
}
FUNC_LEAVE(sequence<0);
@@ -1146,15 +1155,15 @@ H5O_read(H5G_entry_t *ent, const H5O_class_t *type, intn sequence, void *mesg)
* The ADDR argument is passed by value.
*-------------------------------------------------------------------------
*/
-static intn
+static uintn
H5O_find_in_ohdr(H5F_t *f, haddr_t addr, const H5O_class_t **type_p,
intn sequence)
{
H5O_t *oh = NULL;
- int i;
+ uintn u;
const H5O_class_t *type = NULL;
- FUNC_ENTER(H5O_find_in_ohdr, FAIL);
+ FUNC_ENTER(H5O_find_in_ohdr, UFAIL);
/* Check args */
assert(f);
@@ -1163,17 +1172,19 @@ H5O_find_in_ohdr(H5F_t *f, haddr_t addr, const H5O_class_t **type_p,
/* Load the object header */
if (NULL == (oh = H5AC_find(f, H5AC_OHDR, addr, NULL, NULL))) {
- HRETURN_ERROR(H5E_OHDR, H5E_CANTLOAD, FAIL,
+ HRETURN_ERROR(H5E_OHDR, H5E_CANTLOAD, UFAIL,
"unable to load object header");
}
/* Scan through the messages looking for the right one */
- for (i = 0; i < oh->nmesgs; i++) {
- if (*type_p && (*type_p)->id != oh->mesg[i].type->id) continue;
- if (--sequence < 0) break;
+ for (u = 0; u < oh->nmesgs; u++) {
+ if (*type_p && (*type_p)->id != oh->mesg[u].type->id)
+ continue;
+ if (--sequence < 0)
+ break;
}
if (sequence >= 0) {
- HRETURN_ERROR(H5E_OHDR, H5E_NOTFOUND, FAIL,
+ HRETURN_ERROR(H5E_OHDR, H5E_NOTFOUND, UFAIL,
"unable to find object header message");
}
@@ -1181,16 +1192,16 @@ H5O_find_in_ohdr(H5F_t *f, haddr_t addr, const H5O_class_t **type_p,
* Decode the message if necessary. If the message is shared then decode
* a shared message, ignoring the message type.
*/
- if (oh->mesg[i].flags & H5O_FLAG_SHARED) {
+ if (oh->mesg[u].flags & H5O_FLAG_SHARED) {
type = H5O_SHARED;
} else {
- type = oh->mesg[i].type;
+ type = oh->mesg[u].type;
}
- if (NULL == oh->mesg[i].native) {
+ if (NULL == oh->mesg[u].native) {
assert(type->decode);
- oh->mesg[i].native = (type->decode) (f, oh->mesg[i].raw, NULL);
- if (NULL == oh->mesg[i].native) {
- HRETURN_ERROR(H5E_OHDR, H5E_CANTDECODE, FAIL,
+ oh->mesg[u].native = (type->decode) (f, oh->mesg[u].raw, NULL);
+ if (NULL == oh->mesg[u].native) {
+ HRETURN_ERROR(H5E_OHDR, H5E_CANTDECODE, UFAIL,
"unable to decode message");
}
}
@@ -1199,8 +1210,8 @@ H5O_find_in_ohdr(H5F_t *f, haddr_t addr, const H5O_class_t **type_p,
* Return the message type. If this is a shared message then return the
* pointed-to type.
*/
- *type_p = oh->mesg[i].type;
- FUNC_LEAVE(i);
+ *type_p = oh->mesg[u].type;
+ FUNC_LEAVE(u);
}
@@ -1246,7 +1257,8 @@ H5O_modify(H5G_entry_t *ent, const H5O_class_t *type, intn overwrite,
uintn flags, const void *mesg)
{
H5O_t *oh = NULL;
- intn idx, sequence;
+ intn sequence;
+ uintn idx;
intn ret_value = FAIL;
size_t size = 0;
H5O_shared_t sh_mesg = {0,{{0,0}}};
@@ -1273,8 +1285,10 @@ H5O_modify(H5G_entry_t *ent, const H5O_class_t *type, intn overwrite,
/* Count similar messages */
for (idx = 0, sequence = -1; idx < oh->nmesgs; idx++) {
- if (type->id != oh->mesg[idx].type->id) continue;
- if (++sequence == overwrite) break;
+ if (type->id != oh->mesg[idx].type->id)
+ continue;
+ if (++sequence == overwrite)
+ break;
}
/* Was the right message found? */
@@ -1338,7 +1352,7 @@ H5O_modify(H5G_entry_t *ent, const H5O_class_t *type, intn overwrite,
}
}
idx = H5O_alloc(ent->file, oh, type, size);
- if (idx < 0) {
+ if (idx == UFAIL) {
HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, FAIL,
"unable to allocate space for message");
}
@@ -1408,7 +1422,7 @@ H5O_modify(H5G_entry_t *ent, const H5O_class_t *type, intn overwrite,
static herr_t
H5O_touch_oh(H5F_t *f, H5O_t *oh, hbool_t force)
{
- intn idx;
+ uintn idx;
time_t now = HDtime(NULL);
size_t size;
@@ -1417,17 +1431,18 @@ H5O_touch_oh(H5F_t *f, H5O_t *oh, hbool_t force)
/* Look for existing message */
for (idx=0; idx<oh->nmesgs; idx++) {
- if (H5O_MTIME==oh->mesg[idx].type) break;
+ if (H5O_MTIME==oh->mesg[idx].type)
+ break;
}
/* Create a new message */
if (idx==oh->nmesgs) {
- if (!force) HRETURN(SUCCEED); /*nothing to do*/
+ if (!force)
+ HRETURN(SUCCEED); /*nothing to do*/
size = (H5O_MTIME->raw_size)(f, &now);
- if ((idx=H5O_alloc(f, oh, H5O_MTIME, size))<0) {
+ if ((idx=H5O_alloc(f, oh, H5O_MTIME, size))==UFAIL) {
HRETURN_ERROR(H5E_OHDR, H5E_CANTINIT, FAIL,
- "unable to allocate space for modification time "
- "message");
+ "unable to allocate space for modification time message");
}
}
@@ -1533,7 +1548,8 @@ herr_t
H5O_remove(H5G_entry_t *ent, const H5O_class_t *type, intn sequence)
{
H5O_t *oh = NULL;
- intn i, seq, nfailed = 0;
+ intn seq, nfailed = 0;
+ uintn u;
herr_t ret_value = FAIL;
H5O_shared_t *sh_mesg = NULL;
@@ -1556,23 +1572,24 @@ H5O_remove(H5G_entry_t *ent, const H5O_class_t *type, intn sequence)
"unable to load object header");
}
- for (i = seq = 0; i < oh->nmesgs; i++) {
- if (type->id != oh->mesg[i].type->id) continue;
+ for (u = seq = 0; u < oh->nmesgs; u++) {
+ if (type->id != oh->mesg[u].type->id)
+ continue;
if (seq++ == sequence || H5O_ALL == sequence) {
/*
* Keep track of how many times we failed trying to remove constant
* messages.
*/
- if (oh->mesg[i].flags & H5O_FLAG_CONSTANT) {
+ if (oh->mesg[u].flags & H5O_FLAG_CONSTANT) {
nfailed++;
continue;
}
- if (oh->mesg[i].flags & H5O_FLAG_SHARED) {
- if (NULL==oh->mesg[i].native) {
- sh_mesg = (H5O_SHARED->decode)(ent->file, oh->mesg[i].raw,
+ if (oh->mesg[u].flags & H5O_FLAG_SHARED) {
+ if (NULL==oh->mesg[u].native) {
+ sh_mesg = (H5O_SHARED->decode)(ent->file, oh->mesg[u].raw,
NULL);
- if (NULL==(oh->mesg[i].native = sh_mesg)) {
+ if (NULL==(oh->mesg[u].native = sh_mesg)) {
HGOTO_ERROR (H5E_OHDR, H5E_CANTDECODE, FAIL,
"unable to decode shared message info");
}
@@ -1593,10 +1610,10 @@ H5O_remove(H5G_entry_t *ent, const H5O_class_t *type, intn sequence)
}
/* change message type to nil and zero it */
- oh->mesg[i].type = H5O_NULL;
- HDmemset(oh->mesg[i].raw, 0, oh->mesg[i].raw_size);
- oh->mesg[i].native = H5O_free (type, oh->mesg[i].native);
- oh->mesg[i].dirty = TRUE;
+ oh->mesg[u].type = H5O_NULL;
+ HDmemset(oh->mesg[u].raw, 0, oh->mesg[u].raw_size);
+ oh->mesg[u].native = H5O_free (type, oh->mesg[u].native);
+ oh->mesg[u].dirty = TRUE;
oh->dirty = TRUE;
H5O_touch_oh(ent->file, oh, FALSE);
}
@@ -1646,23 +1663,24 @@ H5O_remove(H5G_entry_t *ent, const H5O_class_t *type, intn sequence)
* memory.
*-------------------------------------------------------------------------
*/
-static intn
-H5O_alloc_extend_chunk(H5O_t *oh, intn chunkno, size_t size)
+static uintn
+H5O_alloc_extend_chunk(H5O_t *oh, uintn chunkno, size_t size)
{
- intn idx, i;
+ uintn u;
+ uintn idx;
size_t delta, old_size;
size_t aligned_size = H5O_ALIGN(size);
uint8_t *old_addr;
- FUNC_ENTER(H5O_alloc_extend_chunk, FAIL);
+ FUNC_ENTER(H5O_alloc_extend_chunk, UFAIL);
/* check args */
assert(oh);
- assert(chunkno >= 0 && chunkno < oh->nchunks);
+ assert(chunkno < oh->nchunks);
assert(size > 0);
if (H5F_addr_defined(oh->chunk[chunkno].addr)) {
- HRETURN_ERROR(H5E_OHDR, H5E_NOSPACE, FAIL, "chunk is on disk");
+ HRETURN_ERROR(H5E_OHDR, H5E_NOSPACE, UFAIL, "chunk is on disk");
}
/* try to extend a null message */
@@ -1680,9 +1698,9 @@ H5O_alloc_extend_chunk(H5O_t *oh, intn chunkno, size_t size)
/* Be careful not to indroduce garbage */
oh->chunk[chunkno].image = H5FL_BLK_REALLOC(chunk_image,old_addr,
- (hsize_t)(oh->chunk[chunkno].size + delta));
+ (oh->chunk[chunkno].size + delta));
if (NULL==oh->chunk[chunkno].image) {
- HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL,
+ HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, UFAIL,
"memory allocation failed");
}
HDmemset(oh->chunk[chunkno].image + oh->chunk[chunkno].size,
@@ -1691,10 +1709,10 @@ H5O_alloc_extend_chunk(H5O_t *oh, intn chunkno, size_t size)
/* adjust raw addresses for messages of this chunk */
if (old_addr != oh->chunk[chunkno].image) {
- for (i = 0; i < oh->nmesgs; i++) {
- if (oh->mesg[i].chunkno == chunkno) {
- oh->mesg[i].raw = oh->chunk[chunkno].image +
- (oh->mesg[i].raw - old_addr);
+ for (u = 0; u < oh->nmesgs; u++) {
+ if (oh->mesg[u].chunkno == chunkno) {
+ oh->mesg[u].raw = oh->chunk[chunkno].image +
+ (oh->mesg[u].raw - old_addr);
}
}
}
@@ -1704,13 +1722,14 @@ H5O_alloc_extend_chunk(H5O_t *oh, intn chunkno, size_t size)
/* create a new null message */
if (oh->nmesgs >= oh->alloc_nmesgs) {
- hsize_t na = oh->alloc_nmesgs + H5O_NMESGS;
+ size_t na = oh->alloc_nmesgs + H5O_NMESGS;
H5O_mesg_t *x = H5FL_ARR_REALLOC (H5O_mesg_t, oh->mesg, na);
+
if (NULL==x) {
- HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL,
+ HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, UFAIL,
"memory allocation failed");
}
- oh->alloc_nmesgs = (intn)na;
+ oh->alloc_nmesgs = na;
oh->mesg = x;
}
delta = MAX(H5O_MIN_SIZE, aligned_size+H5O_SIZEOF_MSGHDR(f));
@@ -1729,9 +1748,9 @@ H5O_alloc_extend_chunk(H5O_t *oh, intn chunkno, size_t size)
old_size = oh->chunk[chunkno].size;
oh->chunk[chunkno].size += delta;
oh->chunk[chunkno].image = H5FL_BLK_REALLOC(chunk_image,old_addr,
- (hsize_t)oh->chunk[chunkno].size);
+ oh->chunk[chunkno].size);
if (NULL==oh->chunk[chunkno].image) {
- HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL,
+ HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, UFAIL,
"memory allocation failed");
}
HDmemset(oh->chunk[chunkno].image+old_size, 0,
@@ -1739,10 +1758,10 @@ H5O_alloc_extend_chunk(H5O_t *oh, intn chunkno, size_t size)
/* adjust raw addresses for messages of this chunk */
if (old_addr != oh->chunk[chunkno].image) {
- for (i = 0; i < oh->nmesgs; i++) {
- if (oh->mesg[i].chunkno == chunkno) {
- oh->mesg[i].raw = oh->chunk[chunkno].image +
- (oh->mesg[i].raw - old_addr);
+ for (u = 0; u < oh->nmesgs; u++) {
+ if (oh->mesg[u].chunkno == chunkno) {
+ oh->mesg[u].raw = oh->chunk[chunkno].image +
+ (oh->mesg[u].raw - old_addr);
}
}
}
@@ -1777,18 +1796,19 @@ H5O_alloc_extend_chunk(H5O_t *oh, intn chunkno, size_t size)
*
*-------------------------------------------------------------------------
*/
-static intn
+static uintn
H5O_alloc_new_chunk(H5F_t *f, H5O_t *oh, size_t size)
{
size_t cont_size; /*continuation message size */
intn found_null = (-1); /*best fit null message */
intn found_other = (-1); /*best fit other message */
- intn idx = FAIL; /*message number return value */
+ uintn idx; /*message number return value */
uint8_t *p = NULL; /*ptr into new chunk */
H5O_cont_t *cont = NULL; /*native continuation message */
- intn i, chunkno;
+ intn chunkno;
+ uintn u;
- FUNC_ENTER(H5O_alloc_new_chunk, FAIL);
+ FUNC_ENTER(H5O_alloc_new_chunk, UFAIL);
/* check args */
assert (oh);
@@ -1802,23 +1822,23 @@ H5O_alloc_new_chunk(H5F_t *f, H5O_t *oh, size_t size)
* Don't ever move continuation message from one chunk to another.
*/
cont_size = H5O_ALIGN (H5F_SIZEOF_ADDR(f) + H5F_SIZEOF_SIZE(f));
- for (i=0; i<oh->nmesgs; i++) {
- if (H5O_NULL_ID == oh->mesg[i].type->id) {
- if (cont_size == oh->mesg[i].raw_size) {
- found_null = i;
+ for (u=0; u<oh->nmesgs; u++) {
+ if (H5O_NULL_ID == oh->mesg[u].type->id) {
+ if (cont_size == oh->mesg[u].raw_size) {
+ found_null = u;
break;
- } else if (oh->mesg[i].raw_size >= cont_size &&
+ } else if (oh->mesg[u].raw_size >= cont_size &&
(found_null < 0 ||
- (oh->mesg[i].raw_size <
+ (oh->mesg[u].raw_size <
oh->mesg[found_null].raw_size))) {
- found_null = i;
+ found_null = u;
}
- } else if (H5O_CONT_ID == oh->mesg[i].type->id) {
+ } else if (H5O_CONT_ID == oh->mesg[u].type->id) {
/*don't consider continuation messages */
- } else if (oh->mesg[i].raw_size >= cont_size &&
+ } else if (oh->mesg[u].raw_size >= cont_size &&
(found_other < 0 ||
- oh->mesg[i].raw_size < oh->mesg[found_other].raw_size)) {
- found_other = i;
+ oh->mesg[u].raw_size < oh->mesg[found_other].raw_size)) {
+ found_other = u;
}
}
assert(found_null >= 0 || found_other >= 0);
@@ -1843,13 +1863,14 @@ H5O_alloc_new_chunk(H5F_t *f, H5O_t *oh, size_t size)
* Create the new chunk without giving it a file address.
*/
if (oh->nchunks >= oh->alloc_nchunks) {
- hsize_t na = oh->alloc_nchunks + H5O_NCHUNKS;
+ size_t na = oh->alloc_nchunks + H5O_NCHUNKS;
H5O_chunk_t *x = H5FL_ARR_REALLOC (H5O_chunk_t, oh->chunk, na);
+
if (!x) {
- HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL,
+ HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, UFAIL,
"memory allocation failed");
}
- oh->alloc_nchunks = (intn)na;
+ oh->alloc_nchunks = na;
oh->chunk = x;
}
chunkno = oh->nchunks++;
@@ -1857,7 +1878,7 @@ H5O_alloc_new_chunk(H5F_t *f, H5O_t *oh, size_t size)
oh->chunk[chunkno].addr = HADDR_UNDEF;
oh->chunk[chunkno].size = size;
if (NULL==(oh->chunk[chunkno].image = p = H5FL_BLK_ALLOC(chunk_image,size,1))) {
- HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL,
+ HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, UFAIL,
"memory allocation failed");
}
@@ -1867,13 +1888,14 @@ H5O_alloc_new_chunk(H5F_t *f, H5O_t *oh, size_t size)
*/
if (oh->nmesgs + 3 > oh->alloc_nmesgs) {
int old_alloc=oh->alloc_nmesgs;
- hsize_t na = oh->alloc_nmesgs + MAX (H5O_NMESGS, 3);
+ size_t na = oh->alloc_nmesgs + MAX (H5O_NMESGS, 3);
H5O_mesg_t *x = H5FL_ARR_REALLOC (H5O_mesg_t, oh->mesg, na);
+
if (!x) {
- HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL,
+ HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, UFAIL,
"memory allocation failed");
}
- oh->alloc_nmesgs = (intn)na;
+ oh->alloc_nmesgs = na;
oh->mesg = x;
/* Set new object header info to zeros */
@@ -1885,13 +1907,13 @@ H5O_alloc_new_chunk(H5F_t *f, H5O_t *oh, size_t size)
* Describe the messages of the new chunk.
*/
if (found_null < 0) {
- found_null = i = oh->nmesgs++;
- oh->mesg[i].type = H5O_NULL;
- oh->mesg[i].dirty = TRUE;
- oh->mesg[i].native = NULL;
- oh->mesg[i].raw = oh->mesg[found_other].raw;
- oh->mesg[i].raw_size = oh->mesg[found_other].raw_size;
- oh->mesg[i].chunkno = oh->mesg[found_other].chunkno;
+ found_null = u = oh->nmesgs++;
+ oh->mesg[u].type = H5O_NULL;
+ oh->mesg[u].dirty = TRUE;
+ oh->mesg[u].native = NULL;
+ oh->mesg[u].raw = oh->mesg[found_other].raw;
+ oh->mesg[u].raw_size = oh->mesg[found_other].raw_size;
+ oh->mesg[u].chunkno = oh->mesg[found_other].chunkno;
oh->mesg[found_other].dirty = TRUE;
oh->mesg[found_other].raw = p + H5O_SIZEOF_MSGHDR(f);
@@ -1913,16 +1935,16 @@ H5O_alloc_new_chunk(H5F_t *f, H5O_t *oh, size_t size)
* two null messages.
*/
if (oh->mesg[found_null].raw_size > cont_size) {
- i = oh->nmesgs++;
- oh->mesg[i].type = H5O_NULL;
- oh->mesg[i].dirty = TRUE;
- oh->mesg[i].native = NULL;
- oh->mesg[i].raw = oh->mesg[found_null].raw +
+ u = oh->nmesgs++;
+ oh->mesg[u].type = H5O_NULL;
+ 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);
- oh->mesg[i].raw_size = oh->mesg[found_null].raw_size -
+ oh->mesg[u].raw_size = oh->mesg[found_null].raw_size -
(cont_size + H5O_SIZEOF_MSGHDR(f));
- oh->mesg[i].chunkno = oh->mesg[found_null].chunkno;
+ oh->mesg[u].chunkno = oh->mesg[found_null].chunkno;
oh->mesg[found_null].dirty = TRUE;
oh->mesg[found_null].raw_size = cont_size;
@@ -1934,7 +1956,7 @@ H5O_alloc_new_chunk(H5F_t *f, H5O_t *oh, size_t size)
oh->mesg[found_null].type = H5O_CONT;
oh->mesg[found_null].dirty = TRUE;
if (NULL==(cont = H5MM_calloc(sizeof(H5O_cont_t)))) {
- HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL,
+ HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, UFAIL,
"memory allocation failed");
}
cont->addr = HADDR_UNDEF;
@@ -1963,15 +1985,15 @@ H5O_alloc_new_chunk(H5F_t *f, H5O_t *oh, size_t size)
*
*-------------------------------------------------------------------------
*/
-static intn
+static uintn
H5O_alloc(H5F_t *f, H5O_t *oh, const H5O_class_t *type, size_t size)
{
- intn chunkno;
- intn idx;
- intn null_idx;
+ uintn chunkno;
+ uintn idx;
+ uintn null_idx;
size_t aligned_size = H5O_ALIGN(size);
- FUNC_ENTER(H5O_alloc, FAIL);
+ FUNC_ENTER(H5O_alloc, UFAIL);
/* check args */
assert (oh);
@@ -2001,7 +2023,7 @@ H5O_alloc(H5F_t *f, H5O_t *oh, const H5O_class_t *type, size_t size)
* since we can just increase the size of that chunk.
*/
for (chunkno = 0; chunkno < oh->nchunks; chunkno++) {
- if ((idx = H5O_alloc_extend_chunk(oh, chunkno, size)) >= 0) {
+ if ((idx = H5O_alloc_extend_chunk(oh, chunkno, size)) != UFAIL) {
break;
}
H5E_clear();
@@ -2010,9 +2032,9 @@ H5O_alloc(H5F_t *f, H5O_t *oh, const H5O_class_t *type, size_t size)
/*
* Create a new chunk
*/
- if (idx < 0) {
- if ((idx = H5O_alloc_new_chunk(f, oh, size)) < 0) {
- HRETURN_ERROR(H5E_OHDR, H5E_NOSPACE, FAIL,
+ if (idx == UFAIL) {
+ if ((idx = H5O_alloc_new_chunk(f, oh, size)) == UFAIL) {
+ HRETURN_ERROR(H5E_OHDR, H5E_NOSPACE, UFAIL,
"unable to create a new object header data chunk");
}
}
@@ -2024,13 +2046,14 @@ H5O_alloc(H5F_t *f, H5O_t *oh, const H5O_class_t *type, size_t size)
if (oh->nmesgs >= oh->alloc_nmesgs) {
int old_alloc=oh->alloc_nmesgs;
- hsize_t na = oh->alloc_nmesgs + H5O_NMESGS;
+ size_t na = oh->alloc_nmesgs + H5O_NMESGS;
H5O_mesg_t *x = H5FL_ARR_REALLOC (H5O_mesg_t, oh->mesg, na);
+
if (!x) {
- HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL,
+ HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, UFAIL,
"memory allocation failed");
}
- oh->alloc_nmesgs = (intn)na;
+ oh->alloc_nmesgs = na;
oh->mesg = x;
/* Set new object header info to zeros */
@@ -2136,7 +2159,7 @@ herr_t
H5O_debug(H5F_t *f, haddr_t addr, FILE *stream, intn indent, intn fwidth)
{
H5O_t *oh = NULL;
- intn i, chunkno;
+ uintn i, chunkno;
size_t mesg_total = 0, chunk_total = 0;
int *sequence;
haddr_t tmp_addr;
@@ -2173,12 +2196,12 @@ H5O_debug(H5F_t *f, haddr_t addr, FILE *stream, intn indent, intn fwidth)
HDfprintf(stream, "%*s%-*s %d\n", indent, "", fwidth,
"Number of links:",
(int) (oh->nlink));
- HDfprintf(stream, "%*s%-*s %d (%d)\n", indent, "", fwidth,
+ HDfprintf(stream, "%*s%-*s %u (%u)\n", indent, "", fwidth,
"Number of messages (allocated):",
- (int) (oh->nmesgs), (int) (oh->alloc_nmesgs));
- HDfprintf(stream, "%*s%-*s %d (%d)\n", indent, "", fwidth,
+ (unsigned) (oh->nmesgs), (unsigned) (oh->alloc_nmesgs));
+ HDfprintf(stream, "%*s%-*s %u (%u)\n", indent, "", fwidth,
"Number of chunks (allocated):",
- (int) (oh->nchunks), (int) (oh->alloc_nchunks));
+ (unsigned) (oh->nchunks), (unsigned) (oh->alloc_nchunks));
/* debug each chunk */
for (i=0, chunk_total=0; i<oh->nchunks; i++) {
@@ -2243,7 +2266,7 @@ H5O_debug(H5F_t *f, haddr_t addr, FILE *stream, intn indent, intn fwidth)
"Chunk number:",
(int) (oh->mesg[i].chunkno));
chunkno = oh->mesg[i].chunkno;
- if (chunkno < 0 || chunkno >= oh->nchunks) {
+ if (chunkno >= oh->nchunks) {
HDfprintf(stream, "*** BAD CHUNK NUMBER\n");
}