mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2025-02-17 16:10:24 +08:00
Code Issues Packages Projects Releases Wiki Activity
7389762766
hdf5/test/istore.c
Robb Matzke 7389762766 [svn-r135] ./config/linux 
./config/freebsd2.2.1
        Rewritten to be more flexible.

./src/H5AC.c
./src/H5ACprivate.h
./src/H5F.c
./src/H5H.c
./src/H5Gpkg.h
./src/H5Gshad.c
./src/H5O.c
./test/istore.c
./test/tstab.c
        Accumulates cache statistics and displays the results on
        stderr when the file is closed if it was opened with
        H5F_ACC_DEBUG passed into H5F_open()

./src/H5B.c
./src/H5Bprivate.h
./src/H5Fistore.c
./src/H5Gnode.c
        Added more debugging which is turned on if H5B_DEBUG is
        defined on the compile command (see config/linux).

        Fixed a couple of bugs with left insertions which are used by
        the indexed storage stuff.

./src/H5Flow.c
        Fixed a memory leak.

./src/H5Fprivate.h
        Fixed warnings about shifting more than size of object.

./src/H5Fstdio.c
        Fixed seek optimizations back to the way Quincey originally
        had them.

./src/H5V.c
        Removed unused variables.
1997-11-07 00:16:53 -05:00

