mirror of
https://github.com/HDFGroup/hdf5.git
synced 2025-01-30 15:32:37 +08:00
7488c6366e
---------------------- ./src/H5.c ./src/H5A.c ./src/H5AC.c ./src/H5B.c ./src/H5D.c ./src/H5E.c ./src/H5F.c ./src/H5Farray.c ./src/H5Fcore.c ./src/H5Ffamily.c ./src/H5Fistore.c ./src/H5Flow.c ./src/H5Fmpio.c ./src/H5Fsec2.c ./src/H5Fsplit.c ./src/H5Fstdio.c ./src/H5G.c ./src/H5Gent.c ./src/H5Gnode.c ./src/H5Gstab.c ./src/H5HG.c ./src/H5HL.c ./src/H5I.c ./src/H5Iprivate.h ./src/H5MF.c ./src/H5MM.c ./src/H5O.c ./src/H5Oattr.c ./src/H5Ocomp.c ./src/H5Ocont.c ./src/H5Odtype.c ./src/H5Oefl.c ./src/H5Ofill.c ./src/H5Olayout.c ./src/H5Omtime.c ./src/H5Oname.c ./src/H5Osdspace.c ./src/H5Oshared.c ./src/H5Ostab.c ./src/H5P.c ./src/H5R.c ./src/H5RA.c ./src/H5S.c ./src/H5Sall.c ./src/H5Shyper.c ./src/H5Smpio.c ./src/H5Snone.c ./src/H5Spoint.c ./src/H5Sselect.c ./src/H5T.c ./src/H5TB.c ./src/H5Tbit.c ./src/H5Tconv.c ./src/H5V.c ./src/H5Z.c ./src/H5detect.c ./src/H5private.h Most of these changes are because the `interface_initialize_g' variable change from hbool_t to int. It's a one line change. Changed the way the library is closed so we have more control over the order the interfaces are shut down. Instead of registering an atexit() function for every interface in some haphazard order we just register one: H5_term_library() which then calls the H5*_term_interface() functions in a well-defined order. If the library is closed and then reopened repeatedly by calling H5close() and H5open() in a loop we only add one copy of the library termination functions with atexit(). Termination is a two-step process in order to help detect programming errors that would cause an infinite loop caused by the termination of one interface waking up some other previously terminated interface. The first step terminates the interface and *marks it as unusable*. After all interfaces are terminated then we mark them all as usable again. The FUNC_ENTER() macro has been modified to return failure or to dump core (depending on whether NDEBUG is defined) if we try to call an interface while it's shutting down. ./src/H5.c The H5dont_atexit() function returns failure if it's called more than once or if it's called too late. However, the error stack is not automatically printed on failure because the library might not be initialized yet ./test/chunk.c ./test/flush1.c ./test/flush2.c ./test/iopipe.c ./test/overhead.c ./test/ragged.c Changed the extra cast for Win32 so we do floating point division again -- it was just confusion about precedence and associativity of casting and the C coercion rules. Removed extra carriage returns inserted by broken operating system. ./src/H5Ffamily.c Fixed an bug where H5F_fam_write() lowered the EOF marker for one of the family members causing H5F_fam_read() to read zeros. ./test/h5test.h [NEW] ./test/h5test.c [NEW] ./test/Makefile.in ./test/bittests.c ./test/cmpd_dset.c ./test/dsets.c ./test/dtypes.c ./test/extend.c ./test/external.c Support library for test files. This isn't done yet but Katie's contractions are ~10 minutes apart so I figured I better back this stuff up just in case I'm not here next week... Eventually all test files will understand HDF5_DRIVER to name the low level file driver and parameters so we can easily test various drivers. They will also understand HDF5_PREFIX to prepend to the beginning of file names which is necessary for testing ROMIO with various drivers. Also, the cleanup function will know how to use the file name prefix and will understand different file driver naming schemes like file families. I'm not sure they'll understand the `gsf:' type prefixes yet. Note, the external test is completely commented out because I'm in the middle of modifying it. It will still compile and run but it doesn't test anything at the moment.
686 lines
18 KiB
C
686 lines
18 KiB
C
/*
|
||
* Copyright © 1998 Spizella Software
|
||
* All rights reserved.
|
||
*
|
||
* Programmer: Robb Matzke <robb@arborea.spizella.com>
|
||
* Tuesday, August 25, 1998
|
||
*/
|
||
|
||
/* See H5private.h for how to include headers */
|
||
#undef NDEBUG
|
||
#include <hdf5.h>
|
||
#include <H5private.h> /*for performance monitoring*/
|
||
|
||
#ifdef STDC_HEADERS
|
||
# include <signal.h>
|
||
#endif
|
||
|
||
#define NOTIFY_INTERVAL 2 /*seconds*/
|
||
#define TIME_LIMIT 60 /*seconds*/
|
||
#define CH_SIZE 8192*8 /*approx chunk size in bytes*/
|
||
#define MAX_NELMTS 3000000
|
||
|
||
#define C_MTYPE unsigned int /*type in memory */
|
||
#define H_MTYPE H5T_NATIVE_UINT /*type in memory */
|
||
#define H_FTYPE H5T_NATIVE_UINT /*type in file */
|
||
|
||
typedef struct {
|
||
double percent;
|
||
size_t lo, hi;
|
||
size_t nhits;
|
||
} quant_t;
|
||
|
||
#if 1
|
||
/* Typical VBT sizes */
|
||
static quant_t quant_g[] = {
|
||
{10.00, 1, 5},
|
||
{89.00, 6, 20},
|
||
{ 0.90, 21, 100},
|
||
{ 0.09, 101, 1000},
|
||
{ 0.01, 1001, 10000},
|
||
};
|
||
#elif 0
|
||
/* Sizes for testing */
|
||
static quant_t quant_g[] = {
|
||
{10.0, 1, 5},
|
||
{80.0, 6, 15},
|
||
{10.0, 16, 20},
|
||
};
|
||
#elif 0
|
||
/* Larger I/O */
|
||
static quant_t quant_g[] = {
|
||
{10.0, 1, 1000},
|
||
{80.0, 1001, 5000},
|
||
{10.0, 5001, 10000},
|
||
};
|
||
#else
|
||
/* All same size */
|
||
static quant_t quant_g[] = {
|
||
{100.0, 1000, 1000}
|
||
};
|
||
#endif
|
||
|
||
static volatile sig_atomic_t alarm_g = 0;
|
||
static volatile sig_atomic_t timeout_g = 0;
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: catch_alarm
|
||
*
|
||
* Purpose: Increments the global `alarm_g' and resets the alarm for
|
||
* another few seconds.
|
||
*
|
||
* Return: void
|
||
*
|
||
* Programmer: Robb Matzke
|
||
* Wednesday, August 26, 1998
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static void
|
||
catch_alarm(int __unused__ signum)
|
||
{
|
||
static int ncalls=0;
|
||
|
||
ncalls++;
|
||
if (0==ncalls % NOTIFY_INTERVAL) {
|
||
alarm_g++;
|
||
}
|
||
if (timeout_g>0) --timeout_g;
|
||
alarm(1);
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: display_error_cb
|
||
*
|
||
* Purpose: Displays the error stack after printing "*FAILED*".
|
||
*
|
||
* Return: Success: 0
|
||
*
|
||
* Failure: -1
|
||
*
|
||
* Programmer: Robb Matzke
|
||
* Wednesday, March 4, 1998
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static herr_t
|
||
display_error_cb (void __unused__ *client_data)
|
||
{
|
||
putchar('\n');
|
||
H5Eprint (stdout);
|
||
return 0;
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: rand_nelmts
|
||
*
|
||
* Purpose: Returns a the length of a 1-d array according to the
|
||
* probabilities described above.
|
||
*
|
||
* Return: Success: Number of elements
|
||
*
|
||
* Failure: never fails
|
||
*
|
||
* Programmer: Robb Matzke
|
||
* Thursday, August 20, 1998
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static size_t
|
||
rand_nelmts(int reset_counters)
|
||
{
|
||
double p = (rand() % 1000000)/1000000.0;
|
||
double total = 0.0;
|
||
size_t size=0, i;
|
||
static size_t ncalls=0;
|
||
|
||
if (reset_counters) {
|
||
printf(" %9s %8s %8s\n", "Length", "Requsted", "Actual");
|
||
printf(" --------------- -------- --------\n");
|
||
for (i=0; i<NELMTS(quant_g); i++) {
|
||
printf(" [%6lu,%6lu] %7.3f%% %7.3f%%\n",
|
||
(unsigned long)(quant_g[i].lo),
|
||
(unsigned long)(quant_g[i].hi),
|
||
quant_g[i].percent,
|
||
100.0*(double)(quant_g[i].nhits)/(double)ncalls);
|
||
quant_g[i].nhits = 0;
|
||
}
|
||
printf(" --------------- -------- --------\n");
|
||
ncalls = 0;
|
||
size = 0;
|
||
} else {
|
||
for (i=0; i<NELMTS(quant_g); i++) {
|
||
total += quant_g[i].percent/100.0;
|
||
if (p<total) {
|
||
size = rand()%(1+(quant_g[i].hi-quant_g[i].lo)) +
|
||
quant_g[i].lo;
|
||
quant_g[i].nhits++;
|
||
break;
|
||
}
|
||
}
|
||
assert(i<NELMTS(quant_g));
|
||
ncalls++;
|
||
}
|
||
|
||
return size;
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: ragged_write_all
|
||
*
|
||
* Purpose: Writes rows to the ragged array RA.
|
||
*
|
||
* Return: Success: 0
|
||
*
|
||
* Failure: -1
|
||
*
|
||
* Programmer: Robb Matzke
|
||
* Thursday, August 27, 1998
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static int
|
||
ragged_write_all(hid_t ra, hsize_t rows_at_once)
|
||
{
|
||
int *dd, total_nelmts=0;
|
||
hssize_t row; /*current row number */
|
||
hsize_t i; /*counter */
|
||
hsize_t max_width = quant_g[NELMTS(quant_g)-1].hi;
|
||
hsize_t interval_nelmts; /*elmts/interval timer */
|
||
hsize_t *size=NULL; /*size of each row */
|
||
void **buf=NULL; /*buffer for each row */
|
||
H5_timer_t timer, timer_total; /*performance timers */
|
||
char s[64]; /*tempory string buffer */
|
||
char testname[80];
|
||
|
||
sprintf(testname, "Testing write all, units of %lu",
|
||
(unsigned long)rows_at_once);
|
||
printf("%s...\n", testname);
|
||
fflush(stdout);
|
||
timeout_g = TIME_LIMIT;
|
||
|
||
/* Create the ragged array row in memory */
|
||
if (NULL==(dd = malloc(max_width*sizeof(C_MTYPE))) ||
|
||
NULL==(size = malloc(rows_at_once*sizeof(*size))) ||
|
||
NULL==(buf = malloc(rows_at_once*sizeof(*buf)))) {
|
||
puts("Memory allocation failed");
|
||
goto error;
|
||
}
|
||
for (i=0; i<max_width; i++) dd[i] = i+1;
|
||
|
||
/*
|
||
* Describe a few rows then add them to the ragged array. Print a status
|
||
* report every once in a while too.
|
||
*/
|
||
printf(" %8s %8s %8s %10s\n",
|
||
"Row", "Nelmts", "Complete", "Bandwidth");
|
||
printf(" -------- -------- -------- ----------\n");
|
||
H5_timer_reset(&timer_total);
|
||
H5_timer_begin(&timer);
|
||
interval_nelmts = 0;
|
||
for (row=0; total_nelmts<MAX_NELMTS && timeout_g>0; row+=i) {
|
||
for (i=0; i<rows_at_once && total_nelmts<MAX_NELMTS; i++) {
|
||
size[i] = rand_nelmts(0);
|
||
total_nelmts += size[i];
|
||
buf[i] = dd;
|
||
interval_nelmts += size[i];
|
||
}
|
||
if (H5RAwrite(ra, row, i, H_MTYPE, size, buf)<0) goto error;
|
||
if (0==row || alarm_g || 0==timeout_g) {
|
||
alarm_g = 0;
|
||
H5_timer_end(&timer_total, &timer);
|
||
/*
|
||
* The extra cast in the following statement is a bug workaround
|
||
* for the Win32 version 5.0 compiler.
|
||
* 1998-11-06 ptl
|
||
*/
|
||
H5_bandwidth(s,
|
||
(double)(hssize_t)interval_nelmts*sizeof(C_MTYPE),
|
||
timer.etime);
|
||
printf(" %8lu %8lu %7.3f%% %10s%s\n",
|
||
(unsigned long)(row+i), (unsigned long)total_nelmts,
|
||
100.0*total_nelmts/MAX_NELMTS, s,
|
||
0==timeout_g?" (aborting)":"");
|
||
interval_nelmts = 0;
|
||
H5_timer_begin(&timer);
|
||
}
|
||
}
|
||
|
||
/* Conclusions */
|
||
if (timeout_g) { /*a minor race condition, but who really cares?*/
|
||
H5_timer_end(&timer_total, &timer);
|
||
/*
|
||
* The extra cast in the following statement is a bug workaround for
|
||
* the Win32 version 5.0 compiler.
|
||
* 1998-11-06 ptl
|
||
*/
|
||
H5_bandwidth(s, (double)(hssize_t)interval_nelmts*sizeof(C_MTYPE),
|
||
timer.etime);
|
||
printf(" %8lu %8lu %7.3f%% %10s\n",
|
||
(unsigned long)row, (unsigned long)total_nelmts,
|
||
100.0*total_nelmts/MAX_NELMTS, s);
|
||
}
|
||
printf(" -------- -------- -------- ----------\n");
|
||
H5_bandwidth(s, (double)total_nelmts*sizeof(C_MTYPE), timer_total.etime);
|
||
printf(" %27s%10s\n", "", s);
|
||
|
||
/* Cleanup */
|
||
free(dd);
|
||
free(size);
|
||
free(buf);
|
||
printf("%-70s PASSED\n\n", testname);
|
||
return 0;
|
||
|
||
error:
|
||
printf("%-70s*FAILED*\n\n", testname);
|
||
return -1;
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: ragged_read_all
|
||
*
|
||
* Purpose: Reads all rows of a ragged array in row order a few rows at a
|
||
* time.
|
||
*
|
||
* Return: Success: 0
|
||
*
|
||
* Failure: -1
|
||
*
|
||
* Programmer: Robb Matzke
|
||
* Thursday, August 27, 1998
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static int
|
||
ragged_read_all(hid_t ra, hsize_t rows_at_once)
|
||
{
|
||
int total_nelmts=0;
|
||
hsize_t i, j; /*counters */
|
||
hssize_t row; /*current row number */
|
||
hsize_t interval_nelmts; /*elmts/interval timer */
|
||
hsize_t *size=NULL; /*size of each row */
|
||
C_MTYPE **buf=NULL; /*buffer for each row */
|
||
H5_timer_t timer, timer_total; /*performance timers */
|
||
char s[64]; /*tempory string buffer */
|
||
char testname[80];
|
||
|
||
sprintf(testname, "Testing read all, units of %lu",
|
||
(unsigned long)rows_at_once);
|
||
printf("%s...\n", testname);
|
||
fflush(stdout);
|
||
timeout_g = TIME_LIMIT;
|
||
|
||
/* Create the ragged array row in memory */
|
||
if (NULL==(size = malloc(rows_at_once*sizeof(*size))) ||
|
||
NULL==(buf = malloc(rows_at_once*sizeof(*buf)))) {
|
||
puts("Memory allocation failed");
|
||
goto error;
|
||
}
|
||
|
||
/*
|
||
* Read a few rows at a time from the ragged array. Print a status report
|
||
* every once in a while too.
|
||
*/
|
||
printf(" %8s %8s %8s %10s\n",
|
||
"Row", "Nelmts", "Complete", "Bandwidth");
|
||
printf(" -------- -------- -------- ----------\n");
|
||
H5_timer_reset(&timer_total);
|
||
H5_timer_begin(&timer);
|
||
interval_nelmts = 0;
|
||
for (row=0; total_nelmts<MAX_NELMTS && timeout_g>0; row+=i) {
|
||
|
||
/* Clear data then read */
|
||
HDmemset(size, 0, rows_at_once*sizeof(*size));
|
||
HDmemset(buf, 0, rows_at_once*sizeof(*buf));
|
||
if (H5RAread(ra, row, rows_at_once, H_MTYPE, size,
|
||
(void**)buf)<0) {
|
||
goto error;
|
||
}
|
||
|
||
/* Check values read */
|
||
for (i=0; i<rows_at_once && size[i]; i++) {
|
||
interval_nelmts += size[i];
|
||
total_nelmts += size[i];
|
||
for (j=0; j<size[i]; j++) {
|
||
if (buf[i][j]!=j+1) {
|
||
printf("Wrong value(s) read for row %ld.\n",
|
||
(long)(row+i));
|
||
for (j=0; j<size[i]; j++) {
|
||
printf("%s%d", j?",":"", buf[i][j]);
|
||
}
|
||
putchar('\n');
|
||
goto error;
|
||
}
|
||
}
|
||
free(buf[i]);
|
||
buf[i] = NULL;
|
||
}
|
||
|
||
/* Print statistics? */
|
||
if (0==row || alarm_g || 0==timeout_g) {
|
||
alarm_g = 0;
|
||
H5_timer_end(&timer_total, &timer);
|
||
/*
|
||
* The extra cast in the following statement is a bug workaround
|
||
* for the Win32 version 5.0 compiler.
|
||
* 1998-11-06 ptl
|
||
*/
|
||
H5_bandwidth(s, (double)(hssize_t)interval_nelmts*sizeof(C_MTYPE),
|
||
timer.etime);
|
||
printf(" %8lu %8lu %7.3f%% %10s%s\n",
|
||
(unsigned long)(row+i), (unsigned long)total_nelmts,
|
||
100.0*total_nelmts/MAX_NELMTS, s,
|
||
0==timeout_g?" (aborting)":"");
|
||
interval_nelmts = 0;
|
||
H5_timer_begin(&timer);
|
||
}
|
||
if (0==size[rows_at_once-1]) {
|
||
/* Reached the end of the array */
|
||
if (total_nelmts<MAX_NELMTS) {
|
||
puts(" * Short read, previous write probably aborted");
|
||
}
|
||
row += i;
|
||
break;
|
||
}
|
||
}
|
||
|
||
/* Conclusions */
|
||
if (timeout_g) { /*a minor race condition, but who really cares?*/
|
||
H5_timer_end(&timer_total, &timer);
|
||
/*
|
||
* The extra cast in the following statement is a bug workaround for
|
||
* the Win32 version 5.0 compiler.
|
||
* 1998-11-06 ptl
|
||
*/
|
||
H5_bandwidth(s, (double)(hssize_t)interval_nelmts*sizeof(C_MTYPE),
|
||
timer.etime);
|
||
printf(" %8lu %8lu %7.3f%% %10s\n",
|
||
(unsigned long)row, (unsigned long)total_nelmts,
|
||
100.0*total_nelmts/MAX_NELMTS, s);
|
||
}
|
||
printf(" -------- -------- -------- ----------\n");
|
||
H5_bandwidth(s, (double)total_nelmts*sizeof(C_MTYPE), timer_total.etime);
|
||
printf(" %27s%10s\n", "", s);
|
||
|
||
/* Cleanup */
|
||
free(size);
|
||
free(buf);
|
||
printf("%-70s PASSED\n\n", testname);
|
||
return 0;
|
||
|
||
error:
|
||
printf("%-70s*FAILED*\n\n", testname);
|
||
return -1;
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: ragged_read_short
|
||
*
|
||
* Purpose: Reads all the data but only the part that is in the `raw'
|
||
* dataset. We should see a nice speed increase because we
|
||
* don't have to perform the little reads into the overflow
|
||
* array.
|
||
*
|
||
* Return: Success: 0
|
||
*
|
||
* Failure: -1
|
||
*
|
||
* Programmer: Robb Matzke
|
||
* Friday, August 28, 1998
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static int
|
||
ragged_read_short(hid_t ra, hsize_t rows_at_once, hsize_t width)
|
||
{
|
||
int total_nelmts=0;
|
||
hsize_t i, j;
|
||
hssize_t row; /*current row number */
|
||
hsize_t interval_nelmts; /*elmts/interval timer */
|
||
hsize_t read_nelmts=0; /*total elements read */
|
||
hsize_t *size=NULL; /*size of each row */
|
||
C_MTYPE **buf=NULL; /*buffer for each row */
|
||
H5_timer_t timer, timer_total; /*performance timers */
|
||
char s[64]; /*tempory string buffer */
|
||
char testname[80];
|
||
|
||
sprintf(testname, "Testing read short, units of %lu",
|
||
(unsigned long)rows_at_once);
|
||
printf("%s...\n", testname);
|
||
fflush(stdout);
|
||
timeout_g = TIME_LIMIT;
|
||
|
||
/* Create the ragged array row in memory */
|
||
if (NULL==(size = malloc(rows_at_once*sizeof(*size))) ||
|
||
NULL==(buf = malloc(rows_at_once*sizeof(*buf)))) {
|
||
puts("Memory allocation failed");
|
||
goto error;
|
||
}
|
||
for (i=0; i<rows_at_once; i++) {
|
||
if (NULL==(buf[i] = malloc(width*sizeof(C_MTYPE)))) {
|
||
puts("Memory allocation failed");
|
||
goto error;
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Read a few rows at a time from the ragged array. Print a status report
|
||
* every once in a while too.
|
||
*/
|
||
printf(" %8s %8s %8s %10s\n",
|
||
"Row", "Nelmts", "Complete", "Bandwidth");
|
||
printf(" -------- -------- -------- ----------\n");
|
||
H5_timer_reset(&timer_total);
|
||
H5_timer_begin(&timer);
|
||
interval_nelmts = 0;
|
||
for (row=0; total_nelmts<MAX_NELMTS && timeout_g>0; row+=i) {
|
||
|
||
/* Read data */
|
||
for (i=0; i<rows_at_once; i++) size[i] = width;
|
||
if (H5RAread(ra, row, rows_at_once, H_MTYPE, size,
|
||
(void**)buf)<0) {
|
||
goto error;
|
||
}
|
||
|
||
/* Check values read */
|
||
for (i=0; i<rows_at_once && size[i]; i++) {
|
||
|
||
/*
|
||
* Number of useful elements actually read in this timing
|
||
* interval. This is used to calculate bandwidth.
|
||
*/
|
||
interval_nelmts += MIN(width, size[i]);
|
||
|
||
/*
|
||
* Total number of elements actually read for rows so far.
|
||
*/
|
||
read_nelmts += MIN(width, size[i]);
|
||
|
||
/*
|
||
* Total number of elements attributed to the rows read so far.
|
||
* This is used to calculate the percent done.
|
||
*/
|
||
total_nelmts += size[i];
|
||
|
||
/* Check the values */
|
||
for (j=0; j<MIN(width, size[i]); j++) {
|
||
if (buf[i][j]!=j+1) {
|
||
printf("Wrong value(s) read for row %ld.\n",
|
||
(long)(row+i));
|
||
for (j=0; j<MIN(width, size[i]); j++) {
|
||
printf("%s%d", j?",":"", buf[i][j]);
|
||
}
|
||
putchar('\n');
|
||
goto error;
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Print statistics? */
|
||
if (0==row || alarm_g || 0==timeout_g) {
|
||
alarm_g = 0;
|
||
H5_timer_end(&timer_total, &timer);
|
||
/*
|
||
* The extra cast in the following statement is a bug workaround
|
||
* for the Win32 version 5.0 compiler.
|
||
* 1998-11-06 ptl
|
||
*/
|
||
H5_bandwidth(s,
|
||
(double)(hssize_t)interval_nelmts*sizeof(C_MTYPE),
|
||
timer.etime);
|
||
printf(" %8lu %8lu %7.3f%% %10s%s\n",
|
||
(unsigned long)(row+i), (unsigned long)read_nelmts,
|
||
100.0*total_nelmts/MAX_NELMTS, s,
|
||
0==timeout_g?" (aborting)":"");
|
||
interval_nelmts = 0;
|
||
H5_timer_begin(&timer);
|
||
}
|
||
if (0==size[rows_at_once-1]) {
|
||
/* Reached the end of the array */
|
||
if (total_nelmts<MAX_NELMTS) {
|
||
puts(" * Short read, previous write probably aborted");
|
||
}
|
||
row += i;
|
||
break;
|
||
}
|
||
}
|
||
|
||
/* Conclusions */
|
||
if (timeout_g) { /*a minor race condition, but who really cares?*/
|
||
H5_timer_end(&timer_total, &timer);
|
||
/*
|
||
* The extra cast in the following statement is a bug workaround for
|
||
* the Win32 version 5.0 compiler.
|
||
* 1998-11-06 ptl
|
||
*/
|
||
H5_bandwidth(s, (double)(hssize_t)interval_nelmts*sizeof(C_MTYPE),
|
||
timer.etime);
|
||
printf(" %8lu %8lu %7.3f%% %10s\n",
|
||
(unsigned long)row, (unsigned long)read_nelmts,
|
||
100.0*total_nelmts/MAX_NELMTS, s);
|
||
}
|
||
printf(" -------- -------- -------- ----------\n");
|
||
/*
|
||
* The extra cast in the following statement is a bug workaround for the
|
||
* Win32 version 5.0 compiler.
|
||
* 1998-11-06 ptl
|
||
*/
|
||
H5_bandwidth(s, (double)(hssize_t)read_nelmts*sizeof(C_MTYPE),
|
||
timer_total.etime);
|
||
printf(" %27s%10s\n", "", s);
|
||
|
||
/* Cleanup */
|
||
for (i=0; i<rows_at_once; i++) free(buf[i]);
|
||
free(size);
|
||
free(buf);
|
||
printf("%-70s PASSED\n\n", testname);
|
||
return 0;
|
||
|
||
error:
|
||
printf("%-70s*FAILED*\n\n", testname);
|
||
return -1;
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: main
|
||
*
|
||
* Purpose:
|
||
*
|
||
* Return: Success:
|
||
*
|
||
* Failure:
|
||
*
|
||
* Programmer: Robb Matzke
|
||
* Friday, August 21, 1998
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
int
|
||
main(int argc, char *argv[])
|
||
{
|
||
hid_t file, dcpl, ra;
|
||
hsize_t ch_size[2]; /*chunk size */
|
||
hsize_t rows_at_once=100; /*row aggregation */
|
||
int argno=1;
|
||
|
||
/* Parse command line options */
|
||
if (argno<argc) {
|
||
rows_at_once = strtol(argv[argno++], NULL, 0);
|
||
}
|
||
|
||
/* Display HDF5 API errors in a special way */
|
||
H5Eset_auto(display_error_cb, NULL);
|
||
|
||
/* Get a SIGALRM every few seconds */
|
||
#ifdef HAVE_SIGACTION
|
||
{
|
||
struct sigaction act;
|
||
act.sa_handler = catch_alarm;
|
||
sigemptyset(&(act.sa_mask));
|
||
act.sa_flags = 0;
|
||
sigaction(SIGALRM, &act, NULL);
|
||
alarm(1);
|
||
}
|
||
#else
|
||
puts("No sigaction(). This test may run for a *long* time.");
|
||
#endif
|
||
|
||
/* Create the file and ragged array */
|
||
if ((file=H5Fcreate("ragged.h5", H5F_ACC_TRUNC, H5P_DEFAULT,
|
||
H5P_DEFAULT))<0) goto error;
|
||
if ((dcpl=H5Pcreate(H5P_DATASET_CREATE))<0) goto error;
|
||
ch_size[1] = 20;
|
||
ch_size[0] = MAX(1, CH_SIZE/(ch_size[1]*sizeof(C_MTYPE))); /*length*/
|
||
printf("Chunk size is %lu by %lu\n",
|
||
(unsigned long)(ch_size[0]), (unsigned long)(ch_size[1]));
|
||
if (H5Pset_chunk(dcpl, 2, ch_size)<0) goto error;
|
||
if ((ra=H5RAcreate(file, "ra", H_FTYPE, dcpl))<0) goto error;
|
||
if (H5Pclose(dcpl)<0) goto error;
|
||
|
||
/* The tests */
|
||
if (ragged_write_all(ra, rows_at_once)<0) goto error;
|
||
if (ragged_read_all(ra, rows_at_once)<0) goto error;
|
||
if (ragged_read_short(ra, rows_at_once, ch_size[1])<0) goto error;
|
||
|
||
/* The tests again */
|
||
if (ragged_write_all(ra, rows_at_once)<0) goto error;
|
||
if (ragged_read_all(ra, rows_at_once)<0) goto error;
|
||
if (ragged_read_short(ra, rows_at_once, ch_size[1])<0) goto error;
|
||
|
||
/* Conclusions */
|
||
printf("\n\nDistribution of row lengths:\n");
|
||
rand_nelmts(1);
|
||
|
||
/* Cleanup */
|
||
if (H5RAclose(ra)<0) goto error;
|
||
if (H5Fclose(file)<0) goto error;
|
||
|
||
puts("All ragged array tests passed.");
|
||
return 0;
|
||
|
||
error:
|
||
puts("*** RAGGED ARRAY TEST(S) FAILED ***");
|
||
return -1;
|
||
}
|