mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2025-01-30 15:32:37 +08:00
Code Issues Packages Projects Releases Wiki Activity

[svn-r12605] Description:

Browse Source 
Break out a bunch of the misc. routines that were in src/H5.c into more
specific modules.

    Add optimized fletcher32 checksum routine, for checksumming metadata as
well as raw data.

Tested On:
    Linux/32 2.6 (chicago)
    Linux/64 2.6 (chicago2)
    Will test further after checkin...
This commit is contained in:
Quincey Koziol 2006-08-21 18:27:11 -05:00
parent 6bbe128367
commit 5fe34046c0
15 changed files with 3103 additions and 2494 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
MANIFEST
View File

@ -385,6 +385,7 @@
./src/hdf5-win.lnt _DO_NOT_DISTRIBUTE_
./src/hdf5-lin.lnt _DO_NOT_DISTRIBUTE_
./src/H5.c
./src/H5checksum.c
./src/H5dbg.c
./src/H5api_adpt.h
./src/H5err.txt
@ -392,6 +393,9 @@
./src/H5detect.c
./src/H5private.h
./src/H5public.h
./src/H5system.c
./src/H5timer.c
./src/H5trace.c
./src/H5A.c
./src/H5Apkg.h
./src/H5Aprivate.h
@ -726,6 +730,7 @@
./test/tarrold.h5
./test/tattr.c
./test/tbogus.h5
./test/tchecksum.c
./test/tconfig.c
./test/testframe.c
./test/testhdf5.c

2523
src/H5.c
View File

File diff suppressed because it is too large Load Diff

145
src/H5checksum.c Normal file
View File

@ -0,0 +1,145 @@
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Copyright by the Board of Trustees of the University of Illinois. *
* All rights reserved. *
* *
* This file is part of HDF5. The full HDF5 copyright notice, including *
* terms governing use, modification, and redistribution, is contained in *
* the files COPYING and Copyright.html. COPYING can be found at the root *
* of the source code distribution tree; Copyright.html can be found at the *
* root level of an installed copy of the electronic HDF5 document set and *
* is linked from the top-level documents page. It can also be found at *
* http://hdf.ncsa.uiuc.edu/HDF5/doc/Copyright.html. If you do not have *
* access to either file, you may request a copy from hdfhelp@ncsa.uiuc.edu. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*-------------------------------------------------------------------------
*
* Created: H5checksum.c
* Aug 21 2006
* Quincey Koziol <koziol@hdfgroup.org>
*
* Purpose: Internal code for computing fletcher32 checksums
*
*-------------------------------------------------------------------------
*/
/****************/
/* Module Setup */
/****************/
/***********/
/* Headers */
/***********/
#include "H5private.h" /* Generic Functions */
/****************/
/* Local Macros */
/****************/
/******************/
/* Local Typedefs */
/******************/
/********************/
/* Package Typedefs */
/********************/
/********************/
/* Local Prototypes */
/********************/
/*********************/
/* Package Variables */
/*********************/
/*****************************/
/* Library Private Variables */
/*****************************/
/*******************/
/* Local Variables */
/*******************/
/*-------------------------------------------------------------------------
* Function: H5_fletcher32
*
* Purpose: This routine provides a generic, fast checksum algorithm for
* use in the library.
*
* Note: See the Wikipedia page for Fletcher's checksum:
* http://en.wikipedia.org/wiki/Fletcher%27s_checksum
* for more details, etc.
*
* Return: 32-bit fletcher checksum of input buffer (can't fail)
*
* Programmer: Quincey Koziol
* Monday, August 21, 2006
*
*-------------------------------------------------------------------------
*/
uint32_t
H5_fletcher32(const void *_data, size_t _len)
{
const uint16_t *data = (const uint16_t *)_data; /* Pointer to the data to be summed */
size_t len = _len / 2; /* Length in 16-bit words */
uint32_t sum1 = 0xffff, sum2 = 0xffff;
uint32_t ret_value; /* Return value */
FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5_fletcher32)
/* Sanity check */
HDassert(_data);
HDassert(_len > 0);
/* Compute checksum for pairs of bytes */
/* The magic "360" value is is the largest number of sums that can be
* performed without numeric overflow. See the Wikipedia page for
* Fletcher's checksum: http://en.wikipedia.org/wiki/Fletcher%27s_checksum
* for more details, etc.
*/
while (len) {
unsigned tlen = len > 360 ? 360 : len;
len -= tlen;
do {
sum1 += *data++;
sum2 += sum1;
} while (--tlen);
sum1 = (sum1 & 0xffff) + (sum1 >> 16);
sum2 = (sum2 & 0xffff) + (sum2 >> 16);
}
/* Check for odd # of bytes */
if(_len % 2) {
sum1 += *(const uint8_t *)data;
sum2 += sum1;
sum1 = (sum1 & 0xffff) + (sum1 >> 16);
sum2 = (sum2 & 0xffff) + (sum2 >> 16);
} /* end if */
/* Second reduction step to reduce sums to 16 bits */
sum1 = (sum1 & 0xffff) + (sum1 >> 16);
sum2 = (sum2 & 0xffff) + (sum2 >> 16);
/* Byteswap result on little-endian platforms */
#ifdef H5_WORDS_BIGENDIAN
ret_value = sum2 << 16 | sum1;
#else /* H5_WORDS_BIGENDIAN */
ret_value = (sum2 << 8) & 0x00ff0000;
ret_value |= (sum2 << 24) & 0xff000000;
ret_value |= (sum1 << 8) & 0x0000ff00;
ret_value |= (sum1 >> 8) & 0x000000ff;
#endif /* H5_WORDS_BIGENDIAN */
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5_fletcher32() */

