mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2025-03-31 17:10:47 +08:00
Code Issues Packages Projects Releases Wiki Activity

[svn-r16041] Description:

Browse Source 
Minor cleanups of new testing code.

Tested on:
        Mac OS X/32 10.5.5 (amazon) in debug mode
        Mac OS X/32 10.5.5 (amazon) w/C++ & FORTRAN, w/threadsafe,
                                in production mode
        FreeBSD/32 6.3 (duty) in debug mode
        FreeBSD/64 6.3 (liberty) w/C++ & FORTRAN, in debug mode
        Linux/32 2.6 (jam) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
                                in debug mode
        Linux/64-amd64 2.6 (smirom) w/Intel compilers w/default API=1.6.x,
                                w/C++ & FORTRAN, in production mode
        Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
                                w/szip filter, in production mode
        Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
                                in production mode
        Linux/64-ia64 2.4 (tg-login3) w/parallel, w/FORTRAN, in production mode
        Linux/64-amd64 2.6 (abe) w/parallel, w/FORTRAN, in production mode
This commit is contained in:
Quincey Koziol 2008-11-06 21:57:17 -05:00
parent 9fe6b65c9f
commit ad751bdce8
1 changed files with 78 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

131
test/earray.c
View File

@ -100,7 +100,8 @@ typedef struct earray_test_param_t earray_test_param_t;
/* Extensible array iterator class */
typedef struct earray_iter_t {
void *(*init)(hsize_t cnt); /* Initialize/allocate iterator private info */
void *(*init)(const H5EA_create_t *cparam, const earray_test_param_t *tparam,
hsize_t cnt); /* Initialize/allocate iterator private info */
hssize_t (*next)(void *info); /* Get the next element to test */
hssize_t (*max)(const void *info); /* Get the max. element set */
int (*state)(void *_eiter, const H5EA_create_t *cparam,
@ -999,12 +1000,13 @@ typedef struct eiter_fw_t {
*-------------------------------------------------------------------------
*/
static void *
eiter_fw_init(hsize_t UNUSED cnt)
eiter_fw_init(const H5EA_create_t UNUSED *cparam, const earray_test_param_t UNUSED *tparam,
hsize_t UNUSED cnt)
{
eiter_fw_t *eiter; /* Forward element iteration object */
/* Allocate space for the element iteration object */
eiter = HDmalloc(sizeof(eiter_fw_t));
eiter = (eiter_fw_t *)HDmalloc(sizeof(eiter_fw_t));
HDassert(eiter);
/* Initialize the element iteration object */
@ -1039,7 +1041,7 @@ eiter_fw_next(void *_eiter)
HDassert(eiter);
/* Get the next array index to test */
ret_val = eiter->idx++;
ret_val = (hssize_t)eiter->idx++;
return(ret_val);
} /* end eiter_fw_next() */
@ -1067,7 +1069,7 @@ eiter_fw_max(const void *_eiter)
HDassert(eiter);
/* Return the max. array index used */
return((hsize_t)(eiter->idx - 1));
return((hssize_t)(eiter->idx - 1));
} /* end eiter_fw_max() */
@ -1096,13 +1098,12 @@ eiter_fw_state(void *_eiter, const H5EA_create_t *cparam,
HDassert(tparam);
HDassert(state);
/* Reset the state */
HDmemset(state, 0, sizeof(*state));
/* Compute the state of the extensible array */
state->max_idx_set = idx + 1;
if(idx < cparam->idx_blk_elmts)
if(idx < cparam->idx_blk_elmts) {
state->nelmts = (hsize_t)cparam->idx_blk_elmts;
state->nsuper_blks = state->ndata_blks = (hsize_t)0;
} /* end if */
else {
unsigned sblk_idx; /* Which superblock does this index fall in? */
@ -1134,6 +1135,8 @@ HDfprintf(stderr, "state->ndata_blks = %Hu\n", state->ndata_blks);
HDfprintf(stderr, "state->nsuper_blks = %Hu\n", state->nsuper_blks);
#endif /* QAK */
} /* end if */
else
state->nsuper_blks = 0;
} /* end else */
return(0);
@ -1178,6 +1181,10 @@ static const earray_iter_t ea_iter_fw = {
typedef struct eiter_rv_t {
hsize_t idx; /* Index of next array location */
hsize_t max; /* Index of max. array location */
hsize_t max_sblk_idx; /* Which superblock does the max. array location fall in? */
hsize_t max_nelmts; /* Max. # of elements for array */
hsize_t max_ndata_blks; /* Max. # of data blocks for array */
hsize_t idx_blk_nsblks; /* Number of superblocks directly pointed to in the index block */
} eiter_rv_t;
@ -1195,17 +1202,30 @@ typedef struct eiter_rv_t {
*-------------------------------------------------------------------------
*/
static void *
eiter_rv_init(hsize_t cnt)
eiter_rv_init(const H5EA_create_t *cparam, const earray_test_param_t *tparam,
hsize_t cnt)
{
eiter_rv_t *eiter; /* Reverse element iteration object */
/* Allocate space for the element iteration object */
eiter = HDmalloc(sizeof(eiter_rv_t));
eiter = (eiter_rv_t *)HDmalloc(sizeof(eiter_rv_t));
HDassert(eiter);
/* Initialize reverse iteration info */
eiter->idx = cnt - 1;
eiter->max = cnt - 1;
if(cnt > cparam->idx_blk_elmts) {
eiter->max_sblk_idx = H5V_log2_gen((uint64_t)(((eiter->max - cparam->idx_blk_elmts) / cparam->data_blk_min_elmts) + 1));
eiter->max_nelmts = EA_NELMTS(cparam, tparam, eiter->max, eiter->max_sblk_idx);
eiter->max_ndata_blks = EA_NDATA_BLKS(cparam, tparam, eiter->max, eiter->max_sblk_idx);
eiter->idx_blk_nsblks = 2 * H5V_log2_of2((uint32_t)cparam->sup_blk_min_data_ptrs);
} /* end if */
else {
eiter->max_sblk_idx = (hsize_t)0;
eiter->max_nelmts = (hsize_t)0;
eiter->max_ndata_blks = (hsize_t)0;
eiter->idx_blk_nsblks = (hsize_t)0;
} /* end else */
/* Return iteration object */
return(eiter);
@ -1235,7 +1255,7 @@ eiter_rv_next(void *_eiter)
HDassert(eiter);
/* Get the next array index to test */
ret_val = eiter->idx--;
ret_val = (hssize_t)eiter->idx--;
return(ret_val);
} /* end eiter_rv_next() */
@ -1292,77 +1312,68 @@ eiter_rv_state(void *_eiter, const H5EA_create_t *cparam,
HDassert(tparam);
HDassert(state);
/* Reset the state */
HDmemset(state, 0, sizeof(*state));
/* Compute the state of the extensible array */
state->max_idx_set = eiter->max + 1;
if(eiter->max < cparam->idx_blk_elmts)
if(eiter->max < cparam->idx_blk_elmts) {
state->nelmts = (hsize_t)cparam->idx_blk_elmts;
state->nsuper_blks = state->ndata_blks = (hsize_t)0;
} /* end if */
else {
hsize_t max_nelmts; /* Max. # of elements for array */
hsize_t idx_nelmts; /* # of elements for array index */
hsize_t max_ndata_blks; /* Max. # of data blocks for array */
hsize_t idx_ndata_blks; /* # of data blocks for array index */
hsize_t tmp_idx;
unsigned max_sblk_idx; /* Which superblock does the max. index fall in? */
hsize_t loc_idx = 0; /* Local index, for computing an offset in next lower data block */
unsigned idx_sblk_idx; /* Which superblock does this index fall in? */
unsigned tmp_sblk_idx; /* Which superblock does this index fall in? */
unsigned loc_sblk_idx = 0; /* Which superblock does the local index fall in? */
/* Compute super block index for element index */
/* (same eqn. as in H5EA__dblock_sblk_idx()) */
max_sblk_idx = H5V_log2_gen((uint64_t)(((eiter->max - cparam->idx_blk_elmts) / cparam->data_blk_min_elmts) + 1));
if(idx < cparam->idx_blk_elmts + cparam->data_blk_min_elmts)
idx_sblk_idx = 0;
else {
hsize_t loc_idx;
hsize_t dblk_idx;
hsize_t tmp_idx; /* Temporary index in superblock */
hsize_t dblk_idx; /* Index of data block within superblock */
idx_sblk_idx = H5V_log2_gen((uint64_t)(((idx - cparam->idx_blk_elmts) / cparam->data_blk_min_elmts) + 1));
loc_idx = idx - (cparam->idx_blk_elmts + tparam->sblk_info[idx_sblk_idx].start_idx);
dblk_idx = loc_idx / tparam->sblk_info[idx_sblk_idx].dblk_nelmts;
tmp_idx = idx - (cparam->idx_blk_elmts + tparam->sblk_info[idx_sblk_idx].start_idx);
dblk_idx = tmp_idx / tparam->sblk_info[idx_sblk_idx].dblk_nelmts;
if(dblk_idx > 0)
tmp_idx = idx - tparam->sblk_info[idx_sblk_idx].dblk_nelmts;
loc_idx = idx - tparam->sblk_info[idx_sblk_idx].dblk_nelmts;
else
tmp_idx = cparam->idx_blk_elmts + tparam->sblk_info[idx_sblk_idx].start_idx - 1;
tmp_sblk_idx = H5V_log2_gen((uint64_t)(((tmp_idx - cparam->idx_blk_elmts) / cparam->data_blk_min_elmts) + 1));
loc_idx = cparam->idx_blk_elmts + tparam->sblk_info[idx_sblk_idx].start_idx - 1;
loc_sblk_idx = H5V_log2_gen((uint64_t)(((loc_idx - cparam->idx_blk_elmts) / cparam->data_blk_min_elmts) + 1));
} /* end else */
#ifdef QAK
HDfprintf(stderr, "idx = %Hu, tmp_idx = %Hu, max_sblk_idx = %u, idx_sblk_idx = %u, tmp_sblk_idx = %u\n", idx, tmp_idx, max_sblk_idx, idx_sblk_idx, tmp_sblk_idx);
HDfprintf(stderr, "idx = %Hu, loc_idx = %Hu, eiter->max_sblk_idx = %u, idx_sblk_idx = %u, loc_sblk_idx = %u\n", idx, loc_idx, eiter->max_sblk_idx, idx_sblk_idx, loc_sblk_idx);
HDfprintf(stderr, "tparam->sblk_info[%u] = {%Zu, %Zu, %Hu, %Hu}\n", idx_sblk_idx, tparam->sblk_info[idx_sblk_idx].ndblks, tparam->sblk_info[idx_sblk_idx].dblk_nelmts, tparam->sblk_info[idx_sblk_idx].start_idx, tparam->sblk_info[idx_sblk_idx].start_dblk);
HDfprintf(stderr, "tparam->sblk_info[%u] = {%Zu, %Zu, %Hu, %Hu}\n", max_sblk_idx, tparam->sblk_info[max_sblk_idx].ndblks, tparam->sblk_info[max_sblk_idx].dblk_nelmts, tparam->sblk_info[max_sblk_idx].start_idx, tparam->sblk_info[max_sblk_idx].start_dblk);
HDfprintf(stderr, "tparam->sblk_info[%u] = {%Zu, %Zu, %Hu, %Hu}\n", eiter->max_sblk_idx, tparam->sblk_info[eiter->max_sblk_idx].ndblks, tparam->sblk_info[eiter->max_sblk_idx].dblk_nelmts, tparam->sblk_info[eiter->max_sblk_idx].start_idx, tparam->sblk_info[eiter->max_sblk_idx].start_dblk);
#endif /* QAK */
max_nelmts = EA_NELMTS(cparam, tparam, eiter->max, max_sblk_idx);
if(idx < cparam->idx_blk_elmts + cparam->data_blk_min_elmts)
idx_nelmts = (hsize_t)cparam->idx_blk_elmts;
else
idx_nelmts = EA_NELMTS(cparam, tparam, tmp_idx, tmp_sblk_idx);
state->nelmts = (max_nelmts - idx_nelmts) + cparam->idx_blk_elmts;
idx_nelmts = EA_NELMTS(cparam, tparam, loc_idx, loc_sblk_idx);
state->nelmts = (eiter->max_nelmts - idx_nelmts) + cparam->idx_blk_elmts;
#ifdef QAK
HDfprintf(stderr, "max_nelmts = %Hu, idx_nelmts = %Hu, state->nelmts = %Hu\n", max_nelmts, idx_nelmts, state->nelmts);
HDfprintf(stderr, "eiter->max_nelmts = %Hu, idx_nelmts = %Hu, state->nelmts = %Hu\n", eiter->max_nelmts, idx_nelmts, state->nelmts);
#endif /* QAK */
max_ndata_blks = EA_NDATA_BLKS(cparam, tparam, eiter->max, max_sblk_idx);
if(idx < cparam->idx_blk_elmts + cparam->data_blk_min_elmts)
idx_ndata_blks = 0;
else
idx_ndata_blks = EA_NDATA_BLKS(cparam, tparam, tmp_idx, tmp_sblk_idx);
state->ndata_blks = max_ndata_blks - idx_ndata_blks;
idx_ndata_blks = EA_NDATA_BLKS(cparam, tparam, loc_idx, loc_sblk_idx);
state->ndata_blks = eiter->max_ndata_blks - idx_ndata_blks;
#ifdef QAK
HDfprintf(stderr, "max_ndata_blks = %Hu, idx_ndata_blks = %Hu, state->ndata_blks = %Hu\n", max_ndata_blks, idx_ndata_blks, state->ndata_blks);
HDfprintf(stderr, "eiter->max_ndata_blks = %Hu, idx_ndata_blks = %Hu, state->ndata_blks = %Hu\n", eiter->max_ndata_blks, idx_ndata_blks, state->ndata_blks);
#endif /* QAK */
/* Check if we have any super blocks yet */
if(tparam->sblk_info[max_sblk_idx].ndblks >= cparam->sup_blk_min_data_ptrs) {
hsize_t idx_blk_nsblks = 2 * H5V_log2_of2((uint32_t)cparam->sup_blk_min_data_ptrs);
if(idx_sblk_idx > idx_blk_nsblks)
state->nsuper_blks = (max_sblk_idx - idx_sblk_idx) + 1;
if(tparam->sblk_info[eiter->max_sblk_idx].ndblks >= cparam->sup_blk_min_data_ptrs) {
if(idx_sblk_idx > eiter->idx_blk_nsblks)
state->nsuper_blks = (eiter->max_sblk_idx - idx_sblk_idx) + 1;
else
state->nsuper_blks = (max_sblk_idx - idx_blk_nsblks) + 1;
state->nsuper_blks = (eiter->max_sblk_idx - eiter->idx_blk_nsblks) + 1;
#ifdef QAK
HDfprintf(stderr, "idx_blk_nsblks = %Hu, state->nsuper_blks = %Hu\n", idx_blk_nsblks, state->nsuper_blks);
HDfprintf(stderr, "eiter->idx_blk_nsblks = %Hu, state->nsuper_blks = %Hu\n", eiter->idx_blk_nsblks, state->nsuper_blks);
#endif /* QAK */
} /* end if */
} /* end else */
@ -1471,9 +1482,19 @@ test_set_elmts(hid_t fapl, H5EA_create_t *cparam, earray_test_param_t *tparam,
if(check_stats(ea, &state))
TEST_ERROR
#ifdef OLD_WAY
/* Retrieve elements of array in data block (not set yet) */
for(idx = 0; idx < nelmts; idx++) {
/* Get all elements from empty array */
/* Initialize iterator */
if(NULL == (eiter_info = tparam->eiter->init(cparam, tparam, nelmts)))
TEST_ERROR
/* Get elements of array */
for(cnt = 0; cnt < nelmts; cnt++) {
/* Get the array index */
if((sidx = tparam->eiter->next(eiter_info)) < 0)
TEST_ERROR
idx = (hsize_t)sidx;
/* Retrieve element of array (not set yet) */
relmt = (uint64_t)0;
if(H5EA_get(ea, H5P_DATASET_XFER_DEFAULT, idx, &relmt) < 0)
@ -1483,10 +1504,16 @@ test_set_elmts(hid_t fapl, H5EA_create_t *cparam, earray_test_param_t *tparam,
if(relmt != H5EA_TEST_FILL)
TEST_ERROR
} /* end for */
#endif /* OLD_WAY */
/* Shutdown iterator */
if(tparam->eiter->term(eiter_info) < 0)
TEST_ERROR
/* Set (& get) all elements from empty array */
/* Initialize iterator */
if(NULL == (eiter_info = tparam->eiter->init(nelmts)))
if(NULL == (eiter_info = tparam->eiter->init(cparam, tparam, nelmts)))
TEST_ERROR
/* Set elements of array */
@ -1566,7 +1593,6 @@ error:
return 1;
} /* test_set_elmts() */
/*-------------------------------------------------------------------------
* Function: main
@ -1677,7 +1703,6 @@ main(void)
} /* end switch */
/* Basic capacity tests */
/* Need separate test to read elements from empty array */
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)1, "setting first element of array");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)cparam.idx_blk_elmts, "setting index block elements of array");
/* Super block #0 ("virtual" super block, in index block) */