593 lines
14 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*
* Copyright (C) 1997 NCSA
* All rights reserved.
*
* Programmer: Robb Matzke <matzke@llnl.gov>
* Wednesday, October 15, 1997
*
* Purpose: Tests various aspects of indexed raw data storage.
*/
#include <H5private.h>
#include <H5Fprivate.h>
#include <H5Gprivate.h>
#include <H5MMprivate.h>
#include <H5Oprivate.h>
#include <H5Vprivate.h>
#define FILENAME "istore.h5"
#define TEST_SMALL 0x0001
#define TEST_MEDIUM 0x0002
#define AT() printf (" at %s:%d in %s()...\n", \
__FILE__, __LINE__, __FUNCTION__);
/*-------------------------------------------------------------------------
* Function: print_array
*
* Purpose: Prints the values in an array
*
* Return: void
*
* Programmer: Robb Matzke
* Friday, October 10, 1997
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
print_array (uint8 *array, size_t nx, size_t ny, size_t nz)
{
int i, j, k;
for (i=0; i<nx; i++) {
if (nz>1) {
printf ("i=%d:\n", i);
} else {
printf ("%03d:", i);
}
for (j=0; j<ny; j++) {
if (nz>1) printf ("%03d:", j);
for (k=0; k<nz; k++) {
printf (" %3d", *array++);
}
if (nz>1) printf ("\n");
}
printf ("\n");
}
}
/*-------------------------------------------------------------------------
* Function: new_object
*
* Purpose: Creates a new object that refers to a indexed storage of raw
* data. No raw data is stored.
*
* Return: Success: Handle to a new open object.
*
* Failure: NULL, error message printed.
*
* Programmer: Robb Matzke
* Wednesday, October 15, 1997
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static H5G_entry_t *
new_object (H5F_t *f, const char *name, size_t ndims)
{
H5G_entry_t *handle = NULL;
H5O_istore_t istore;
size_t alignment[H5O_ISTORE_NDIMS];
intn i;
/* Create the object symbol table entry and header */
if (NULL==(handle=H5G_create (f, name, 64))) {
puts ("*FAILED*");
if (!isatty (1)) {
AT ();
printf (" H5G_create (f, name=\"%s\") = NULL\n", name);
}
return NULL;
}
/* Add the indexed-storage message */
for (i=0; i<ndims; i++) alignment[i] = 2;
H5F_istore_new (f, &istore, ndims, alignment);
if (H5O_modify (f, H5O_NO_ADDR, handle, H5O_ISTORE, H5O_NEW_MESG,
&istore)<0) {
printf ("*FAILED*\n");
if (!isatty (1)) {
AT();
printf (" H5G_modify istore message failure\n");
}
return NULL;
}
return handle;
}
/*-------------------------------------------------------------------------
* Function: test_create
*
* Purpose: Creates a named object that refers to indexed storage of raw
* data. No raw data is stored.
*
* Return: Success: SUCCEED
*
* Failure: FAIL
*
* Programmer: Robb Matzke
* Wednesday, October 15, 1997
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static herr_t
test_create (H5F_t *f, const char *prefix)
{
H5G_entry_t *handle = NULL;
intn i;
char name[256];
printf ("%-70s", "Testing istore create");
fflush (stdout);
for (i=1; i<=H5O_ISTORE_NDIMS; i++) {
sprintf (name, "%s_%02d", prefix, i);
if (NULL==(handle=new_object (f, name, i))) return FAIL;
H5G_close (f, handle);
}
puts (" PASSED");
return SUCCEED;
}
/*-------------------------------------------------------------------------
* Function: test_extend
*
* Purpose: Creates an empty object and then writes to it in such a way
* as to always extend the object's domain without creating
* holes and without causing the object to become concave.
*
* Return: Success: SUCCEED
*
* Failure: FAIL
*
* Programmer: Robb Matzke
* Wednesday, October 15, 1997
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static herr_t
test_extend (H5F_t *f, const char *prefix,
size_t nx, size_t ny, size_t nz)
{
H5G_entry_t *handle = NULL;
int i, j, k, ndims, ctr;
uint8 *buf=NULL, *check=NULL, *whole=NULL;
char dims[64], s[256], name[256];
size_t offset[3];
size_t max_corner[3];
size_t size[3];
size_t whole_size[3];
size_t nelmts;
H5O_istore_t istore;
if (!nz) {
if (!ny) {
ndims = 1;
ny = nz = 1;
sprintf (dims, "%d", nx);
} else {
ndims = 2;
nz = 1;
sprintf (dims, "%dx%d", nx, ny);
}
} else {
ndims = 3;
sprintf (dims, "%dx%dx%d", nx, ny, nz);
}
sprintf (s, "Testing istore extend: %s", dims);
printf ("%-70s", s);
fflush (stdout);
buf = H5MM_xmalloc (nx*ny*nz);
check = H5MM_xmalloc (nx*ny*nz);
whole = H5MM_xcalloc (nx*ny*nz, 1);
/* Build the new empty object */
sprintf (name, "%s_%s", prefix, dims);
if (NULL==(handle=new_object (f, name, ndims))) {
if (!isatty (1)) {
AT ();
printf (" Cannot create %d-d object `%s'\n", ndims, name);
}
goto error;
}
if (NULL==H5O_read (f, H5O_NO_ADDR, handle, H5O_ISTORE, 0, &istore)) {
puts ("*FAILED*");
if (!isatty (1)) {
AT ();
printf (" Unable to read istore message\n");
}
goto error;
}
if (ndims!=istore.ndims) {
puts ("*FAILED*");
if (!isatty (1)) {
AT ();
printf (" Header read error: istore.ndims != %d\n", ndims);
}
goto error;
}
whole_size[0] = nx;
whole_size[1] = ny;
whole_size[2] = nz;
max_corner[0] = 0;
max_corner[1] = 0;
max_corner[2] = 0;
for (ctr=0; H5V_vector_lt (ndims, max_corner, whole_size); ctr++) {
/* Size and location */
if (0==ctr) {
offset[0] = offset[1] = offset[2] = 0;
size[0] = size[1] = size[2] = 1;
nelmts = 1;
} else {
for (i=0, nelmts=1; i<ndims; i++) {
if (ctr % ndims == i) {
offset[i] = max_corner[i];
size[i] = MIN (1, whole_size[i]-offset[i]);
} else {
offset[i] = 0;
size[i] = max_corner[i];
}
nelmts *= size[i];
}
}
#if 0
if (0==ctr) printf ("\n");
printf (" Insert: ctr=%d, corner=(%d", ctr, offset[0]);
if (ndims>1) printf (",%d", offset[1]);
if (ndims>2) printf (",%d", offset[2]);
printf ("), size=(%d", size[0]);
if (ndims>1) printf (",%d", size[1]);
if (ndims>2) printf (",%d", size[2]);
printf ("), %d element%s", nelmts, 1==nelmts?"":"s");
if (0==nelmts) printf (" *SKIPPED*");
printf ("\n");
fflush (stdout);
#endif
/* Fill the source array */
if (0==nelmts) continue;
memset (buf, 128+ctr, nelmts);
/* Write to disk */
if (H5F_istore_write (f, &istore, offset, size, buf)<0) {
puts ("*FAILED*");
if (!isatty (1)) {
AT ();
printf (" Write failed: ctr=%d\n", ctr);
}
goto error;
}
/* Read from disk */
memset (check, 0xff, nelmts);
if (H5F_istore_read (f, &istore, offset, size, check)<0) {
puts ("*FAILED*");
if (!isatty (1)) {
AT ();
printf (" Read failed: ctr=%d\n", ctr);
}
goto error;
}
if (memcmp (buf, check, nelmts)) {
puts ("*FAILED*");
if (!isatty (1)) {
AT ();
printf (" Read check failed: ctr=%d\n", ctr);
printf (" Wrote:\n");
print_array (buf, size[0], size[1], size[2]);
printf (" Read:\n");
print_array (buf, size[0], size[1], size[2]);
}
goto error;
}
/* Write to `whole' buffer for later checking */
H5V_hyper_copy (ndims, size,
whole_size, offset, whole, /*dst*/
size, H5V_ZERO, buf); /*src*/
/* Update max corner */
for (i=0; i<ndims; i++) {
max_corner[i] = MAX (max_corner[i], offset[i]+size[i]);
}
}
/* Now read the entire array back out and check it */
memset (buf, 0xff, nx*ny*nz);
if (H5F_istore_read (f, &istore, H5V_ZERO, whole_size, buf)<0) {
puts ("*FAILED*");
if (!isatty (1)) {
AT ();
printf (" Read failed for whole array\n");
}
goto error;
}
for (i=0; i<nx; i++) {
for (j=0; j<ny; j++) {
for (k=0; k<nz; k++) {
if (whole[i*ny*nz + j*nz + k] != buf[i*ny*nz + j*nz + k]) {
puts ("*FAILED*");
if (!isatty (1)) {
AT ();
printf (" Check failed at i=%d", i);
if (ndims>1) printf (", j=%d", j);
if (ndims>2) printf (", k=%d", k);
printf ("\n Check array is:\n");
print_array (whole, nx, ny, nz);
printf (" Value read is:\n");
print_array (buf, nx, ny, nz);
}
goto error;
}
}
}
}
H5G_close (f, handle);
puts (" PASSED");
H5MM_xfree (buf);
H5MM_xfree (check);
H5MM_xfree (whole);
return SUCCEED;
error:
H5MM_xfree (buf);
H5MM_xfree (check);
H5MM_xfree (whole);
return FAIL;
}
/*-------------------------------------------------------------------------
* Function: test_sparse
*
* Purpose: Creates a sparse matrix consisting of NBLOCKS randomly placed
* blocks each of size NX,NY,NZ.
*
* Return: Success: SUCCEED
*
* Failure: FAIL
*
* Programmer: Robb Matzke
* Wednesday, October 22, 1997
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static herr_t
test_sparse (H5F_t *f, const char *prefix, size_t nblocks,
size_t nx, size_t ny, size_t nz)
{
intn ndims, ctr;
char dims[64], s[256], name[256];
size_t offset[3], size[3];
H5G_entry_t *handle = NULL;
H5O_istore_t istore;
uint8 *buf = NULL;
if (!nz) {
if (!ny) {
ndims = 1;
ny = nz = 1;
sprintf (dims, "%d", nx);
} else {
ndims = 2;
nz = 1;
sprintf (dims, "%dx%d", nx, ny);
}
} else {
ndims = 3;
sprintf (dims, "%dx%dx%d", nx, ny, nz);
}
sprintf (s, "Testing istore sparse: %s", dims);
printf ("%-70s", s);
fflush (stdout);
buf = H5MM_xmalloc (nx*ny*nz);
/* Build the new empty object */
sprintf (name, "%s_%s", prefix, dims);
if (NULL==(handle=new_object (f, name, ndims))) {
if (!isatty (1)) {
AT ();
printf (" Cannot create %d-d object `%s'\n", ndims, name);
}
goto error;
}
if (NULL==H5O_read (f, H5O_NO_ADDR, handle, H5O_ISTORE, 0, &istore)) {
puts ("*FAILED*");
if (!isatty (1)) {
AT ();
printf (" Unable to read istore message\n");
}
goto error;
}
for (ctr=0; ctr<nblocks; ctr++) {
offset[0] = rand () % 1000000;
offset[1] = rand () % 1000000;
offset[2] = rand () % 1000000;
size[0] = nx;
size[1] = ny;
size[2] = nz;
memset (buf, 128+ctr, nx*ny*nz);
/* write to disk */
if (H5F_istore_write (f, &istore, offset, size, buf)<0) {
puts ("*FAILED*");
if (!isatty (1)) {
AT ();
printf (" Write failed: ctr=%d\n", ctr);
printf (" offset=(%d", offset[0]);
if (ndims>1) printf (",%d", offset[1]);
if (ndims>2) printf (",%d", offset[2]);
printf ("), size=(%d", size[0]);
if (ndims>1) printf (",%d", size[1]);
if (ndims>2) printf (",%d", size[2]);
printf (")\n");
}
goto error;
}
/* We don't test reading yet.... */
}
H5G_close (f, handle);
puts (" PASSED");
H5MM_xfree (buf);
return SUCCEED;
error:
H5MM_xfree (buf);
return FAIL;
}
/*-------------------------------------------------------------------------
* Function: main
*
* Purpose: Tests indexed storage stuff.
*
* Return: Success: exit(0)
*
* Failure: exit(non-zero)
*
* Programmer: Robb Matzke
* Wednesday, October 15, 1997
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int
main (int argc, char *argv[])
{
H5F_t *f;
herr_t status;
int nerrors = 0;
uintn size_of_test;
/* Parse arguments or assume `small' */
if (1==argc) {
size_of_test = TEST_SMALL;
} else {
intn i;
for (i=1,size_of_test=0; i<argc; i++) {
if (!strcmp (argv[i], "small")) {
size_of_test |= TEST_SMALL;
} else if (!strcmp (argv[i], "medium")) {
size_of_test |= TEST_MEDIUM;
} else {
printf ("unrecognized argument: %s\n", argv[i]);
exit (1);
}
}
}
printf ("Test sizes: ");
if (size_of_test & TEST_SMALL) printf (" SMALL");
if (size_of_test & TEST_MEDIUM) printf (" MEDIUM");
printf ("\n");
/* Create the test file */
if (NULL==(f=H5F_open (H5F_LOW_DFLT, FILENAME,
(H5F_ACC_CREAT|H5F_ACC_WRITE|H5F_ACC_TRUNC|
H5F_ACC_DEBUG),
NULL))) {
printf ("Cannot create file %s; test aborted\n", FILENAME);
exit (1);
}
/*
* Creation test: Creates empty objects with various raw data sizes
* and alignments.
*/
status = test_create (f, "create");
nerrors += status<0 ? 1 : 0;
if (size_of_test & TEST_SMALL) {
status = test_extend (f, "extend", 10, 0, 0);
nerrors += status<0 ? 1 : 0;
status = test_extend (f, "extend", 10, 10, 0);
nerrors += status<0 ? 1 : 0;
status = test_extend (f, "extend", 10, 10, 10);
nerrors += status<0 ? 1 : 0;
}
if (size_of_test & TEST_MEDIUM) {
status = test_extend (f, "extend", 10000, 0, 0);
nerrors += status<0 ? 1 : 0;
status = test_extend (f, "extend", 2500, 10, 0);
nerrors += status<0 ? 1 : 0;
status = test_extend (f, "extend", 10, 400, 10);
nerrors += status<0 ? 1 : 0;
}
if (size_of_test & TEST_SMALL) {
status = test_sparse (f, "sparse", 100, 5, 0, 0);
nerrors += status<0 ? 1 : 0;
status = test_sparse (f, "sparse", 100, 3, 4, 0);
nerrors += status<0 ? 1 : 0;
status = test_sparse (f, "sparse", 100, 2, 3, 4);
nerrors += status<0 ? 1 : 0;
}
if (size_of_test & TEST_MEDIUM) {
status = test_sparse (f, "sparse", 1000, 30, 0, 0);
nerrors += status<0 ? 1 : 0;
status = test_sparse (f, "sparse", 2000, 7, 3, 0);
nerrors += status<0 ? 1 : 0;
status = test_sparse (f, "sparse", 2000, 4, 2, 3);
nerrors += status<0 ? 1 : 0;
}
/* Close the test file and exit */
H5F_close (f);
if (nerrors) {
printf ("***** %d I-STORE TEST%s FAILED! *****\n",
nerrors, 1==nerrors?"":"S");
if (isatty (1)) {
printf ("(Redirect output to a pager or a file to see "
"debug output)\n");
}
exit (1);
}
printf ("All i-store tests passed.\n");
exit (0);
}
Reference in New Issue View Git Blame Copy Permalink