3
src/H5private.h
View File

@ -1446,6 +1446,9 @@ H5_DLL int H5S_term_interface(void);
H5_DLL int H5T_term_interface(void);
H5_DLL int H5Z_term_interface(void);
/* Checksum functions */
H5_DLL uint32_t H5_fletcher32(const void *data, size_t len);
/* Functions for debugging */
H5_DLL herr_t H5_buffer_dump(FILE *stream, int indent, uint8_t *buf,
uint8_t *marker, size_t buf_offset, size_t buf_size);

578
src/H5system.c Normal file
View File

@ -0,0 +1,578 @@
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Copyright by the Board of Trustees of the University of Illinois. *
* All rights reserved. *
* *
* This file is part of HDF5. The full HDF5 copyright notice, including *
* terms governing use, modification, and redistribution, is contained in *
* the files COPYING and Copyright.html. COPYING can be found at the root *
* of the source code distribution tree; Copyright.html can be found at the *
* root level of an installed copy of the electronic HDF5 document set and *
* is linked from the top-level documents page. It can also be found at *
* http://hdf.ncsa.uiuc.edu/HDF5/doc/Copyright.html. If you do not have *
* access to either file, you may request a copy from hdfhelp@ncsa.uiuc.edu. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*-------------------------------------------------------------------------
*
* Created: H5system.c
* Aug 21 2006
* Quincey Koziol <koziol@hdfgroup.org>
*
* Purpose: System call wrapper implementations.
*
*-------------------------------------------------------------------------
*/
/****************/
/* Module Setup */
/****************/
/***********/
/* Headers */
/***********/
#include "H5private.h" /* Generic Functions */
#include "H5Fprivate.h" /* File access */
/****************/
/* Local Macros */
/****************/
/******************/
/* Local Typedefs */
/******************/
/********************/
/* Package Typedefs */
/********************/
/********************/
/* Local Prototypes */
/********************/
/*********************/
/* Package Variables */
/*********************/
/*****************************/
/* Library Private Variables */
/*****************************/
/*******************/
/* Local Variables */
/*******************/
/*-------------------------------------------------------------------------
* Function: HDfprintf
*
* Purpose: Prints the optional arguments under the control of the format
* string FMT to the stream STREAM. This function takes the
* same format as fprintf(3c) with a few added features:
*
* The conversion modifier `H' refers to the size of an
* `hsize_t' or `hssize_t' type. For instance, "0x%018Hx"
* prints an `hsize_t' value as a hex number right justified and
* zero filled in an 18-character field.
*
* The conversion `a' refers to an `haddr_t' type.
*
* Return: Success: Number of characters printed
*
* Failure: -1
*
* Programmer: Robb Matzke
* Thursday, April 9, 1998
*
* Modifications:
* Robb Matzke, 1999-07-27
* The `%a' format refers to an argument of `haddr_t' type
* instead of `haddr_t*' and the return value is correct.
*-------------------------------------------------------------------------
*/
int
HDfprintf(FILE *stream, const char *fmt, ...)
{
int n=0, nout = 0;
int fwidth, prec;
int zerofill;
int leftjust;
int plussign;
int ldspace;
int prefix;
char modifier[8];
int conv;
char *rest, format_templ[128];
const char *s;
va_list ap;
assert (stream);
assert (fmt);
va_start (ap, fmt);
while (*fmt) {
fwidth = prec = 0;
zerofill = 0;
leftjust = 0;
plussign = 0;
prefix = 0;
ldspace = 0;
modifier[0] = '\0';
if ('%'==fmt[0] && '%'==fmt[1]) {
HDputc ('%', stream);
fmt += 2;
nout++;
} else if ('%'==fmt[0]) {
s = fmt + 1;
/* Flags */
while (HDstrchr ("-+ #", *s)) {
switch (*s) {
case '-':
leftjust = 1;
break;
case '+':
plussign = 1;
break;
case ' ':
ldspace = 1;
break;
case '#':
prefix = 1;
break;
} /*lint !e744 Switch statement doesn't _need_ default */
s++;
}
/* Field width */
if (HDisdigit (*s)) {
zerofill = ('0'==*s);
fwidth = (int)HDstrtol (s, &rest, 10);
s = rest;
} else if ('*'==*s) {
fwidth = va_arg (ap, int);
if (fwidth<0) {
leftjust = 1;
fwidth = -fwidth;
}
s++;
}
/* Precision */
if ('.'==*s) {
s++;
if (HDisdigit (*s)) {
prec = (int)HDstrtol (s, &rest, 10);
s = rest;
} else if ('*'==*s) {
prec = va_arg (ap, int);
s++;
}
if (prec<1) prec = 1;
}
/* Extra type modifiers */
if (HDstrchr ("ZHhlqLI", *s)) {
switch (*s) {
/*lint --e{506} Don't issue warnings about constant value booleans */
/*lint --e{774} Don't issue warnings boolean within 'if' always evaluates false/true */
case 'H':
if (sizeof(hsize_t)<sizeof(long)) {
modifier[0] = '\0';
} else if (sizeof(hsize_t)==sizeof(long)) {
HDstrcpy (modifier, "l");
} else {
HDstrcpy (modifier, H5_PRINTF_LL_WIDTH);
}
break;
case 'Z':
if (sizeof(size_t)<sizeof(long)) {
modifier[0] = '\0';
} else if (sizeof(size_t)==sizeof(long)) {
HDstrcpy (modifier, "l");
} else {
HDstrcpy (modifier, H5_PRINTF_LL_WIDTH);
}
break;
default:
/* Handle 'I64' modifier for Microsoft's "__int64" type */
if(*s=='I' && *(s+1)=='6' && *(s+2)=='4') {
modifier[0] = *s;
modifier[1] = *(s+1);
modifier[2] = *(s+2);
modifier[3] = '\0';
s+=2; /* Increment over 'I6', the '4' is taken care of below */
} /* end if */
else {
/* Handle 'll' for long long types */
if(*s=='l' && *(s+1)=='l') {
modifier[0] = *s;
modifier[1] = *s;
modifier[2] = '\0';
s++; /* Increment over first 'l', second is taken care of below */
} /* end if */
else {
modifier[0] = *s;
modifier[1] = '\0';
} /* end else */
} /* end else */
break;
}
s++;
}
/* Conversion */
conv = *s++;
/* Create the format template */
sprintf (format_templ, "%%%s%s%s%s%s",
leftjust?"-":"", plussign?"+":"",
ldspace?" ":"", prefix?"#":"", zerofill?"0":"");
if (fwidth>0)
sprintf (format_templ+HDstrlen(format_templ), "%d", fwidth);
if (prec>0)
sprintf (format_templ+HDstrlen(format_templ), ".%d", prec);
if (*modifier)
sprintf (format_templ+HDstrlen(format_templ), "%s", modifier);
sprintf (format_templ+HDstrlen(format_templ), "%c", conv);
/* Conversion */
switch (conv) {
case 'd':
case 'i':
if (!HDstrcmp(modifier, "h")) {
short x = (short)va_arg (ap, int);
n = fprintf (stream, format_templ, x);
} else if (!*modifier) {
int x = va_arg (ap, int);
n = fprintf (stream, format_templ, x);
} else if (!HDstrcmp (modifier, "l")) {
long x = va_arg (ap, long);
n = fprintf (stream, format_templ, x);
} else {
int64_t x = va_arg(ap, int64_t);
n = fprintf (stream, format_templ, x);
}
break;
case 'o':
case 'u':
case 'x':
case 'X':
if (!HDstrcmp (modifier, "h")) {
unsigned short x = (unsigned short)va_arg (ap, unsigned int);
n = fprintf (stream, format_templ, x);
} else if (!*modifier) {
unsigned int x = va_arg (ap, unsigned int); /*lint !e732 Loss of sign not really occuring */
n = fprintf (stream, format_templ, x);
} else if (!HDstrcmp (modifier, "l")) {
unsigned long x = va_arg (ap, unsigned long); /*lint !e732 Loss of sign not really occuring */
n = fprintf (stream, format_templ, x);
} else {
uint64_t x = va_arg(ap, uint64_t); /*lint !e732 Loss of sign not really occuring */
n = fprintf (stream, format_templ, x);
}
break;
case 'f':
case 'e':
case 'E':
case 'g':
case 'G':
if (!HDstrcmp (modifier, "h")) {
float x = (float) va_arg (ap, double);
n = fprintf (stream, format_templ, x);
} else if (!*modifier || !HDstrcmp (modifier, "l")) {
double x = va_arg (ap, double);
n = fprintf (stream, format_templ, x);
} else {
/*
* Some compilers complain when `long double' and
* `double' are the same thing.
*/
#if H5_SIZEOF_LONG_DOUBLE != H5_SIZEOF_DOUBLE
long double x = va_arg (ap, long double);
n = fprintf (stream, format_templ, x);
#else
double x = va_arg (ap, double);
n = fprintf (stream, format_templ, x);
#endif
}
break;
case 'a':
{
haddr_t x = va_arg (ap, haddr_t); /*lint !e732 Loss of sign not really occuring */
if (H5F_addr_defined(x)) {
sprintf(format_templ, "%%%s%s%s%s%s",
leftjust?"-":"", plussign?"+":"",
ldspace?" ":"", prefix?"#":"",
zerofill?"0":"");
if (fwidth>0)
sprintf(format_templ+HDstrlen(format_templ), "%d", fwidth);
/*lint --e{506} Don't issue warnings about constant value booleans */
/*lint --e{774} Don't issue warnings boolean within 'if' always evaluates false/true */
if (sizeof(x)==H5_SIZEOF_INT) {
HDstrcat(format_templ, "u");
} else if (sizeof(x)==H5_SIZEOF_LONG) {
HDstrcat(format_templ, "lu");
} else if (sizeof(x)==H5_SIZEOF_LONG_LONG) {
HDstrcat(format_templ, H5_PRINTF_LL_WIDTH);
HDstrcat(format_templ, "u");
}
n = fprintf(stream, format_templ, x);
} else {
HDstrcpy(format_templ, "%");
if (leftjust)
HDstrcat(format_templ, "-");
if (fwidth)
sprintf(format_templ+HDstrlen(format_templ), "%d", fwidth);
HDstrcat(format_templ, "s");
fprintf(stream, format_templ, "UNDEF");
}
}
break;
case 'c':
{
char x = (char)va_arg (ap, int);
n = fprintf (stream, format_templ, x);
}
break;
case 's':
case 'p':
{
char *x = va_arg (ap, char*); /*lint !e64 Type mismatch not really occuring */
n = fprintf (stream, format_templ, x);
}
break;
case 'n':
format_templ[HDstrlen(format_templ)-1] = 'u';
n = fprintf (stream, format_templ, nout);
break;
case 't':
{
htri_t tri_var = va_arg (ap, htri_t);
if (tri_var > 0) fprintf (stream, "TRUE");
else if (!tri_var) fprintf (stream, "FALSE");
else fprintf (stream, "FAIL(%d)", (int)tri_var);
}
break;
default:
HDfputs (format_templ, stream);
n = (int)HDstrlen (format_templ);
break;
}
nout += n;
fmt = s;
} else {
HDputc (*fmt, stream);
fmt++;
nout++;
}
}
va_end (ap);
return nout;
} /* end HDfprintf() */
/*-------------------------------------------------------------------------
* Function: HDstrtoll
*
* Purpose: Converts the string S to an int64_t value according to the
* given BASE, which must be between 2 and 36 inclusive, or be
* the special value zero.
*
* The string must begin with an arbitrary amount of white space
* (as determined by isspace(3c)) followed by a single optional
* `+' or `-' sign. If BASE is zero or 16 the string may then
* include a `0x' or `0X' prefix, and the number will be read in
* base 16; otherwise a zero BASE is taken as 10 (decimal)
* unless the next character is a `0', in which case it is taken
* as 8 (octal).
*
* The remainder of the string is converted to an int64_t in the
* obvious manner, stopping at the first character which is not
* a valid digit in the given base. (In bases above 10, the
* letter `A' in either upper or lower case represetns 10, `B'
* represents 11, and so forth, with `Z' representing 35.)
*
* If REST is not null, the address of the first invalid
* character in S is stored in *REST. If there were no digits
* at all, the original value of S is stored in *REST. Thus, if
* *S is not `\0' but **REST is `\0' on return the entire string
* was valid.
*
* Return: Success: The result.
*
* Failure: If the input string does not contain any
* digits then zero is returned and REST points
* to the original value of S. If an overflow
* or underflow occurs then the maximum or
* minimum possible value is returned and the
* global `errno' is set to ERANGE. If BASE is
* incorrect then zero is returned.
*
* Programmer: Robb Matzke
* Thursday, April 9, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int64_t
HDstrtoll(const char *s, const char **rest, int base)
{
int64_t sign=1, acc=0;
hbool_t overflow = FALSE;
errno = 0;
if (!s || (base && (base<2 || base>36))) {
if (rest) *rest = s;
return 0;
}
/* Skip white space */
while (HDisspace (*s)) s++;
/* Optional minus or plus sign */
if ('+'==*s) {
s++;
} else if ('-'==*s) {
sign = -1;
s++;
}
/* Zero base prefix */
if (0==base && '0'==*s && ('x'==s[1] || 'X'==s[1])) {
base = 16;
s += 2;
} else if (0==base && '0'==*s) {
base = 8;
s++;
} else if (0==base) {
base = 10;
}
/* Digits */
while ((base<=10 && *s>='0' && *s<'0'+base) ||
(base>10 && ((*s>='0' && *s<='9') ||
(*s>='a' && *s<'a'+base-10) ||
(*s>='A' && *s<'A'+base-10)))) {
if (!overflow) {
int64_t digit = 0;
if (*s>='0' && *s<='9') digit = *s - '0';
else if (*s>='a' && *s<='z') digit = (*s-'a')+10;
else digit = (*s-'A')+10;
if (acc*base+digit < acc) {
overflow = TRUE;
} else {
acc = acc*base + digit;
}
}
s++;
}
/* Overflow */
if (overflow) {
if (sign>0) {
acc = ((uint64_t)1<<(8*sizeof(int64_t)-1))-1;
} else {
acc = (uint64_t)1<<(8*sizeof(int64_t)-1);
}
errno = ERANGE;
}
/* Return values */
acc *= sign;
if (rest) *rest = s;
return acc;
} /* end HDstrtoll() */
/*-------------------------------------------------------------------------
* Function: HDrand/HDsrand
*
* Purpose: Wrapper function for rand. If rand_r exists on this system,
* use it.
*
* Wrapper function for srand. If rand_r is available, it will keep
* track of the seed locally instead of using srand() which modifies
* global state and can break other programs.
*
* Return: Success: Random number from 0 to RAND_MAX
*
* Failure: Cannot fail.
*
* Programmer: Leon Arber
* March 6, 2006.
*
*-------------------------------------------------------------------------
*/
#ifdef H5_HAVE_RAND_R
static unsigned int g_seed = 42;
int HDrand(void)
{
return rand_r(&g_seed);
}
void HDsrand(unsigned int seed)
{
g_seed = seed;
}
#endif
/*-------------------------------------------------------------------------
* Function: HDremove_all
*
* Purpose: Wrapper function for remove on VMS systems
*
* This function deletes all versions of a file
*
* Return: Success: 0;
*
* Failure: -1
*
* Programmer: Elena Pourmal
* March 22, 2006
*
*-------------------------------------------------------------------------
*/
#ifdef H5_VMS
int
HDremove_all(char *fname)
{
int ret_value = -1;
char *_fname;
_fname = H5MM_malloc(HDstrlen(fname) + 3); /* to accomodate ;* and null */
if(_fname) {
HDstrcpy(_fname, fname);
HDstrcat(_fname,";*");
HDremove(_fname);
H5MM_xfree(_fname);
ret_value = 0;
}
return ret_value;
}
#endif

