From 4dd2b367d5718689009ff67e2e665b7e61863331 Mon Sep 17 00:00:00 2001 From: Quincey Koziol Date: Mon, 15 Sep 1997 12:54:15 -0500 Subject: [svn-r78] Checkpointing dataset code. Everything is currently working, except writing a second dataset out to the file seems to loose the first one. --- src/H5Aprivate.h | 1 + src/H5D.c | 161 +++++++++++++++++++++++++++++++++++++++++++++++++++---- src/H5Dprivate.h | 5 +- src/H5Dpublic.h | 1 + src/H5M.c | 28 +++++++++- src/H5Oname.c | 2 +- src/H5Osdim.c | 23 ++++++-- src/H5Osdtyp.c | 1 + 8 files changed, 206 insertions(+), 16 deletions(-) diff --git a/src/H5Aprivate.h b/src/H5Aprivate.h index 572d3be..09371d1 100644 --- a/src/H5Aprivate.h +++ b/src/H5Aprivate.h @@ -63,6 +63,7 @@ #define H5A_DATATYPEID_HASHSIZE 64 #define H5A_DATASPACEID_HASHSIZE 64 #define H5A_DATASETID_HASHSIZE 64 +#define H5A_OID_HASHSIZE 64 /* Atom information structure used */ typedef struct atom_info_struct_tag { diff --git a/src/H5D.c b/src/H5D.c index 32eb59b..995d741 100644 --- a/src/H5D.c +++ b/src/H5D.c @@ -38,6 +38,7 @@ static char RcsId[] = "@(#)$Revision$"; #include /* Dataset functions */ #include /* Error handling */ #include /* Meta data */ +#include /* Group headers */ #include /* Object headers */ #include /* File space allocation header */ @@ -67,6 +68,7 @@ static herr_t H5D_init_interface(void) FUNC_ENTER (H5D_init_interface, NULL, FAIL); /* Initialize the atom group for the file IDs */ + ret_value=H5Ainit_group(H5_OID,H5A_OID_HASHSIZE,0); ret_value=H5Ainit_group(H5_DATASET,H5A_DATASETID_HASHSIZE,H5D_RESERVED_ATOMS); FUNC_LEAVE(ret_value); @@ -165,18 +167,21 @@ hatom_t H5D_access(hatom_t oid) /* Pull information about the dataset out of the file */ dset->file=H5Aatom_object(ohdr->fid); /* Get the pointer to the file for the dataset */ /* Get the dataset's name */ - if((dset->name=H5O_read(dset->file,ohdr->ohdr,ohdr->ent,H5O_NAME,1,NULL))==NULL) + if((dset->name=H5O_read(dset->file,ohdr->ohdr,&ohdr->ent,H5O_NAME,0,NULL))==NULL) HGOTO_ERROR(H5E_OHDR, H5E_NOTFOUND, FAIL); dset->modified=BFALSE; /* nothing changed yet */ /* Get the dataset's type (currently only atomic types) */ - if((dset->type=H5O_read(dset->file,ohdr->ohdr,ohdr->ent,H5O_SIM_DTYPE,1,NULL))==NULL) + if((dset->type=H5O_read(dset->file,ohdr->ohdr,&ohdr->ent,H5O_SIM_DTYPE,0,NULL))==NULL) HGOTO_ERROR(H5E_OHDR, H5E_NOTFOUND, FAIL); /* Get the dataset's dimensionality (currently only simple dataspaces) */ - if((dset->dim=H5O_read(dset->file,ohdr->ohdr,ohdr->ent,H5O_SIM_DIM,1,NULL))==NULL) + if((dset->dim=HDmalloc(sizeof(H5P_dim_t)))==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL); + dset->dim->type=H5P_TYPE_SIMPLE; /* for now... */ + if((dset->dim->s=H5O_read(dset->file,ohdr->ohdr,&ohdr->ent,H5O_SIM_DIM,0,NULL))==NULL) HGOTO_ERROR(H5E_OHDR, H5E_NOTFOUND, FAIL); dset->header=ohdr->ohdr; /* keep the object header location for later */ /* Get the dataset's data offset (currently only standard storage) */ - if(NULL==H5O_read(dset->file,ohdr->ohdr,ohdr->ent,H5O_STD_STORE,1,&store)) + if(NULL==H5O_read(dset->file,ohdr->ohdr,&ohdr->ent,H5O_STD_STORE,0,&store)) HGOTO_ERROR(H5E_OHDR, H5E_NOTFOUND, FAIL); dset->data=store.off; @@ -197,6 +202,66 @@ done: /*-------------------------------------------------------------------------- NAME + H5D_find_name + PURPOSE + Get the OID for accessing an existing HDF5 dataset object + USAGE + hoid_t H5D_find_name(grp_id, type, name) + hatom_t grp_id; IN: Atom for directory to search for dataset + hobjtype_t type; IN: Type of object to search for (dataset in this case) + const char *name; IN: Name of the object to search for + RETURNS + Returns ID (atom) on success, FAIL on failure + DESCRIPTION + This function finds for a dataset by name in a directory. +--------------------------------------------------------------------------*/ +hatom_t H5D_find_name(hatom_t grp_id, hobjtype_t type, const char *name) +{ + hdf5_file_t *file; /* Pointer to the file-store of this object */ + H5D_oid_t *ohdr; /* OID for reference to dataset */ + hatom_t ret_value = SUCCEED; + + FUNC_ENTER(H5D_find_name, H5D_init_interface, FAIL); + + /* Clear errors and check args and all the boring stuff. */ + H5ECLEAR; + + /* Allocate space for the dataset */ + if((ohdr=HDmalloc(sizeof(H5D_oid_t)))==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL); + + /* Get directory symbols, etc... */ + if(H5Aatom_group(grp_id)!=H5_FILE) + HGOTO_ERROR(H5E_ATOM, H5E_BADTYPE, FAIL); + file=H5Aatom_object(grp_id); +/* WARNING! WARNING! WARNING! */ +/* The following line explicitly uses the root symbol as the + current working directory. This should be changed to something more + appropriate and is only hacked in here to get the prototype working. -QAK +*/ +/* WARNING! WARNING! WARNING! */ + if(H5G_find(file,file->root_sym,&(ohdr->dir),name,&(ohdr->ent))==FAIL) + HGOTO_ERROR(H5E_DATASET, H5E_NOTFOUND, FAIL); + ohdr->fid=grp_id; + ohdr->ohdr=ohdr->ent.header; + + /* Register the new OID and get an ID for it */ + if((ret_value=H5Aregister_atom(H5_OID, (const VOIDP)ohdr))==FAIL) + HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL); + +done: + if(ret_value == FAIL) + { /* Error condition cleanup */ + + } /* end if */ + + /* Normal function cleanup */ + + FUNC_LEAVE(ret_value); +} /* end H5D_find_name() */ + +/*-------------------------------------------------------------------------- + NAME H5Dset_info PURPOSE Set the type and dimensionality of a dataset. @@ -302,11 +367,79 @@ done: /*-------------------------------------------------------------------------- NAME + H5Dread + PURPOSE + Read data from a dataset + USAGE + herr_t H5Dread(oid) + hatom_t oid; IN: Dataset to read + hatom_t did; IN: Dimensionality object to use as dataspace for I/O + VOIDP buf; IN: Buffer to fill with data from the file + RETURNS + SUCCEED/FAIL + DESCRIPTION + This function reads dataset object data to the file. The dataspace + ID determines the slice/hyper-slab/portion of the dataset to write. + H5P_SCALAR is a special value which indicates that the entire dataset is + to be written out. (For datasets which have a scalar dataspace for the + entire dataset, this is somewhat redundant.... :-) +--------------------------------------------------------------------------*/ +herr_t H5Dread(hatom_t oid, hatom_t did, VOIDP buf) +{ + H5D_dataset_t *dataset; /* dataset object to do I/O on */ + uintn toread; /* number of bytes to read in */ + herr_t ret_value = SUCCEED; + + FUNC_ENTER(H5Dread, H5D_init_interface, FAIL); + + /* Clear errors and check args and all the boring stuff. */ + H5ECLEAR; + + /* Check that we've received correctly typed parameters */ + if(H5Aatom_group(did)!=H5_DATASPACE || H5Aatom_group(oid)!=H5_DATASET) + HGOTO_ERROR(H5E_ATOM, H5E_BADTYPE, FAIL); + if(buf==NULL) + HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL); + + /* Get the object */ + if((dataset=H5Aatom_object(oid))==NULL) + HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL); + + /* Check that the datatype & dataspace have already been initialized */ + if(dataset->type==NULL || dataset->dim==NULL || dataset->data==(-1)) + HGOTO_ERROR(H5E_FUNC, H5E_UNINITIALIZED, FAIL); + + /* Compute the number of bytes to read */ + if(did==H5P_SCALAR) /* Check if we are reading the entire dataset */ + toread=H5T_size(dataset->type,BTRUE)*H5P_nelem(dataset->dim); + else + HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL); + +/* Check memory to disk datatype conversions, etc. */ +/* DO THIS! -QAK */ + + /* Write the data out to disk */ + if(H5F_block_read(dataset->file,dataset->data,toread,buf)==FAIL) + HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL); + +done: + if(ret_value == FAIL) + { /* Error condition cleanup */ + + } /* end if */ + + /* Normal function cleanup */ + + FUNC_LEAVE(ret_value); +} /* end H5Dread() */ + +/*-------------------------------------------------------------------------- + NAME H5Dwrite PURPOSE Write data for a dataset USAGE - herr_t H5Dset_info(oid) + herr_t H5Dwrite(oid) hatom_t oid; IN: Dataset object to modify hatom_t did; IN: Dimensionality object to use as dataspace for I/O VOIDP buf; IN: Buffer with data to write to the file @@ -321,7 +454,7 @@ done: --------------------------------------------------------------------------*/ herr_t H5Dwrite(hatom_t oid, hatom_t did, VOIDP buf) { - H5D_dataset_t *dataset; /* dataset object to release */ + H5D_dataset_t *dataset; /* dataset object to do I/O on */ uintn towrite; /* number of bytes to write out */ herr_t ret_value = SUCCEED; @@ -331,7 +464,7 @@ herr_t H5Dwrite(hatom_t oid, hatom_t did, VOIDP buf) H5ECLEAR; /* Check that we've received correctly typed parameters */ - if(did!=0 && H5Aatom_group(did)!=H5_DATASPACE) + if(H5Aatom_group(did)!=H5_DATASPACE || H5Aatom_group(oid)!=H5_DATASET) HGOTO_ERROR(H5E_ATOM, H5E_BADTYPE, FAIL); if(buf==NULL) HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL); @@ -339,12 +472,13 @@ herr_t H5Dwrite(hatom_t oid, hatom_t did, VOIDP buf) /* Get the object */ if((dataset=H5Aatom_object(oid))==NULL) HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL); + /* Check that the datatype & dataspace haven't already been initialized */ if(dataset->type==NULL || dataset->dim==NULL) HGOTO_ERROR(H5E_FUNC, H5E_UNINITIALIZED, FAIL); /* Compute the number of bytes to write out */ - if(did==0) /* Check if we are writing out the entire dataset */ + if(did==H5P_SCALAR) /* Check if we are writing out the entire dataset */ towrite=H5T_size(dataset->type,BTRUE)*H5P_nelem(dataset->dim); else HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL); @@ -423,6 +557,12 @@ herr_t H5D_flush(hatom_t oid) /* * Write the necessary messages to the header. */ + /* Write the dataset's name */ + if(dataset->name!=NULL) + { + if(H5O_modify(dataset->file,dataset->header,&d_sym,NULL,H5O_NAME,H5O_NEW_MESG,dataset->name)==FAIL) + HGOTO_ERROR (H5E_INTERNAL, H5E_CANTCREATE, FAIL); + } /* end if */ /* Check if this dataset has an "atomic" datatype */ if(BTRUE==H5T_is_atomic(dataset->type)) { @@ -443,6 +583,7 @@ herr_t H5D_flush(hatom_t oid) { /* if it's not an atomic datatype, fail for right now */ HGOTO_ERROR (H5E_INTERNAL, H5E_UNSUPPORTED, FAIL); } /* end else */ + /* Write the dataset's storage information */ if(dataset->data>0) { H5O_std_store_t store; /* standard storage info */ @@ -559,10 +700,12 @@ herr_t H5D_release(hatom_t oid) if(dataset->modified==BTRUE) H5D_flush(oid); - /* relase the memory used for the dataset */ + /* release the memory used for the dataset */ if(dataset->name!=NULL) + { HDfree(dataset->name->s); HDfree(dataset->name); + } /* end if */ HDfree(dataset); /* Delete the dataset from the atom group */ diff --git a/src/H5Dprivate.h b/src/H5Dprivate.h index a5343d4..83a090f 100644 --- a/src/H5Dprivate.h +++ b/src/H5Dprivate.h @@ -32,8 +32,8 @@ typedef struct { hatom_t fid; /* File Id for object */ haddr_t ohdr; /* Offset of the object header */ - H5G_entry_t *dir; /* directory entry for the directory the object is located in */ - H5G_entry_t *ent; /* directory entry for the object itself */ + H5G_entry_t dir; /* directory entry for the directory the object is located in */ + H5G_entry_t ent; /* directory entry for the object itself */ } H5D_oid_t; typedef struct { @@ -54,6 +54,7 @@ typedef struct { /*-----------------_-- Local function prototypes ----------------------------*/ hatom_t H5D_create(hatom_t owner_id, hobjtype_t type, const char *name); hatom_t H5D_access(hatom_t oid); +hatom_t H5D_find_name(hatom_t owner_id, hobjtype_t type, const char *name); herr_t H5D_flush(hatom_t oid); herr_t H5D_release(hatom_t oid); diff --git a/src/H5Dpublic.h b/src/H5Dpublic.h index 5eda12b..31b3080 100644 --- a/src/H5Dpublic.h +++ b/src/H5Dpublic.h @@ -31,6 +31,7 @@ extern "C" { herr_t H5Dset_info(hatom_t oid, hatom_t tid, hatom_t did); herr_t H5Dget_info(hatom_t oid, hatom_t *tid, hatom_t *sid); herr_t H5Dwrite(hatom_t oid, hatom_t did, VOIDP buf); +herr_t H5Dread(hatom_t oid, hatom_t did, VOIDP buf); #ifdef __cplusplus } diff --git a/src/H5M.c b/src/H5M.c index b47fd2f..f3771a2 100644 --- a/src/H5M.c +++ b/src/H5M.c @@ -117,7 +117,7 @@ static meta_func_t meta_func_arr[]={ H5D_create, /* Dataset Create */ H5D_access, /* Dataset Access */ NULL, /* Dataset Copy */ - NULL, /* Dataset FindName */ + H5D_find_name, /* Dataset FindName */ NULL, /* Dataset NameLen */ NULL, /* Dataset GetName */ NULL, /* Dataset SetName */ @@ -128,6 +128,23 @@ static meta_func_t meta_func_arr[]={ NULL, /* Dataset GetParent */ NULL, /* Dataset GetFile */ H5D_release /* Dataset Release */ + }, + { /* Dataset object meta-functions (defined in H5D.c) */ + H5_OID, /* OID Type ID */ + NULL, /* OID Create */ + H5D_access, /* OID Access (calls dataset access routine) */ + NULL, /* OID Copy */ + NULL, /* OID FindName */ + NULL, /* OID NameLen */ + NULL, /* OID GetName */ + NULL, /* OID SetName */ + NULL, /* OID Search */ + NULL, /* OID Index */ + NULL, /* OID Flush */ + NULL, /* OID Delete */ + NULL, /* OID GetParent */ + NULL, /* OID GetFile */ + NULL /* OID Release */ } }; @@ -350,7 +367,9 @@ done: --------------------------------------------------------------------------*/ hatom_t H5Mfind_name(hatom_t owner_id, hobjtype_t type, const char *name) { +#ifdef OLD_WAY group_t group=H5Aatom_group(owner_id); /* Atom group for incoming object */ +#endif /* OLD_WAY */ intn i; /* local counting variable */ hatom_t ret_value = SUCCEED; @@ -358,10 +377,17 @@ hatom_t H5Mfind_name(hatom_t owner_id, hobjtype_t type, const char *name) /* Clear errors and check args and all the boring stuff. */ H5ECLEAR; +#ifdef OLD_WAY if(group<=BADGROUP || group>=MAXGROUP) HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL); i=H5M_find_type(group); +#else /* OLD_WAY */ + if(type<=BADGROUP || type>=MAXGROUP) + HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL); + + i=H5M_find_type(type); +#endif /* OLD_WAY */ if(meta_func_arr[i].find_name==NULL) HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL); ret_value=(meta_func_arr[i].find_name)(owner_id,type,name); diff --git a/src/H5Oname.c b/src/H5Oname.c index 5631887..cec5d34 100644 --- a/src/H5Oname.c +++ b/src/H5Oname.c @@ -196,7 +196,7 @@ H5O_name_size (hdf5_file_t *f, const void *_mesg) const H5O_name_t *mesg = (const H5O_name_t *)_mesg; size_t size; - FUNC_ENTER (H5O_stab_size, NULL, FAIL); + FUNC_ENTER (H5O_name_size, NULL, FAIL); /* check args */ assert (f); diff --git a/src/H5Osdim.c b/src/H5Osdim.c index 56a0be7..6ab0519 100644 --- a/src/H5Osdim.c +++ b/src/H5Osdim.c @@ -171,16 +171,16 @@ H5O_sim_dim_encode (hdf5_file_t *f, size_t raw_size, uint8 *p, const void *mesg) UINT32ENCODE(p,sdim->dim_flags); if(sdim->rank>0) { - for(u=0; urank; u++); + for(u=0; urank; u++) UINT32ENCODE(p,sdim->size[u]); if(sdim->dim_flags&0x01) { - for(u=0; urank; u++); + for(u=0; urank; u++) UINT32ENCODE(p,sdim->max[u]); } /* end if */ if(sdim->dim_flags&0x02) { - for(u=0; urank; u++); + for(u=0; urank; u++) UINT32ENCODE(p,sdim->perm[u]); } /* end if */ } /* end if */ @@ -338,6 +338,23 @@ H5O_sim_dim_copy (const void *mesg, void *dest) /* copy */ HDmemcpy(dst,src,sizeof(H5O_sim_dim_t)); + if(src->rank>0) + { + dst->size = H5MM_xcalloc (src->rank, sizeof(uint32)); + HDmemcpy(dst->size,src->size,src->rank*sizeof(uint32)); + /* Check for maximum dimensions and copy those */ + if((src->dim_flags&0x01)>0) + { + dst->max = H5MM_xcalloc (src->rank, sizeof(uint32)); + HDmemcpy(dst->max,src->max,src->rank*sizeof(uint32)); + } /* end if */ + /* Check for dimension permutation and copy those */ + if((src->dim_flags&0x02)>0) + { + dst->perm = H5MM_xcalloc (src->rank, sizeof(uint32)); + HDmemcpy(dst->perm,src->perm,src->rank*sizeof(uint32)); + } /* end if */ + } /* end if */ FUNC_LEAVE ((void*)dst); } /* end H5O_sim_dim_copy() */ diff --git a/src/H5Osdtyp.c b/src/H5Osdtyp.c index 962b646..a4b3c04 100644 --- a/src/H5Osdtyp.c +++ b/src/H5Osdtyp.c @@ -102,6 +102,7 @@ H5O_sim_dtype_decode (hdf5_file_t *f, size_t raw_size, const uint8 *p) sdtype->len=*p++; sdtype->arch=*p++; UINT16DECODE(p,sdtype->base); + sdtype->base=MAKE_ATOM(H5_DATATYPE,sdtype->base); /* convert into atomic base type */ } /* end if */ FUNC_LEAVE (sdtype); -- cgit v0.12