248
src/H5timer.c Normal file
View File

@ -0,0 +1,248 @@
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Copyright by the Board of Trustees of the University of Illinois. *
* All rights reserved. *
* *
* This file is part of HDF5. The full HDF5 copyright notice, including *
* terms governing use, modification, and redistribution, is contained in *
* the files COPYING and Copyright.html. COPYING can be found at the root *
* of the source code distribution tree; Copyright.html can be found at the *
* root level of an installed copy of the electronic HDF5 document set and *
* is linked from the top-level documents page. It can also be found at *
* http://hdf.ncsa.uiuc.edu/HDF5/doc/Copyright.html. If you do not have *
* access to either file, you may request a copy from hdfhelp@ncsa.uiuc.edu. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*-------------------------------------------------------------------------
*
* Created: H5timer.c
* Aug 21 2006
* Quincey Koziol <koziol@hdfgroup.org>
*
* Purpose: Internal 'timer' routines & support routines.
*
*-------------------------------------------------------------------------
*/
/****************/
/* Module Setup */
/****************/
/***********/
/* Headers */
/***********/
#include "H5private.h" /* Generic Functions */
/* We need this for the struct rusage declaration */
#if defined(H5_HAVE_GETRUSAGE) && defined(H5_HAVE_SYS_RESOURCE_H)
# include <sys/resource.h>
#endif
/****************/
/* Local Macros */
/****************/
/******************/
/* Local Typedefs */
/******************/
/********************/
/* Package Typedefs */
/********************/
/********************/
/* Local Prototypes */
/********************/
/*********************/
/* Package Variables */
/*********************/
/*****************************/
/* Library Private Variables */
/*****************************/
/*******************/
/* Local Variables */
/*******************/
/*-------------------------------------------------------------------------
* Function: H5_timer_reset
*
* Purpose: Resets the timer struct to zero. Use this to reset a timer
* that's being used as an accumulator for summing times.
*
* Return: void
*
* Programmer: Robb Matzke
* Thursday, April 16, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
void
H5_timer_reset (H5_timer_t *timer)
{
assert (timer);
HDmemset (timer, 0, sizeof *timer);
} /* end H5_timer_reset() */
/*-------------------------------------------------------------------------
* Function: H5_timer_begin
*
* Purpose: Initialize a timer to time something.
*
* Return: void
*
* Programmer: Robb Matzke
* Thursday, April 16, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
void
H5_timer_begin (H5_timer_t *timer)
{
#ifdef H5_HAVE_GETRUSAGE
struct rusage rusage;
#endif
#ifdef H5_HAVE_GETTIMEOFDAY
struct timeval etime;
#endif
assert (timer);
#ifdef H5_HAVE_GETRUSAGE
HDgetrusage (RUSAGE_SELF, &rusage);
timer->utime = (double)rusage.ru_utime.tv_sec +
((double)rusage.ru_utime.tv_usec/1e6);
timer->stime = (double)rusage.ru_stime.tv_sec +
((double)rusage.ru_stime.tv_usec/1e6);
#else
timer->utime = 0.0;
timer->stime = 0.0;
#endif
#ifdef H5_HAVE_GETTIMEOFDAY
HDgettimeofday (&etime, NULL);
timer->etime = (double)etime.tv_sec + ((double)etime.tv_usec/1e6);
#else
timer->etime = 0.0;
#endif
} /* end H5_timer_begin() */
/*-------------------------------------------------------------------------
* Function: H5_timer_end
*
* Purpose: This function should be called at the end of a timed region.
* The SUM is an optional pointer which will accumulate times.
* TMS is the same struct that was passed to H5_timer_start().
* On return, TMS will contain total times for the timed region.
*
* Return: void
*
* Programmer: Robb Matzke
* Thursday, April 16, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
void
H5_timer_end (H5_timer_t *sum/*in,out*/, H5_timer_t *timer/*in,out*/)
{
H5_timer_t now;
assert (timer);
H5_timer_begin (&now);
timer->utime = MAX(0.0, now.utime - timer->utime);
timer->stime = MAX(0.0, now.stime - timer->stime);
timer->etime = MAX(0.0, now.etime - timer->etime);
if (sum) {
sum->utime += timer->utime;
sum->stime += timer->stime;
sum->etime += timer->etime;
}
} /* end H5_timer_end() */
/*-------------------------------------------------------------------------
* Function: H5_bandwidth
*
* Purpose: Prints the bandwidth (bytes per second) in a field 10
* characters wide widh four digits of precision like this:
*
* NaN If <=0 seconds
* 1234. TB/s
* 123.4 TB/s
* 12.34 GB/s
* 1.234 MB/s
* 4.000 kB/s
* 1.000 B/s
* 0.000 B/s If NBYTES==0
* 1.2345e-10 For bandwidth less than 1
* 6.7893e+94 For exceptionally large values
* 6.678e+106 For really big values
*
* Return: void
*
* Programmer: Robb Matzke
* Wednesday, August 5, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
void
H5_bandwidth(char *buf/*out*/, double nbytes, double nseconds)
{
double bw;
if (nseconds<=0.0) {
HDstrcpy(buf, " NaN");
} else {
bw = nbytes/nseconds;
if (fabs(bw) < 0.0000000001) {
/* That is == 0.0, but direct comparison between floats is bad */
HDstrcpy(buf, "0.000 B/s");
} else if (bw<1.0) {
sprintf(buf, "%10.4e", bw);
} else if (bw<1024.0) {
sprintf(buf, "%05.4f", bw);
HDstrcpy(buf+5, " B/s");
} else if (bw<1024.0*1024.0) {
sprintf(buf, "%05.4f", bw/1024.0);
HDstrcpy(buf+5, " kB/s");
} else if (bw<1024.0*1024.0*1024.0) {
sprintf(buf, "%05.4f", bw/(1024.0*1024.0));
HDstrcpy(buf+5, " MB/s");
} else if (bw<1024.0*1024.0*1024.0*1024.0) {
sprintf(buf, "%05.4f",
bw/(1024.0*1024.0*1024.0));
HDstrcpy(buf+5, " GB/s");
} else if (bw<1024.0*1024.0*1024.0*1024.0*1024.0) {
sprintf(buf, "%05.4f",
bw/(1024.0*1024.0*1024.0*1024.0));
HDstrcpy(buf+5, " TB/s");
} else {
sprintf(buf, "%10.4e", bw);
if (HDstrlen(buf)>10) {
sprintf(buf, "%10.3e", bw);
}
}
}
} /* end H5_bandwidth() */

1868
src/H5trace.c Normal file
View File

File diff suppressed because it is too large Load Diff

3
src/Makefile.am
View File

@ -40,7 +40,8 @@ MOSTLYCLEANFILES=H5Tinit.c
DISTCLEANFILES=H5pubconf.h
# library sources
libhdf5_la_SOURCES= H5.c H5dbg.c H5A.c H5AC.c H5B.c H5Bcache.c \
libhdf5_la_SOURCES= H5.c H5checksum.c H5dbg.c H5system.c H5timer.c H5trace.c \
H5A.c H5AC.c H5B.c H5Bcache.c \
H5B2.c H5B2cache.c H5B2dbg.c H5B2int.c H5B2stat.c H5B2test.c \
H5C.c H5CS.c H5D.c H5Dcompact.c H5Dcontig.c \
H5Defl.c H5Dio.c H5Distore.c H5Dmpio.c H5Doh.c H5Dselect.c H5Dtest.c \

8
src/Makefile.in
View File

@ -82,7 +82,7 @@ am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(settingsdir)" \
libLTLIBRARIES_INSTALL = $(INSTALL)
LTLIBRARIES = $(lib_LTLIBRARIES)
libhdf5_la_LIBADD =
am_libhdf5_la_OBJECTS = H5.lo H5dbg.lo H5A.lo H5AC.lo H5B.lo \
am_libhdf5_la_OBJECTS = H5.lo H5checksum.lo H5dbg.lo H5system.lo H5timer.lo H5trace.lo H5A.lo H5AC.lo H5B.lo \
H5Bcache.lo H5B2.lo H5B2cache.lo H5B2dbg.lo H5B2int.lo \
H5B2stat.lo H5B2test.lo H5C.lo H5CS.lo H5D.lo H5Dcompact.lo \
H5Dcontig.lo H5Defl.lo H5Dio.lo H5Distore.lo H5Dmpio.lo \
@ -389,7 +389,7 @@ MOSTLYCLEANFILES = H5Tinit.c
DISTCLEANFILES = H5pubconf.h
# library sources
libhdf5_la_SOURCES = H5.c H5dbg.c H5A.c H5AC.c H5B.c H5Bcache.c \
libhdf5_la_SOURCES = H5.c H5checksum.c H5dbg.c H5system.c H5timer.c H5trace.c H5A.c H5AC.c H5B.c H5Bcache.c \
H5B2.c H5B2cache.c H5B2dbg.c H5B2int.c H5B2stat.c H5B2test.c \
H5C.c H5CS.c H5D.c H5Dcompact.c H5Dcontig.c \
H5Defl.c H5Dio.c H5Distore.c H5Dmpio.c H5Doh.c H5Dselect.c H5Dtest.c \
@ -552,6 +552,10 @@ distclean-compile:
-rm -f *.tab.c
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5checksum.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5system.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5timer.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5trace.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5A.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5AC.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5B.Plo@am__quote@

7
test/Makefile.am
View File

@ -115,8 +115,9 @@ CHECK_CLEANFILES+=cmpd_dset.h5 compact_dataset.h5 dataset.h5 extend.h5 istore.h5
objcopy_src.h5 objcopy_dst.h5 objcopy_ext.dat
# Sources for testhdf5 executable
testhdf5_SOURCES=testhdf5.c tarray.c tattr.c tconfig.c tfile.c tgenprop.c \
th5o.c th5s.c theap.c tid.c titerate.c tmeta.c tmisc.c ttime.c trefer.c trefstr.c \
tselect.c tskiplist.c ttst.c tunicode.c tvltypes.c tvlstr.c
testhdf5_SOURCES=testhdf5.c tarray.c tattr.c tchecksum.c tconfig.c tfile.c \
tgenprop.c th5o.c th5s.c theap.c tid.c titerate.c tmeta.c tmisc.c ttime.c \
trefer.c trefstr.c tselect.c tskiplist.c ttst.c tunicode.c tvltypes.c \
tvlstr.c
include $(top_srcdir)/config/conclude.am

5
test/Makefile.in
View File

@ -290,7 +290,7 @@ stream_test_OBJECTS = stream_test.$(OBJEXT)
stream_test_LDADD = $(LDADD)
stream_test_DEPENDENCIES = libh5test.la $(am__DEPENDENCIES_1)
am_testhdf5_OBJECTS = testhdf5.$(OBJEXT) tarray.$(OBJEXT) \
tattr.$(OBJEXT) tconfig.$(OBJEXT) tfile.$(OBJEXT) \
tattr.$(OBJEXT) tchecksum.$(OBJEXT) tconfig.$(OBJEXT) tfile.$(OBJEXT) \
tgenprop.$(OBJEXT) th5o.$(OBJEXT) th5s.$(OBJEXT) \
theap.$(OBJEXT) tid.$(OBJEXT) titerate.$(OBJEXT) \
tmeta.$(OBJEXT) tmisc.$(OBJEXT) ttime.$(OBJEXT) \
@ -657,7 +657,7 @@ ttsafe_SOURCES = ttsafe.c ttsafe_dcreate.c ttsafe_error.c ttsafe_cancel.c
VFD_LIST = sec2 stdio core split multi family
# Sources for testhdf5 executable
testhdf5_SOURCES = testhdf5.c tarray.c tattr.c tconfig.c tfile.c tgenprop.c \
testhdf5_SOURCES = testhdf5.c tarray.c tattr.c tchecksum.c tconfig.c tfile.c tgenprop.c \
th5o.c th5s.c theap.c tid.c titerate.c tmeta.c tmisc.c ttime.c trefer.c trefstr.c \
tselect.c tskiplist.c ttst.c tunicode.c tvltypes.c tvlstr.c
@ -958,6 +958,7 @@ distclean-compile:
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/stream_test.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/tarray.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/tattr.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/tchecksum.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/tconfig.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/testframe.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/testhdf5.Po@am__quote@

194
test/tchecksum.c Normal file
View File

@ -0,0 +1,194 @@
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Copyright by the Board of Trustees of the University of Illinois. *
* All rights reserved. *
* *
* This file is part of HDF5. The full HDF5 copyright notice, including *
* terms governing use, modification, and redistribution, is contained in *
* the files COPYING and Copyright.html. COPYING can be found at the root *
* of the source code distribution tree; Copyright.html can be found at the *
* root level of an installed copy of the electronic HDF5 document set and *
* is linked from the top-level documents page. It can also be found at *
* http://hdf.ncsa.uiuc.edu/HDF5/doc/Copyright.html. If you do not have *
* access to either file, you may request a copy from hdfhelp@ncsa.uiuc.edu. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*-------------------------------------------------------------------------
*
* Created: tchecksum.c
* Aug 21 2006
* Quincey Koziol <koziol@hdfgroup.org>
*
* Purpose: Test internal checksum routine(s)
*
*-------------------------------------------------------------------------
*/
/***********/
/* Headers */
/***********/
#include "testhdf5.h"
/**********/
/* Macros */
/**********/
#define BUF_LEN 3093 /* No particular value */
/*******************/
/* Local variables */
/*******************/
uint8_t large_buf[BUF_LEN];
/****************************************************************
**
** test_chksum_size_one(): Checksum 1 byte buffer
**
****************************************************************/
static void
test_chksum_size_one(void)
{
uint8_t buf[1] = {23}; /* Buffer to checksum */
uint32_t chksum; /* Checksum value */
/* Buffer w/real data */
chksum = H5_fletcher32(buf, sizeof(buf));
VERIFY(chksum, 0x17001700, "H5_fletcher32");
/* Buffer w/zero(s) for data */
HDmemset(buf, 0, sizeof(buf));
chksum = H5_fletcher32(buf, sizeof(buf));
VERIFY(chksum, 0xffffffff, "H5_fletcher32");
} /* test_chksum_size_one() */
/****************************************************************
**
** test_chksum_size_two(): Checksum 2 byte buffer
**
****************************************************************/
static void
test_chksum_size_two(void)
{
uint8_t buf[2] = {23, 187}; /* Buffer to checksum */
uint32_t chksum; /* Checksum value */
/* Buffer w/real data */
chksum = H5_fletcher32(buf, sizeof(buf));
VERIFY(chksum, 0x17bb17bb, "H5_fletcher32");
/* Buffer w/zero(s) for data */
HDmemset(buf, 0, sizeof(buf));
chksum = H5_fletcher32(buf, sizeof(buf));
VERIFY(chksum, 0xffffffff, "H5_fletcher32");
} /* test_chksum_size_two() */
/****************************************************************
**
** test_chksum_size_three(): Checksum 3 byte buffer
**
****************************************************************/
static void
test_chksum_size_three(void)
{
uint8_t buf[3] = {23, 187, 98}; /* Buffer to checksum */
uint32_t chksum; /* Checksum value */
/* Buffer w/real data */
chksum = H5_fletcher32(buf, sizeof(buf));
VERIFY(chksum, 0x917679bb, "H5_fletcher32");
/* Buffer w/zero(s) for data */
HDmemset(buf, 0, sizeof(buf));
chksum = H5_fletcher32(buf, sizeof(buf));
VERIFY(chksum, 0xffffffff, "H5_fletcher32");
} /* test_chksum_size_three() */
/****************************************************************
**
** test_chksum_size_four(): Checksum 4 byte buffer
**
****************************************************************/
static void
test_chksum_size_four(void)
{
uint8_t buf[4] = {23, 187, 98, 217};/* Buffer to checksum */
uint32_t chksum; /* Checksum value */
/* Buffer w/real data */
chksum = H5_fletcher32(buf, sizeof(buf));
VERIFY(chksum, 0x924f7a94, "H5_fletcher32");
/* Buffer w/zero(s) for data */
HDmemset(buf, 0, sizeof(buf));
chksum = H5_fletcher32(buf, sizeof(buf));
VERIFY(chksum, 0xffffffff, "H5_fletcher32");
} /* test_chksum_size_four() */
/****************************************************************
**
** test_chksum_large(): Checksum larger buffer
**
****************************************************************/
static void
test_chksum_large(void)
{
uint32_t chksum; /* Checksum value */
size_t u; /* Local index variable */
/* Initialize buffer w/known data */
for(u = 0; u < BUF_LEN; u++)
large_buf[u] = u * 3;
/* Buffer w/real data */
chksum = H5_fletcher32(large_buf, sizeof(large_buf));
VERIFY(chksum, 0x85b4e2a, "H5_fletcher32");
/* Buffer w/zero(s) for data */
HDmemset(large_buf, 0, sizeof(large_buf));
chksum = H5_fletcher32(large_buf, sizeof(large_buf));
VERIFY(chksum, 0xffffffff, "H5_fletcher32");
} /* test_chksum_large() */
/****************************************************************
**
** test_checksum(): Main checksum testing routine.
**
****************************************************************/
void
test_checksum(void)
{
/* Output message about test being performed */
MESSAGE(5, ("Testing checksum algorithm\n"));
/* Various checks for fletcher32 checksum algorithm */
test_chksum_size_one(); /* Test buffer w/only 1 byte */
test_chksum_size_two(); /* Test buffer w/only 2 bytes */
test_chksum_size_three(); /* Test buffer w/only 3 bytes */
test_chksum_size_four(); /* Test buffer w/only 4 bytes */
test_chksum_large(); /* Test buffer w/larger # of bytes */
} /* test_checksum() */
/*-------------------------------------------------------------------------
* Function: cleanup_checksum
*
* Purpose: Cleanup temporary test files
*
* Return: none
*
* Programmer: Quincey Koziol
* August 21, 2006
*
*-------------------------------------------------------------------------
*/
void
cleanup_checksum(void)
{
/* no file to clean */
}

3
test/testhdf5.c
View File

@ -44,7 +44,8 @@ main(int argc, char *argv[])
/* Tests are generally arranged from least to most complexity... */
AddTest("config", test_configure, cleanup_configure, "Configure definitions", NULL);
AddTest("metadata", test_metadata, cleanup_metadata, "Encode/decode metadata code", NULL);
AddTest("metadata", test_metadata, cleanup_metadata, "Encoding/decoding metadata", NULL);
AddTest("checksum", test_checksum, cleanup_checksum, "Checksum algorithm", NULL);
AddTest("tst", test_tst, NULL, "Ternary Search Trees", NULL);
AddTest("heap", test_heap, NULL, "Memory Heaps", NULL);
AddTest("skiplist", test_skiplist, NULL, "Skip Lists", NULL);

3
test/testhdf5.h
View File

@ -123,6 +123,7 @@ extern "C" {
/* Prototypes for the test routines */
void test_metadata(void);
void test_checksum(void);
void test_tst(void);
void test_heap(void);
void test_refstr(void);
@ -148,6 +149,7 @@ void test_unicode(void);
/* Prototypes for the cleanup routines */
void cleanup_metadata(void);
void cleanup_checksum(void);
void cleanup_file(void);
void cleanup_h5o(void);
void cleanup_h5s(void);
@ -168,3 +170,4 @@ void cleanup_unicode(void);
}
#endif
#endif /* TESTHDF5_H */

4
test/tmeta.c
View File

@ -21,8 +21,6 @@
*************************************************************/
#include "testhdf5.h"
#include "H5private.h"
#include "H5Fprivate.h"
#define TEST_INT16_VALUE -7641
@ -65,7 +63,7 @@ test_metadata(void)
uint8_t *p; /* pointer into the buffer being en/de-coded */
/* Output message about test being performed */
MESSAGE(5, ("Testing Metadata encode/decode code\n"));
MESSAGE(5, ("Testing Metadata Encoding/decoding\n"));
/* Start by encoding the values above */
p = encode_buffer;