From 0d4ed0eb9a43e5bb471dad1be08f83ae703821d1 Mon Sep 17 00:00:00 2001 From: Dana Robinson Date: Mon, 22 Mar 2021 11:45:32 -0700 Subject: Brings accum.c changes from develop --- test/accum.c | 1708 ++++++++++++++++++++++++++++++++++------------------------ 1 file changed, 1008 insertions(+), 700 deletions(-) diff --git a/test/accum.c b/test/accum.c index 548a04d..f3e19f0 100644 --- a/test/accum.c +++ b/test/accum.c @@ -10,28 +10,24 @@ * help@hdfgroup.org. * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -/* Programmer: Mike McGreevy - * October 7, 2010 - */ + /* Programmer: Mike McGreevy + * October 7, 2010 + */ #include "h5test.h" -#define H5F_FRIEND /*suppress error about including H5Fpkg */ -#define H5FD_FRIEND /*suppress error about including H5FDpkg */ +#define H5F_FRIEND /*suppress error about including H5Fpkg */ +#define H5FD_FRIEND /*suppress error about including H5FDpkg */ #define H5FD_TESTING #include "H5Fpkg.h" #include "H5FDpkg.h" -#include "H5CXprivate.h" /* API Contexts */ +#include "H5CXprivate.h" /* API Contexts */ #include "H5Iprivate.h" -#include "H5VLprivate.h" /* Virtual Object Layer */ +#include "H5VLprivate.h" /* Virtual Object Layer */ -/* Filename */ -/* (The file names are the same as the define in accum_swmr_reader.c) */ -const char *FILENAME[] = { - "accum", - "accum_swmr_big", - NULL -}; + /* Filename */ + /* (The file names are the same as the define in accum_swmr_reader.c) */ +const char* FILENAME[] = { "accum", "accum_swmr_big", NULL }; /* The reader forked by test_swmr_write_big() */ #define SWMR_READER "accum_swmr_reader" @@ -40,41 +36,40 @@ const char *FILENAME[] = { #define BIG_BUF_SIZE (6 * 1024 * 1024) /* Random I/O test values */ -#define RANDOM_BUF_SIZE (1 * 1024 * 1024) +#define RANDOM_BUF_SIZE (1 * 1024 * 1024) #define MAX_RANDOM_SEGMENTS (5 * 1024) -#define RAND_SEG_LEN (1024) -#define RANDOM_BASE_OFF (1024 * 1024) +#define RAND_SEG_LEN (1024) +#define RANDOM_BASE_OFF (1024 * 1024) /* Function Prototypes */ -unsigned test_write_read(H5F_t *f); -unsigned test_write_read_nonacc_front(H5F_t *f); -unsigned test_write_read_nonacc_end(H5F_t *f); -unsigned test_accum_overlap(H5F_t *f); -unsigned test_accum_overlap_clean(H5F_t *f); -unsigned test_accum_overlap_size(H5F_t *f); -unsigned test_accum_non_overlap_size(H5F_t *f); -unsigned test_accum_adjust(H5F_t *f); -unsigned test_read_after(H5F_t *f); -unsigned test_free(H5F_t *f); -unsigned test_big(H5F_t *f); -unsigned test_random_write(H5F_t *f); +unsigned test_write_read(H5F_t* f); +unsigned test_write_read_nonacc_front(H5F_t* f); +unsigned test_write_read_nonacc_end(H5F_t* f); +unsigned test_accum_overlap(H5F_t* f); +unsigned test_accum_overlap_clean(H5F_t* f); +unsigned test_accum_overlap_size(H5F_t* f); +unsigned test_accum_non_overlap_size(H5F_t* f); +unsigned test_accum_adjust(H5F_t* f); +unsigned test_read_after(H5F_t* f); +unsigned test_free(H5F_t* f); +unsigned test_big(H5F_t* f); +unsigned test_random_write(H5F_t* f); unsigned test_swmr_write_big(hbool_t newest_format); /* Helper Function Prototypes */ -void accum_printf(const H5F_t *f); +void accum_printf(const H5F_t* f); /* Private Test H5Faccum Function Wrappers */ -#define accum_write(a,s,b) H5F_block_write(f, H5FD_MEM_DEFAULT, (haddr_t)(a), (size_t)(s), (b)) -#define accum_read(a,s,b) H5F_block_read(f, H5FD_MEM_DEFAULT, (haddr_t)(a), (size_t)(s), (b)) -#define accum_free(f,a,s) H5F__accum_free(f->shared, H5FD_MEM_DEFAULT, (haddr_t)(a), (hsize_t)(s)) -#define accum_flush(f) H5F__accum_flush(f->shared) -#define accum_reset(f) H5F__accum_reset(f->shared, TRUE) +#define accum_write(a, s, b) H5F_block_write(f, H5FD_MEM_DEFAULT, (haddr_t)(a), (size_t)(s), (b)) +#define accum_read(a, s, b) H5F_block_read(f, H5FD_MEM_DEFAULT, (haddr_t)(a), (size_t)(s), (b)) +#define accum_free(f, a, s) H5F__accum_free(f->shared, H5FD_MEM_DEFAULT, (haddr_t)(a), (hsize_t)(s)) +#define accum_flush(f) H5F__accum_flush(f->shared) +#define accum_reset(f) H5F__accum_reset(f->shared, TRUE) /* ================= */ /* Main Test Routine */ /* ================= */ - /*------------------------------------------------------------------------- * Function: main * @@ -91,42 +86,46 @@ void accum_printf(const H5F_t *f); int main(void) { - unsigned nerrors = 0; /* track errors */ - hbool_t api_ctx_pushed = FALSE; /* Whether API context pushed */ - hid_t fid = -1; - hid_t fapl = -1; /* File access property list */ - char filename[1024]; - H5F_t * f = NULL; /* File for all tests */ - + unsigned nerrors = 0; /* track errors */ + hbool_t api_ctx_pushed = FALSE; /* Whether API context pushed */ + hid_t fid = -1; + hid_t fapl = -1; /* File access property list */ + char filename[1024]; + H5F_t* f = NULL; /* File for all tests */ /* Test Setup */ HDputs("Testing the metadata accumulator"); /* File access property list */ h5_reset(); - if((fapl = h5_fileaccess()) < 0) + if ((fapl = h5_fileaccess()) < 0) FAIL_STACK_ERROR - h5_fixname(FILENAME[0], fapl, filename, sizeof filename); + h5_fixname(FILENAME[0], fapl, filename, sizeof filename); /* Create a test file */ - if((fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0) FAIL_STACK_ERROR + if ((fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0) + FAIL_STACK_ERROR - /* Push API context */ - if(H5CX_push() < 0) FAIL_STACK_ERROR - api_ctx_pushed = TRUE; + /* Push API context */ + if (H5CX_push() < 0) + FAIL_STACK_ERROR + api_ctx_pushed = TRUE; /* Get H5F_t * to internal file structure */ - if(NULL == (f = (H5F_t *)H5VL_object(fid))) FAIL_STACK_ERROR + if (NULL == (f = (H5F_t*)H5VL_object(fid))) + FAIL_STACK_ERROR - /* We'll be writing lots of garbage data, so extend the - file a ways. 10MB should do. */ - if(H5FD_set_eoa(f->shared->lf, H5FD_MEM_DEFAULT, (haddr_t)(1024*1024*10)) < 0) FAIL_STACK_ERROR + /* We'll be writing lots of garbage data, so extend the + file a ways. 10MB should do. */ + if (H5FD_set_eoa(f->shared->lf, H5FD_MEM_DEFAULT, (haddr_t)(1024 * 1024 * 10)) < 0) + FAIL_STACK_ERROR - /* Reset metadata accumulator for the file */ - if(accum_reset(f) < 0) FAIL_STACK_ERROR + /* Reset metadata accumulator for the file */ + if (accum_reset(f) < 0) + FAIL_STACK_ERROR - /* Test Functions */ - nerrors += test_write_read(f); + /* Test Functions */ + nerrors += test_write_read(f); nerrors += test_write_read_nonacc_front(f); nerrors += test_write_read_nonacc_end(f); nerrors += test_accum_overlap(f); @@ -140,17 +139,19 @@ main(void) nerrors += test_random_write(f); /* Pop API context */ - if(api_ctx_pushed && H5CX_pop() < 0) FAIL_STACK_ERROR - api_ctx_pushed = FALSE; + if (api_ctx_pushed && H5CX_pop(FALSE) < 0) + FAIL_STACK_ERROR + api_ctx_pushed = FALSE; /* End of test code, close and delete file */ - if(H5Fclose(fid) < 0) TEST_ERROR + if (H5Fclose(fid) < 0) + TEST_ERROR - /* This test uses a different file */ - nerrors += test_swmr_write_big(TRUE); + /* This test uses a different file */ + nerrors += test_swmr_write_big(TRUE); nerrors += test_swmr_write_big(FALSE); - if(nerrors) + if (nerrors) goto error; HDputs("All metadata accumulator tests passed."); h5_cleanup(FILENAME, fapl); @@ -158,7 +159,8 @@ main(void) return 0; error: - if(api_ctx_pushed) H5CX_pop(); + if (api_ctx_pushed) + H5CX_pop(FALSE); HDputs("*** TESTS FAILED ***"); return 1; @@ -168,7 +170,6 @@ error: /* Individual Unit Test Routines */ /* ============================= */ - /*------------------------------------------------------------------------- * Function: test_write_read * @@ -183,30 +184,34 @@ error: *------------------------------------------------------------------------- */ unsigned -test_write_read(H5F_t *f) +test_write_read(H5F_t* f) { - int i = 0; - int *write_buf, *read_buf; + int i = 0; + int* write_buf, * read_buf; TESTING("simple write/read to/from metadata accumulator"); /* Allocate buffers */ - write_buf = (int *)HDmalloc(1024 * sizeof(int)); + write_buf = (int*)HDmalloc(1024 * sizeof(int)); HDassert(write_buf); - read_buf = (int *)HDcalloc((size_t)1024, sizeof(int)); + read_buf = (int*)HDcalloc((size_t)1024, sizeof(int)); HDassert(read_buf); /* Fill buffer with data, zero out read buffer */ - for(i = 0; i < 1024; i++) + for (i = 0; i < 1024; i++) write_buf[i] = i + 1; /* Do a simple write/read/verify of data */ /* Write 1KB at Address 0 */ - if(accum_write(0, 1024, write_buf) < 0) FAIL_STACK_ERROR; - if(accum_read(0, 1024, read_buf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(write_buf, read_buf, (size_t)1024) != 0) TEST_ERROR; + if (accum_write(0, 1024, write_buf) < 0) + FAIL_STACK_ERROR; + if (accum_read(0, 1024, read_buf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(write_buf, read_buf, (size_t)1024) != 0) + TEST_ERROR; - if(accum_reset(f) < 0) FAIL_STACK_ERROR; + if (accum_reset(f) < 0) + FAIL_STACK_ERROR; PASSED(); @@ -224,7 +229,6 @@ error: return 1; } /* test_write_read */ - /*------------------------------------------------------------------------- * Function: test_write_read_nonacc_front * @@ -239,33 +243,40 @@ error: *------------------------------------------------------------------------- */ unsigned -test_write_read_nonacc_front(H5F_t *f) +test_write_read_nonacc_front(H5F_t* f) { - int i = 0; - int *write_buf, *read_buf; + int i = 0; + int* write_buf, * read_buf; TESTING("simple write/read to/from before metadata accumulator"); /* Allocate buffers */ - write_buf = (int *)HDmalloc(2048 * sizeof(int)); + write_buf = (int*)HDmalloc(2048 * sizeof(int)); HDassert(write_buf); - read_buf = (int *)HDcalloc((size_t)2048, sizeof(int)); + read_buf = (int*)HDcalloc((size_t)2048, sizeof(int)); HDassert(read_buf); /* Fill buffer with data, zero out read buffer */ - for(i = 0; i < 2048; i++) + for (i = 0; i < 2048; i++) write_buf[i] = i + 1; /* Do a simple write/read/verify of data */ /* Write 1KB at Address 0 */ - if(accum_write(0, 1024, write_buf) < 0) FAIL_STACK_ERROR; - if(accum_flush(f) < 0) FAIL_STACK_ERROR; - if(accum_reset(f) < 0) FAIL_STACK_ERROR; - if(accum_write(1024, 1024, write_buf) < 0) FAIL_STACK_ERROR; - if(accum_read(0, 1024, read_buf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(write_buf, read_buf, (size_t)1024) != 0) TEST_ERROR; + if (accum_write(0, 1024, write_buf) < 0) + FAIL_STACK_ERROR; + if (accum_flush(f) < 0) + FAIL_STACK_ERROR; + if (accum_reset(f) < 0) + FAIL_STACK_ERROR; + if (accum_write(1024, 1024, write_buf) < 0) + FAIL_STACK_ERROR; + if (accum_read(0, 1024, read_buf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(write_buf, read_buf, (size_t)1024) != 0) + TEST_ERROR; - if(accum_reset(f) < 0) FAIL_STACK_ERROR; + if (accum_reset(f) < 0) + FAIL_STACK_ERROR; PASSED(); @@ -283,7 +294,6 @@ error: return 1; } /* test_write_read */ - /*------------------------------------------------------------------------- * Function: test_write_read_nonacc_end * @@ -298,33 +308,40 @@ error: *------------------------------------------------------------------------- */ unsigned -test_write_read_nonacc_end(H5F_t *f) +test_write_read_nonacc_end(H5F_t* f) { - int i = 0; - int *write_buf, *read_buf; + int i = 0; + int* write_buf, * read_buf; TESTING("simple write/read to/from after metadata accumulator"); /* Allocate buffers */ - write_buf = (int *)HDmalloc(2048 * sizeof(int)); + write_buf = (int*)HDmalloc(2048 * sizeof(int)); HDassert(write_buf); - read_buf = (int *)HDcalloc((size_t)2048, sizeof(int)); + read_buf = (int*)HDcalloc((size_t)2048, sizeof(int)); HDassert(read_buf); /* Fill buffer with data, zero out read buffer */ - for(i = 0; i < 2048; i++) + for (i = 0; i < 2048; i++) write_buf[i] = i + 1; /* Do a simple write/read/verify of data */ /* Write 1KB at Address 0 */ - if(accum_write(1024, 1024, write_buf) < 0) FAIL_STACK_ERROR; - if(accum_flush(f) < 0) FAIL_STACK_ERROR; - if(accum_reset(f) < 0) FAIL_STACK_ERROR; - if(accum_write(0, 1024, write_buf) < 0) FAIL_STACK_ERROR; - if(accum_read(1024, 1024, read_buf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(write_buf, read_buf, (size_t)1024) != 0) TEST_ERROR; + if (accum_write(1024, 1024, write_buf) < 0) + FAIL_STACK_ERROR; + if (accum_flush(f) < 0) + FAIL_STACK_ERROR; + if (accum_reset(f) < 0) + FAIL_STACK_ERROR; + if (accum_write(0, 1024, write_buf) < 0) + FAIL_STACK_ERROR; + if (accum_read(1024, 1024, read_buf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(write_buf, read_buf, (size_t)1024) != 0) + TEST_ERROR; - if(accum_reset(f) < 0) FAIL_STACK_ERROR; + if (accum_reset(f) < 0) + FAIL_STACK_ERROR; PASSED(); @@ -342,7 +359,6 @@ error: return 1; } /* test_write_read */ - /*------------------------------------------------------------------------- * Function: test_free * @@ -357,151 +373,197 @@ error: *------------------------------------------------------------------------- */ unsigned -test_free(H5F_t *f) +test_free(H5F_t* f) { - int i = 0; - int32_t *wbuf = NULL; - int32_t *rbuf = NULL; - int32_t *expect = NULL; + int i = 0; + int32_t* wbuf = NULL; + int32_t* rbuf = NULL; + int32_t* expect = NULL; TESTING("simple freeing metadata accumulator"); /* Write and free the whole accumulator. */ - wbuf = (int32_t *)HDmalloc(256 * sizeof(int32_t)); + wbuf = (int32_t*)HDmalloc(256 * sizeof(int32_t)); HDassert(wbuf); - rbuf = (int32_t *)HDmalloc(256 * sizeof(int32_t)); + rbuf = (int32_t*)HDmalloc(256 * sizeof(int32_t)); HDassert(rbuf); - expect = (int32_t *)HDmalloc(256 * sizeof(int32_t)); + expect = (int32_t*)HDmalloc(256 * sizeof(int32_t)); HDassert(expect); /* Fill buffer with data */ - for(i = 0; i < 256; i++) + for (i = 0; i < 256; i++) wbuf[i] = (int32_t)(i + 1); - if(accum_write(0, 256 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(0, 256 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; - if(accum_free(f, 0, 256 * sizeof(int32_t)) < 0) FAIL_STACK_ERROR; + if (accum_free(f, 0, 256 * sizeof(int32_t)) < 0) + FAIL_STACK_ERROR; /* Free an empty accumulator */ - if(accum_free(f, 0, 256 * 1024 * sizeof(int32_t)) < 0) FAIL_STACK_ERROR; + if (accum_free(f, 0, 256 * 1024 * sizeof(int32_t)) < 0) + FAIL_STACK_ERROR; /* Write second quarter of the accumulator */ - if(accum_write(64 * sizeof(int32_t), 64 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(64 * sizeof(int32_t), 64 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; /* Free the second quarter of the accumulator, the requested area * is bigger than the data region on the right side. */ - if(accum_free(f, 64 * sizeof(int32_t), 65 * sizeof(int32_t)) < 0) FAIL_STACK_ERROR; - + if (accum_free(f, 64 * sizeof(int32_t), 65 * sizeof(int32_t)) < 0) + FAIL_STACK_ERROR; /* Write half of the accumulator. */ - if(accum_write(0, 128 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(0, 128 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; /* Free the first block of 4B */ - if(accum_free(f, 0, sizeof(int32_t)) < 0) FAIL_STACK_ERROR; + if (accum_free(f, 0, sizeof(int32_t)) < 0) + FAIL_STACK_ERROR; /* Check that the accumulator still contains the correct data */ - if(accum_read(1 * sizeof(int32_t), 127 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf + 1, rbuf, 127 * sizeof(int32_t)) != 0) TEST_ERROR; + if (accum_read(1 * sizeof(int32_t), 127 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf + 1, rbuf, 127 * sizeof(int32_t)) != 0) + TEST_ERROR; /* Free the block of 4B at 127*4B */ - if(accum_free(f, 127 * sizeof(int32_t), sizeof(int32_t)) < 0) FAIL_STACK_ERROR; + if (accum_free(f, 127 * sizeof(int32_t), sizeof(int32_t)) < 0) + FAIL_STACK_ERROR; /* Check that the accumulator still contains the correct data */ - if(accum_read(1 * sizeof(int32_t), 126 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf + 1, rbuf, 126 * sizeof(int32_t)) != 0) TEST_ERROR; + if (accum_read(1 * sizeof(int32_t), 126 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf + 1, rbuf, 126 * sizeof(int32_t)) != 0) + TEST_ERROR; /* Free the block of 4B at 2*4B */ - if(accum_free(f, 2 * sizeof(int32_t), sizeof(int32_t)) < 0) FAIL_STACK_ERROR; + if (accum_free(f, 2 * sizeof(int32_t), sizeof(int32_t)) < 0) + FAIL_STACK_ERROR; /* Check that the accumulator still contains the correct data */ - if(accum_read(1 * sizeof(int32_t), 1 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf + 1, rbuf, 1 * sizeof(int32_t)) != 0) TEST_ERROR; - if(accum_read(3 * sizeof(int32_t), 124 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf + 3, rbuf, 124 * sizeof(int32_t)) != 0) TEST_ERROR; - + if (accum_read(1 * sizeof(int32_t), 1 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf + 1, rbuf, 1 * sizeof(int32_t)) != 0) + TEST_ERROR; + if (accum_read(3 * sizeof(int32_t), 124 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf + 3, rbuf, 124 * sizeof(int32_t)) != 0) + TEST_ERROR; /* Test freeing section that overlaps the start of the accumulator and is * entirely before dirty section */ - if(accum_write(64 * sizeof(int32_t), 128 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(64 * sizeof(int32_t), 128 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; HDmemcpy(expect + 64, wbuf, 128 * sizeof(int32_t)); - if(accum_flush(f) < 0) FAIL_STACK_ERROR; - if(accum_write(68 * sizeof(int32_t), 4 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; + if (accum_flush(f) < 0) + FAIL_STACK_ERROR; + if (accum_write(68 * sizeof(int32_t), 4 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; HDmemcpy(expect + 68, wbuf, 4 * sizeof(int32_t)); - if(accum_free(f, 62 * sizeof(int32_t), 4 * sizeof(int32_t)) < 0) FAIL_STACK_ERROR; + if (accum_free(f, 62 * sizeof(int32_t), 4 * sizeof(int32_t)) < 0) + FAIL_STACK_ERROR; /* Check that the accumulator still contains the correct data */ - if(accum_read(66 * sizeof(int32_t), 126 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(expect + 66, rbuf, 126 * sizeof(int32_t)) != 0) TEST_ERROR; - + if (accum_read(66 * sizeof(int32_t), 126 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(expect + 66, rbuf, 126 * sizeof(int32_t)) != 0) + TEST_ERROR; /* Test freeing section that overlaps the start of the accumulator and * completely contains dirty section */ - if(accum_write(64 * sizeof(int32_t), 128 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(64 * sizeof(int32_t), 128 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; HDmemcpy(expect + 64, wbuf, 128 * sizeof(int32_t)); - if(accum_flush(f) < 0) FAIL_STACK_ERROR; - if(accum_write(68 * sizeof(int32_t), 4 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; + if (accum_flush(f) < 0) + FAIL_STACK_ERROR; + if (accum_write(68 * sizeof(int32_t), 4 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; HDmemcpy(expect + 68, wbuf, 4 * sizeof(int32_t)); - if(accum_free(f, 62 * sizeof(int32_t), 16 * sizeof(int32_t)) < 0) FAIL_STACK_ERROR; + if (accum_free(f, 62 * sizeof(int32_t), 16 * sizeof(int32_t)) < 0) + FAIL_STACK_ERROR; /* Check that the accumulator still contains the correct data */ - if(accum_read(78 * sizeof(int32_t), 114 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(expect + 78, rbuf, 114 * sizeof(int32_t)) != 0) TEST_ERROR; - + if (accum_read(78 * sizeof(int32_t), 114 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(expect + 78, rbuf, 114 * sizeof(int32_t)) != 0) + TEST_ERROR; /* Test freeing section completely contained in accumulator and is entirely * before dirty section */ - if(accum_write(64 * sizeof(int32_t), 128 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(64 * sizeof(int32_t), 128 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; HDmemcpy(expect + 64, wbuf, 128 * sizeof(int32_t)); - if(accum_flush(f) < 0) FAIL_STACK_ERROR; - if(accum_write(72 * sizeof(int32_t), 4 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; + if (accum_flush(f) < 0) + FAIL_STACK_ERROR; + if (accum_write(72 * sizeof(int32_t), 4 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; HDmemcpy(expect + 72, wbuf, 4 * sizeof(int32_t)); - if(accum_free(f, 66 * sizeof(int32_t), 4 * sizeof(int32_t)) < 0) FAIL_STACK_ERROR; + if (accum_free(f, 66 * sizeof(int32_t), 4 * sizeof(int32_t)) < 0) + FAIL_STACK_ERROR; /* Check that the accumulator still contains the correct data */ - if(accum_read(70 * sizeof(int32_t), 122 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(expect + 70, rbuf, 122 * sizeof(int32_t)) != 0) TEST_ERROR; - + if (accum_read(70 * sizeof(int32_t), 122 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(expect + 70, rbuf, 122 * sizeof(int32_t)) != 0) + TEST_ERROR; /* Test freeing section completely contained in accumulator, starts before * dirty section, and ends in dirty section */ - if(accum_write(64 * sizeof(int32_t), 128 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(64 * sizeof(int32_t), 128 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; HDmemcpy(expect + 64, wbuf, 128 * sizeof(int32_t)); - if(accum_flush(f) < 0) FAIL_STACK_ERROR; - if(accum_write(72 * sizeof(int32_t), 4 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; + if (accum_flush(f) < 0) + FAIL_STACK_ERROR; + if (accum_write(72 * sizeof(int32_t), 4 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; HDmemcpy(expect + 72, wbuf, 4 * sizeof(int32_t)); - if(accum_free(f, 70 * sizeof(int32_t), 4 * sizeof(int32_t)) < 0) FAIL_STACK_ERROR; + if (accum_free(f, 70 * sizeof(int32_t), 4 * sizeof(int32_t)) < 0) + FAIL_STACK_ERROR; /* Check that the accumulator still contains the correct data */ - if(accum_read(74 * sizeof(int32_t), 118 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(expect + 74, rbuf, 118 * sizeof(int32_t)) != 0) TEST_ERROR; - + if (accum_read(74 * sizeof(int32_t), 118 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(expect + 74, rbuf, 118 * sizeof(int32_t)) != 0) + TEST_ERROR; /* Test freeing section completely contained in accumulator and completely * contains dirty section */ - if(accum_write(64 * sizeof(int32_t), 128 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(64 * sizeof(int32_t), 128 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; HDmemcpy(expect + 64, wbuf, 128 * sizeof(int32_t)); - if(accum_flush(f) < 0) FAIL_STACK_ERROR; - if(accum_write(72 * sizeof(int32_t), 4 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; + if (accum_flush(f) < 0) + FAIL_STACK_ERROR; + if (accum_write(72 * sizeof(int32_t), 4 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; HDmemcpy(expect + 72, wbuf, 4 * sizeof(int32_t)); - if(accum_free(f, 70 * sizeof(int32_t), 8 * sizeof(int32_t)) < 0) FAIL_STACK_ERROR; + if (accum_free(f, 70 * sizeof(int32_t), 8 * sizeof(int32_t)) < 0) + FAIL_STACK_ERROR; /* Check that the accumulator still contains the correct data */ - if(accum_read(78 * sizeof(int32_t), 114 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(expect + 78, rbuf, 114 * sizeof(int32_t)) != 0) TEST_ERROR; - + if (accum_read(78 * sizeof(int32_t), 114 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(expect + 78, rbuf, 114 * sizeof(int32_t)) != 0) + TEST_ERROR; /* Test freeing section completely contained in accumulator, starts at start * of dirty section, and ends in dirty section */ - if(accum_write(64 * sizeof(int32_t), 128 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(64 * sizeof(int32_t), 128 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; HDmemcpy(expect + 64, wbuf, 128 * sizeof(int32_t)); - if(accum_flush(f) < 0) FAIL_STACK_ERROR; - if(accum_write(72 * sizeof(int32_t), 8 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; + if (accum_flush(f) < 0) + FAIL_STACK_ERROR; + if (accum_write(72 * sizeof(int32_t), 8 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; HDmemcpy(expect + 72, wbuf, 8 * sizeof(int32_t)); - if(accum_free(f, 72 * sizeof(int32_t), 4 * sizeof(int32_t)) < 0) FAIL_STACK_ERROR; + if (accum_free(f, 72 * sizeof(int32_t), 4 * sizeof(int32_t)) < 0) + FAIL_STACK_ERROR; /* Check that the accumulator still contains the correct data */ - if(accum_read(76 * sizeof(int32_t), 116 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(expect + 76, rbuf, 116 * sizeof(int32_t)) != 0) TEST_ERROR; + if (accum_read(76 * sizeof(int32_t), 116 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(expect + 76, rbuf, 116 * sizeof(int32_t)) != 0) + TEST_ERROR; HDfree(wbuf); wbuf = NULL; @@ -510,24 +572,24 @@ test_free(H5F_t *f) HDfree(expect); expect = NULL; - if(accum_reset(f) < 0) FAIL_STACK_ERROR; + if (accum_reset(f) < 0) + FAIL_STACK_ERROR; PASSED(); return 0; error: - if(wbuf) + if (wbuf) HDfree(wbuf); - if(rbuf) + if (rbuf) HDfree(rbuf); - if(expect) + if (expect) HDfree(expect); return 1; } /* test_free */ - /*------------------------------------------------------------------------- * Function: test_accum_overlap * @@ -544,143 +606,179 @@ error: *------------------------------------------------------------------------- */ unsigned -test_accum_overlap(H5F_t *f) +test_accum_overlap(H5F_t* f) { - int i = 0; - int32_t *wbuf, *rbuf; + int i = 0; + int32_t* wbuf, * rbuf; TESTING("overlapping write to metadata accumulator"); /* Allocate buffers */ - wbuf = (int32_t *)HDmalloc(4096 * sizeof(int32_t)); + wbuf = (int32_t*)HDmalloc(4096 * sizeof(int32_t)); HDassert(wbuf); - rbuf = (int32_t *)HDcalloc((size_t)4096, sizeof(int32_t)); + rbuf = (int32_t*)HDcalloc((size_t)4096, sizeof(int32_t)); HDassert(rbuf); /* Case 1: No metadata in accumulator */ /* Write 10 1's at address 40 */ /* @0:| 1111111111| */ /* Put some data in the accumulator initially */ - for(i = 0; i < 10; i++) + for (i = 0; i < 10; i++) wbuf[i] = 1; - if(accum_write(40, 10 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; - if(accum_read(40, 10 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, 10 * sizeof(int32_t)) != 0) TEST_ERROR; + if (accum_write(40, 10 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; + if (accum_read(40, 10 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, 10 * sizeof(int32_t)) != 0) + TEST_ERROR; /* Case 2: End of new piece aligns with start of accumulated data */ /* Write 5 2's at address 20 */ /* @0:| 222221111111111| */ - for(i = 0; i < 5; i++) + for (i = 0; i < 5; i++) wbuf[i] = 2; - if(accum_write(20, 5 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; - if(accum_read(20, 5 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, 5 * sizeof(int32_t)) != 0) TEST_ERROR; + if (accum_write(20, 5 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; + if (accum_read(20, 5 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, 5 * sizeof(int32_t)) != 0) + TEST_ERROR; /* Case 3: Start of new piece aligns with start of accumulated data */ /* Write 3 3's at address 20 */ /* @0:| 333221111111111| */ - for(i = 0; i < 3; i++) + for (i = 0; i < 3; i++) wbuf[i] = 3; - if(accum_write(20, 3 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; - if(accum_read(20, 3 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, 3 * sizeof(int32_t)) != 0) TEST_ERROR; + if (accum_write(20, 3 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; + if (accum_read(20, 3 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, 3 * sizeof(int32_t)) != 0) + TEST_ERROR; /* Case 4: New piece overlaps start of accumulated data */ /* Write 5 4's at address 8 */ /* @0:| 444443221111111111| */ - for(i = 0; i < 5; i++) + for (i = 0; i < 5; i++) wbuf[i] = 4; - if(accum_write(8, 5 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; - if(accum_read(8, 5 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, 5 * sizeof(int32_t)) != 0) TEST_ERROR; + if (accum_write(8, 5 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; + if (accum_read(8, 5 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, 5 * sizeof(int32_t)) != 0) + TEST_ERROR; /* Case 5: New piece completely within accumulated data */ /* Write 4 5's at address 48 */ /* @0:| 444443221155551111| */ - for(i = 0; i < 4; i++) + for (i = 0; i < 4; i++) wbuf[i] = 5; - if(accum_write(48, 4 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; - if(accum_read(48, 4 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, 4 * sizeof(int32_t)) != 0) TEST_ERROR; + if (accum_write(48, 4 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; + if (accum_read(48, 4 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, 4 * sizeof(int32_t)) != 0) + TEST_ERROR; /* Case 6: End of new piece aligns with end of accumulated data */ /* Write 3 6's at address 68 */ /* @0:| 444443221155551666| */ - for(i = 0; i < 3; i++) + for (i = 0; i < 3; i++) wbuf[i] = 6; - if(accum_write(68, 3 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; - if(accum_read(68, 3 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, 3 * sizeof(int32_t)) != 0) TEST_ERROR; + if (accum_write(68, 3 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; + if (accum_read(68, 3 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, 3 * sizeof(int32_t)) != 0) + TEST_ERROR; /* Case 7: New piece overlaps end of accumulated data */ /* Write 5 7's at address 76 */ /* @0:| 4444432211555516677777| */ - for(i = 0; i < 5; i++) + for (i = 0; i < 5; i++) wbuf[i] = 7; - if(accum_write(76, 5 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; - if(accum_read(76, 5 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, 5 * sizeof(int32_t)) != 0) TEST_ERROR; + if (accum_write(76, 5 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; + if (accum_read(76, 5 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, 5 * sizeof(int32_t)) != 0) + TEST_ERROR; /* Case 8: Start of new piece aligns with end of accumulated data */ /* Write 3 8's at address 96 */ /* @0:| 4444432211555516677777888| */ - for(i = 0; i < 3; i++) + for (i = 0; i < 3; i++) wbuf[i] = 8; - if(accum_write(96, 3 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; - if(accum_read(96, 3 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, 3 * sizeof(int32_t)) != 0) TEST_ERROR; + if (accum_write(96, 3 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; + if (accum_read(96, 3 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, 3 * sizeof(int32_t)) != 0) + TEST_ERROR; /* Set up expected data buffer and verify contents of accumulator as constructed by cases 1-8, above */ - for(i = 0; i < 5; i++) + for (i = 0; i < 5; i++) wbuf[i] = 4; - for(i = 5; i < 6; i++) + for (i = 5; i < 6; i++) wbuf[i] = 3; - for(i = 6; i < 8; i++) + for (i = 6; i < 8; i++) wbuf[i] = 2; - for(i = 8; i < 10; i++) + for (i = 8; i < 10; i++) wbuf[i] = 1; - for(i = 10; i < 14; i++) + for (i = 10; i < 14; i++) wbuf[i] = 5; - for(i = 14; i < 15; i++) + for (i = 14; i < 15; i++) wbuf[i] = 1; - for(i = 15; i < 17; i++) + for (i = 15; i < 17; i++) wbuf[i] = 6; - for(i = 17; i < 22; i++) + for (i = 17; i < 22; i++) wbuf[i] = 7; - for(i = 22; i < 25; i++) + for (i = 22; i < 25; i++) wbuf[i] = 8; - if(accum_read(8, 25 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, 25 * sizeof(int32_t)) != 0) TEST_ERROR; + if (accum_read(8, 25 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, 25 * sizeof(int32_t)) != 0) + TEST_ERROR; /* Case 9: New piece completely before accumulated data */ /* Write 1 9 at address 0 */ /* @0:|9 4444432211555516677777888| */ - for(i = 0; i < 1; i++) + for (i = 0; i < 1; i++) wbuf[i] = 9; - if(accum_write(0, 1 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; - if(accum_read(0, 1 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, 1 * sizeof(int32_t)) != 0) TEST_ERROR; + if (accum_write(0, 1 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; + if (accum_read(0, 1 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, 1 * sizeof(int32_t)) != 0) + TEST_ERROR; /* Case 10: New piece completely after accumulated data */ /* Write 4 3's at address 116 */ /* @0:|9 4444432211555516677777888 3333| */ - for(i = 0; i < 4; i++) + for (i = 0; i < 4; i++) wbuf[i] = 3; - if(accum_write(116, 4 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; - if(accum_read(116, 4 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, 4 * sizeof(int32_t)) != 0) TEST_ERROR; + if (accum_write(116, 4 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; + if (accum_read(116, 4 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, 4 * sizeof(int32_t)) != 0) + TEST_ERROR; /* Case 11: New piece completely overlaps accumulated data */ /* Write 6 4's at address 112 */ /* @0:|9 4444432211555516677777888 444444| */ - for(i = 0; i < 6; i++) + for (i = 0; i < 6; i++) wbuf[i] = 4; - if(accum_write(112, 6 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; - if(accum_read(112, 6 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, 6 * sizeof(int32_t)) != 0) TEST_ERROR; + if (accum_write(112, 6 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; + if (accum_read(112, 6 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, 6 * sizeof(int32_t)) != 0) + TEST_ERROR; - if(accum_reset(f) < 0) FAIL_STACK_ERROR; + if (accum_reset(f) < 0) + FAIL_STACK_ERROR; PASSED(); @@ -698,7 +796,6 @@ error: return 1; } /* test_accum_overlap */ - /*------------------------------------------------------------------------- * Function: test_accum_overlap_clean * @@ -716,151 +813,192 @@ error: *------------------------------------------------------------------------- */ unsigned -test_accum_overlap_clean(H5F_t *f) +test_accum_overlap_clean(H5F_t* f) { - int i = 0; - int32_t *wbuf, *rbuf; + int i = 0; + int32_t* wbuf, * rbuf; TESTING("overlapping write to partially clean metadata accumulator"); /* Allocate buffers */ - wbuf = (int32_t *)HDmalloc(4096 * sizeof(int32_t)); + wbuf = (int32_t*)HDmalloc(4096 * sizeof(int32_t)); HDassert(wbuf); - rbuf = (int32_t *)HDcalloc((size_t)4096, sizeof(int32_t)); + rbuf = (int32_t*)HDcalloc((size_t)4096, sizeof(int32_t)); HDassert(rbuf); /* Case 1: No metadata in accumulator */ /* Write 10 1's at address 40 */ /* @0:| 1111111111| */ /* Put some data in the accumulator initially */ - for(i = 0; i < 10; i++) + for (i = 0; i < 10; i++) wbuf[i] = 1; - if(accum_write(40, 10 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; - if(accum_read(40, 10 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, 10 * sizeof(int32_t)) != 0) TEST_ERROR; + if (accum_write(40, 10 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; + if (accum_read(40, 10 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, 10 * sizeof(int32_t)) != 0) + TEST_ERROR; /* Case 2: End of new piece aligns with start of clean accumulated data */ /* Write 5 2's at address 20 */ /* @0:| 222221111111111| */ - if(accum_flush(f) < 0) FAIL_STACK_ERROR; - for(i = 0; i < 5; i++) + if (accum_flush(f) < 0) + FAIL_STACK_ERROR; + for (i = 0; i < 5; i++) wbuf[i] = 2; - if(accum_write(20, 5 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; - if(accum_read(20, 5 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, 5 * sizeof(int32_t)) != 0) TEST_ERROR; + if (accum_write(20, 5 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; + if (accum_read(20, 5 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, 5 * sizeof(int32_t)) != 0) + TEST_ERROR; /* Case 3: Start of new piece aligns with start of accumulated data, * completely encloses dirty section of accumulator */ - /* Write 6 3's at address 20 */ - /* @0:| 333333111111111| */ - for(i = 0; i < 6; i++) + /* Write 6 3's at address 20 */ + /* @0:| 333333111111111| */ + for (i = 0; i < 6; i++) wbuf[i] = 3; - if(accum_write(20, 6 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; - if(accum_read(20, 6 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, 6 * sizeof(int32_t)) != 0) TEST_ERROR; + if (accum_write(20, 6 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; + if (accum_read(20, 6 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, 6 * sizeof(int32_t)) != 0) + TEST_ERROR; /* Case 4: New piece completely within accumulated data, overlaps * end of dirty section of accumulator */ - /* Write 2 4's at address 40 */ - /* @0:| 333334411111111| */ - for(i = 0; i < 2; i++) + /* Write 2 4's at address 40 */ + /* @0:| 333334411111111| */ + for (i = 0; i < 2; i++) wbuf[i] = 4; - if(accum_write(40, 2 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; - if(accum_read(40, 2 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, 2 * sizeof(int32_t)) != 0) TEST_ERROR; + if (accum_write(40, 2 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; + if (accum_read(40, 2 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, 2 * sizeof(int32_t)) != 0) + TEST_ERROR; /* Case 5: New piece completely within accumulated data, completely * after dirty section of accumulator */ - /* Write 2 5's at address 52 */ - /* @0:| 333334415511111| */ - for(i = 0; i < 2; i++) + /* Write 2 5's at address 52 */ + /* @0:| 333334415511111| */ + for (i = 0; i < 2; i++) wbuf[i] = 5; - if(accum_write(52, 2 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; - if(accum_read(52, 2 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, 2 * sizeof(int32_t)) != 0) TEST_ERROR; + if (accum_write(52, 2 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; + if (accum_read(52, 2 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, 2 * sizeof(int32_t)) != 0) + TEST_ERROR; /* Case 6: New piece completely within clean accumulated data */ /* Write 3 6's at address 44 */ /* @0:| 333334666511111| */ - if(accum_flush(f) < 0) FAIL_STACK_ERROR; - for(i = 0; i < 3; i++) + if (accum_flush(f) < 0) + FAIL_STACK_ERROR; + for (i = 0; i < 3; i++) wbuf[i] = 6; - if(accum_write(44, 3 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; - if(accum_read(44, 3 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, 3 * sizeof(int32_t)) != 0) TEST_ERROR; + if (accum_write(44, 3 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; + if (accum_read(44, 3 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, 3 * sizeof(int32_t)) != 0) + TEST_ERROR; /* Case 7: New piece overlaps start of clean accumulated data */ /* Write 2 7's at address 16 */ /* @0:| 7733334666511111| */ - if(accum_flush(f) < 0) FAIL_STACK_ERROR; - for(i = 0; i < 2; i++) + if (accum_flush(f) < 0) + FAIL_STACK_ERROR; + for (i = 0; i < 2; i++) wbuf[i] = 7; - if(accum_write(16, 2 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; - if(accum_read(16, 2 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, 2 * sizeof(int32_t)) != 0) TEST_ERROR; + if (accum_write(16, 2 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; + if (accum_read(16, 2 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, 2 * sizeof(int32_t)) != 0) + TEST_ERROR; /* Case 8: New piece overlaps start of accumulated data, completely * encloses dirty section of accumulator */ - /* Write 4 8's at address 12 */ - /* @0:| 88883334666511111| */ - for(i = 0; i < 4; i++) + /* Write 4 8's at address 12 */ + /* @0:| 88883334666511111| */ + for (i = 0; i < 4; i++) wbuf[i] = 8; - if(accum_write(12, 4 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; - if(accum_read(12, 4 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, 4 * sizeof(int32_t)) != 0) TEST_ERROR; + if (accum_write(12, 4 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; + if (accum_read(12, 4 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, 4 * sizeof(int32_t)) != 0) + TEST_ERROR; /* Case 9: Start of new piece aligns with end of clean accumulated data */ /* Write 3 9's at address 80 */ /* @0:| 88883334666511111999| */ - if(accum_flush(f) < 0) FAIL_STACK_ERROR; - for(i = 0; i < 3; i++) + if (accum_flush(f) < 0) + FAIL_STACK_ERROR; + for (i = 0; i < 3; i++) wbuf[i] = 9; - if(accum_write(80, 3 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; - if(accum_read(80, 3 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, 3 * sizeof(int32_t)) != 0) TEST_ERROR; + if (accum_write(80, 3 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; + if (accum_read(80, 3 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, 3 * sizeof(int32_t)) != 0) + TEST_ERROR; /* Case 10: New piece overlaps end of clean accumulated data */ /* Write 3 2's at address 88 */ /* @0:| 888833346665111119922| */ - if(accum_flush(f) < 0) FAIL_STACK_ERROR; - for(i = 0; i < 2; i++) + if (accum_flush(f) < 0) + FAIL_STACK_ERROR; + for (i = 0; i < 2; i++) wbuf[i] = 2; - if(accum_write(88, 2 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; - if(accum_read(88, 2 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, 2 * sizeof(int32_t)) != 0) TEST_ERROR; + if (accum_write(88, 2 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; + if (accum_read(88, 2 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, 2 * sizeof(int32_t)) != 0) + TEST_ERROR; /* Case 11: New piece overlaps end of accumulated data, completely encloses * dirty section of accumulator */ - /* Write 4 7's at address 84 */ - /* @0:| 8888333466651111197777| */ - for(i = 0; i < 4; i++) + /* Write 4 7's at address 84 */ + /* @0:| 8888333466651111197777| */ + for (i = 0; i < 4; i++) wbuf[i] = 7; - if(accum_write(84, 4 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; - if(accum_read(84, 4 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, 4 * sizeof(int32_t)) != 0) TEST_ERROR; + if (accum_write(84, 4 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; + if (accum_read(84, 4 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, 4 * sizeof(int32_t)) != 0) + TEST_ERROR; /* Set up expected data buffer and verify contents of accumulator as constructed by cases 1-11, above */ - for(i = 0; i < 4; i++) + for (i = 0; i < 4; i++) wbuf[i] = 8; - for(i = 4; i < 7; i++) + for (i = 4; i < 7; i++) wbuf[i] = 3; - for(i = 7; i < 8; i++) + for (i = 7; i < 8; i++) wbuf[i] = 4; - for(i = 8; i < 11; i++) + for (i = 8; i < 11; i++) wbuf[i] = 6; - for(i = 11; i < 12; i++) + for (i = 11; i < 12; i++) wbuf[i] = 5; - for(i = 12; i < 17; i++) + for (i = 12; i < 17; i++) wbuf[i] = 1; - for(i = 17; i < 18; i++) + for (i = 17; i < 18; i++) wbuf[i] = 9; - for(i = 18; i < 22; i++) + for (i = 18; i < 22; i++) wbuf[i] = 7; - if(accum_read(12, 22 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, 22 * sizeof(int32_t)) != 0) TEST_ERROR; + if (accum_read(12, 22 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, 22 * sizeof(int32_t)) != 0) + TEST_ERROR; - if(accum_reset(f) < 0) FAIL_STACK_ERROR; + if (accum_reset(f) < 0) + FAIL_STACK_ERROR; PASSED(); @@ -878,7 +1016,6 @@ error: return 1; } /* test_accum_overlap_clean */ - /*------------------------------------------------------------------------- * Function: test_accum_non_overlap_size * @@ -895,39 +1032,46 @@ error: *------------------------------------------------------------------------- */ unsigned -test_accum_non_overlap_size(H5F_t *f) +test_accum_non_overlap_size(H5F_t* f) { - int i = 0; - int32_t *wbuf, *rbuf; + int i = 0; + int32_t* wbuf, * rbuf; TESTING("non-overlapping write to accumulator larger then accum_size"); /* Allocate buffers */ - wbuf = (int *)HDmalloc(4096 * sizeof(int32_t)); + wbuf = (int*)HDmalloc(4096 * sizeof(int32_t)); HDassert(wbuf); - rbuf = (int *)HDcalloc((size_t)4096, sizeof(int32_t)); + rbuf = (int*)HDcalloc((size_t)4096, sizeof(int32_t)); HDassert(rbuf); /* Case 1: No metadata in accumulator */ /* Write 10 1's at address 140 */ /* @0:| 1111111111| */ /* Put some data in the accumulator initially */ - for(i = 0; i < 10; i++) + for (i = 0; i < 10; i++) wbuf[i] = 1; - if(accum_write(140, 10 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; - if(accum_read(140, 10 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, 10 * sizeof(int32_t)) != 0) TEST_ERROR; + if (accum_write(140, 10 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; + if (accum_read(140, 10 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, 10 * sizeof(int32_t)) != 0) + TEST_ERROR; /* Case 9: New piece completely before accumulated data */ /* Write 20 9 at address 0 */ /* @0:|9 1111111111| */ - for(i = 0; i < 20; i++) + for (i = 0; i < 20; i++) wbuf[i] = 9; - if(accum_write(0, 20 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; - if(accum_read(0, 20 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, 20 * sizeof(int32_t)) != 0) TEST_ERROR; + if (accum_write(0, 20 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; + if (accum_read(0, 20 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, 20 * sizeof(int32_t)) != 0) + TEST_ERROR; - if(accum_reset(f) < 0) FAIL_STACK_ERROR; + if (accum_reset(f) < 0) + FAIL_STACK_ERROR; PASSED(); @@ -962,39 +1106,46 @@ error: *------------------------------------------------------------------------- */ unsigned -test_accum_overlap_size(H5F_t *f) +test_accum_overlap_size(H5F_t* f) { - int i = 0; - int32_t *wbuf, *rbuf; + int i = 0; + int32_t* wbuf, * rbuf; TESTING("overlapping write to accumulator larger then accum_size"); /* Allocate buffers */ - wbuf = (int32_t *)HDmalloc(4096 * sizeof(int32_t)); + wbuf = (int32_t*)HDmalloc(4096 * sizeof(int32_t)); HDassert(wbuf); - rbuf = (int32_t *)HDcalloc((size_t)4096, sizeof(int32_t)); + rbuf = (int32_t*)HDcalloc((size_t)4096, sizeof(int32_t)); HDassert(rbuf); /* Case 1: No metadata in accumulator */ /* Write 10 1's at address 64 */ /* @0:| 1111111111| */ /* Put some data in the accumulator initially */ - for(i = 0; i < 10; i++) + for (i = 0; i < 10; i++) wbuf[i] = 1; - if(accum_write(64, 10 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; - if(accum_read(64, 10 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, 10 * sizeof(int32_t)) != 0) TEST_ERROR; + if (accum_write(64, 10 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; + if (accum_read(64, 10 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, 10 * sizeof(int32_t)) != 0) + TEST_ERROR; /* Case 9: New piece completely before accumulated data */ /* Write 72 9 at address 60 */ /* @0:|9 1111111111| */ - for(i = 0; i < 72; i++) + for (i = 0; i < 72; i++) wbuf[i] = 9; - if(accum_write(60, 72 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR; - if(accum_read(60, 72 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, 72 * sizeof(int32_t)) != 0) TEST_ERROR; + if (accum_write(60, 72 * sizeof(int32_t), wbuf) < 0) + FAIL_STACK_ERROR; + if (accum_read(60, 72 * sizeof(int32_t), rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, 72 * sizeof(int32_t)) != 0) + TEST_ERROR; - if(accum_reset(f) < 0) FAIL_STACK_ERROR; + if (accum_reset(f) < 0) + FAIL_STACK_ERROR; PASSED(); @@ -1012,7 +1163,6 @@ error: return 1; } /* test_accum_overlap_size */ - /*------------------------------------------------------------------------- * Function: test_accum_adjust * @@ -1040,22 +1190,22 @@ error: *------------------------------------------------------------------------- */ unsigned -test_accum_adjust(H5F_t *f) +test_accum_adjust(H5F_t* f) { - int i = 0; - int s = 1048576; /* size of buffer */ - int32_t *wbuf, *rbuf; + int i = 0; + int s = 1048576; /* size of buffer */ + int32_t* wbuf, * rbuf; TESTING("accumulator adjustments after append/prepend of data"); /* Allocate buffers */ - wbuf = (int32_t *)HDmalloc((size_t)s * sizeof(int32_t)); + wbuf = (int32_t*)HDmalloc((size_t)s * sizeof(int32_t)); HDassert(wbuf); - rbuf = (int32_t *)HDcalloc((size_t)s, sizeof(int32_t)); + rbuf = (int32_t*)HDcalloc((size_t)s, sizeof(int32_t)); HDassert(rbuf); /* Fill up write buffer */ - for(i = 0; i < s; i++) + for (i = 0; i < s; i++) wbuf[i] = i + 1; /* ================================================================ */ @@ -1066,7 +1216,8 @@ test_accum_adjust(H5F_t *f) * but not quite full. This will force the accumulator to, on subsequent * writes, a) have to adjust since it's nearly full, and b) prevent * an increase in size because it's already at it's maximum size */ - if(accum_write((1024 * 1024), (1024 * 1024) - 1, wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write((1024 * 1024), (1024 * 1024) - 1, wbuf) < 0) + FAIL_STACK_ERROR; /* Write a small (1KB) block that prepends to the front of the accumulator. */ /* ==> Accumulator will need more buffer space */ @@ -1075,18 +1226,24 @@ test_accum_adjust(H5F_t *f) /* ==> New block is being prepended to accumulator */ /* ==> Accumulator is dirty, it will be flushed. */ /* ==> Dirty region overlaps region to eliminate from accumulator */ - if(accum_write((1024 * 1024) - 1024, 1024, wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write((1024 * 1024) - 1024, 1024, wbuf) < 0) + FAIL_STACK_ERROR; /* Read back and verify first write */ - if(accum_read((1024 * 1024), (1024 * 1024) - 1, rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, (size_t)((1024 * 1024) - 1)) != 0) TEST_ERROR; + if (accum_read((1024 * 1024), (1024 * 1024) - 1, rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, (size_t)((1024 * 1024) - 1)) != 0) + TEST_ERROR; /* Read back and verify second write */ - if(accum_read((1024 * 1024) - 1024, 1024, rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, (size_t)1024) != 0) TEST_ERROR; + if (accum_read((1024 * 1024) - 1024, 1024, rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, (size_t)1024) != 0) + TEST_ERROR; /* Reset accumulator for next case */ - if(accum_reset(f) < 0) FAIL_STACK_ERROR; + if (accum_reset(f) < 0) + FAIL_STACK_ERROR; /* ================================================================ */ /* Case 2: Prepending large block to large, fully dirty accumulator */ @@ -1096,7 +1253,8 @@ test_accum_adjust(H5F_t *f) * but not quite full. This will force the accumulator to, on subsequent * writes, a) have to adjust since it's nearly full, and b) prevent * an increase in size because it's already at it's maximum size */ - if(accum_write((1024 * 1024), (1024 * 1024) - 1, wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write((1024 * 1024), (1024 * 1024) - 1, wbuf) < 0) + FAIL_STACK_ERROR; /* Write a large (just under 1MB) block to the front of the accumulator. */ /* ==> Accumulator will need more buffer space */ @@ -1105,17 +1263,23 @@ test_accum_adjust(H5F_t *f) /* ==> New block is being prepended to accumulator */ /* ==> Accumulator is dirty, it will be flushed. */ /* ==> Dirty region overlaps region to eliminate from accumulator */ - if(accum_write(5, (1024 * 1024) - 5, wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(5, (1024 * 1024) - 5, wbuf) < 0) + FAIL_STACK_ERROR; /* Read back and verify both pieces of data */ - if(accum_read(1048576, 1048575, rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, (size_t)1048576) != 0) TEST_ERROR; + if (accum_read(1048576, 1048575, rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, (size_t)1048576) != 0) + TEST_ERROR; - if(accum_read(5, 1048571, rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, (size_t)1048571) != 0) TEST_ERROR; + if (accum_read(5, 1048571, rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, (size_t)1048571) != 0) + TEST_ERROR; /* Reset accumulator for next case */ - if(accum_reset(f) < 0) FAIL_STACK_ERROR; + if (accum_reset(f) < 0) + FAIL_STACK_ERROR; /* ========================================================= */ /* Case 3: Appending small block to large, clean accumulator */ @@ -1125,32 +1289,39 @@ test_accum_adjust(H5F_t *f) * but not quite full. This will force the accumulator to, on subsequent * writes, a) have to adjust since it's nearly full, and b) prevent * an increase in size because it's already at it's maximum size */ - if(accum_write(0, (1024 * 1024) - 1, wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(0, (1024 * 1024) - 1, wbuf) < 0) + FAIL_STACK_ERROR; /* Flush the accumulator -- we want to test the case when accumulator contains clean data */ - if(accum_flush(f) < 0) FAIL_STACK_ERROR + if (accum_flush(f) < 0) + FAIL_STACK_ERROR - /* Write a small (1KB) block to the end of the accumulator */ - /* ==> Accumulator will need more buffer space */ - /* ==> Accumulator will try to resize, but see that it's getting too big */ - /* ==> Size of new block is larger than half maximum size of accumulator */ - /* ==> New block being appended to accumulator */ - /* ==> Accumulator is NOT dirty */ - /* ==> Since we're appending, need to adjust location of accumulator */ - if(accum_write((1024 * 1024) - 1, 1024, wbuf) < 0) FAIL_STACK_ERROR; + /* Write a small (1KB) block to the end of the accumulator */ + /* ==> Accumulator will need more buffer space */ + /* ==> Accumulator will try to resize, but see that it's getting too big */ + /* ==> Size of new block is larger than half maximum size of accumulator */ + /* ==> New block being appended to accumulator */ + /* ==> Accumulator is NOT dirty */ + /* ==> Since we're appending, need to adjust location of accumulator */ + if (accum_write((1024 * 1024) - 1, 1024, wbuf) < 0) + FAIL_STACK_ERROR; /* Write a piece of metadata outside current accumulator to force write to disk */ - if(accum_write(0, 1, wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(0, 1, wbuf) < 0) + FAIL_STACK_ERROR; /* Read in the piece we wrote to disk above, and then verify that the data is as expected */ - if(accum_read((1024 * 1024) - 1, 1024, rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, (size_t)1024) != 0) TEST_ERROR; + if (accum_read((1024 * 1024) - 1, 1024, rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, (size_t)1024) != 0) + TEST_ERROR; /* Reset accumulator for next case */ - if(accum_reset(f) < 0) FAIL_STACK_ERROR; + if (accum_reset(f) < 0) + FAIL_STACK_ERROR; /* ==================================================================== */ /* Case 4: Appending small block to large, partially dirty accumulator, */ @@ -1161,13 +1332,16 @@ test_accum_adjust(H5F_t *f) * but not quite full. This will force the accumulator to, on subsequent * writes, a) have to adjust since it's nearly full, and b) prevent * an increase in size because it's already at it's maximum size */ - if(accum_write(0, (1024 * 1024) - 5, wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(0, (1024 * 1024) - 5, wbuf) < 0) + FAIL_STACK_ERROR; /* Flush the accumulator to clean it */ - if(accum_flush(f) < 0) FAIL_STACK_ERROR + if (accum_flush(f) < 0) + FAIL_STACK_ERROR - /* write to part of the accumulator so just the start of it is dirty */ - if(accum_write(0, 5, wbuf) < 0) FAIL_STACK_ERROR; + /* write to part of the accumulator so just the start of it is dirty */ + if (accum_write(0, 5, wbuf) < 0) + FAIL_STACK_ERROR; /* Write a small (~340KB) piece of data to the other end of the accumulator */ /* ==> Accumulator will need more buffer space */ @@ -1178,19 +1352,24 @@ test_accum_adjust(H5F_t *f) /* ==> Max Buffer Size - (dirty offset + adjust size) >= 2 * size) */ /* ==> Need to adjust location of accumulator while appending */ /* ==> Accumulator will need to be reallocated */ - if(accum_write(1048571, 349523, wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(1048571, 349523, wbuf) < 0) + FAIL_STACK_ERROR; /* Write a piece of metadata outside current accumulator to force write to disk */ - if(accum_write(1398900, 1, wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(1398900, 1, wbuf) < 0) + FAIL_STACK_ERROR; /* Read in the piece we wrote to disk above, and then verify that the data is as expected */ - if(accum_read(1048571, 349523, rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, (size_t)349523) != 0) TEST_ERROR; + if (accum_read(1048571, 349523, rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, (size_t)349523) != 0) + TEST_ERROR; /* Reset accumulator for next case */ - if(accum_reset(f) < 0) FAIL_STACK_ERROR; + if (accum_reset(f) < 0) + FAIL_STACK_ERROR; /* ==================================================================== */ /* Case 5: Appending small block to large, partially dirty accumulator, */ @@ -1198,14 +1377,17 @@ test_accum_adjust(H5F_t *f) /* ==================================================================== */ /* Write data to the accumulator to fill it just under max size (but not full) */ - if(accum_write(0, (1024 * 1024) - 5, wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(0, (1024 * 1024) - 5, wbuf) < 0) + FAIL_STACK_ERROR; /* Flush the accumulator to clean it */ - if(accum_flush(f) < 0) FAIL_STACK_ERROR + if (accum_flush(f) < 0) + FAIL_STACK_ERROR - /* write to part of the accumulator so it's dirty, but not entirely dirty */ - /* (just the begging few bytes will be clean) */ - if(accum_write(10, (1024 * 1024) - 15, wbuf) < 0) FAIL_STACK_ERROR; + /* write to part of the accumulator so it's dirty, but not entirely dirty */ + /* (just the begging few bytes will be clean) */ + if (accum_write(10, (1024 * 1024) - 15, wbuf) < 0) + FAIL_STACK_ERROR; /* Write a small piece of data to the dirty end of the accumulator */ /* ==> Accumulator will need more buffer space */ @@ -1215,19 +1397,24 @@ test_accum_adjust(H5F_t *f) /* ==> We can slide the dirty region down, to accomodate the request */ /* ==> Max Buffer Size - (dirty offset + adjust size) < 2 * size) */ /* ==> Need to adjust location of accumulator while appending */ - if(accum_write((1024 * 1024) - 5, 10, wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write((1024 * 1024) - 5, 10, wbuf) < 0) + FAIL_STACK_ERROR; /* Write a piece of metadata outside current accumulator to force write to disk */ - if(accum_write(0, 1, wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(0, 1, wbuf) < 0) + FAIL_STACK_ERROR; /* Read in the piece we wrote to disk above, and then verify that the data is as expected */ - if(accum_read((1024 * 1024) - 5, 10, rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, (size_t)10) != 0) TEST_ERROR; + if (accum_read((1024 * 1024) - 5, 10, rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, (size_t)10) != 0) + TEST_ERROR; /* Reset accumulator for next case */ - if(accum_reset(f) < 0) FAIL_STACK_ERROR; + if (accum_reset(f) < 0) + FAIL_STACK_ERROR; /* ================================================================= */ /* Case 6: Appending small block to large, fully dirty accumulator */ @@ -1237,7 +1424,8 @@ test_accum_adjust(H5F_t *f) * but not quite full. This will force the accumulator to, on subsequent * writes, a) have to adjust since it's nearly full, and b) prevent * an increase in size because it's already at it's maximum size */ - if(accum_write(0, (1024 * 1024) - 5, wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(0, (1024 * 1024) - 5, wbuf) < 0) + FAIL_STACK_ERROR; /* Write a small (~340KB) piece of data to the end of the accumulator */ /* ==> Accumulator will need more buffer space */ @@ -1247,18 +1435,23 @@ test_accum_adjust(H5F_t *f) /* ==> We cannot slide dirty region down, it's all dirty */ /* ==> Dirty region overlaps region to eliminate from accumulator */ /* ==> Need to adjust location of accumulator while appending */ - if(accum_write(1048571, 349523, wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(1048571, 349523, wbuf) < 0) + FAIL_STACK_ERROR; /* Write a piece of metadata outside current accumulator to force write to disk */ - if(accum_write(1398900, 1, wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(1398900, 1, wbuf) < 0) + FAIL_STACK_ERROR; /* Read in the piece we wrote to disk above, and then verify that the data is as expected */ - if(accum_read(1048571, 349523, rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, (size_t)349523) != 0) TEST_ERROR; + if (accum_read(1048571, 349523, rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, (size_t)349523) != 0) + TEST_ERROR; - if(accum_reset(f) < 0) FAIL_STACK_ERROR; + if (accum_reset(f) < 0) + FAIL_STACK_ERROR; PASSED(); @@ -1276,7 +1469,6 @@ error: return 1; } /* test_accum_adjust */ - /*------------------------------------------------------------------------- * Function: test_read_after * @@ -1296,52 +1488,59 @@ error: *------------------------------------------------------------------------- */ unsigned -test_read_after(H5F_t *f) +test_read_after(H5F_t* f) { - int i = 0; - int s = 128; /* size of buffer */ - int32_t *wbuf, *rbuf; + int i = 0; + int s = 128; /* size of buffer */ + int32_t* wbuf, * rbuf; TESTING("reading data from both accumulator and disk"); /* Allocate buffers */ - wbuf = (int32_t *)HDmalloc((size_t)s * sizeof(int32_t)); + wbuf = (int32_t*)HDmalloc((size_t)s * sizeof(int32_t)); HDassert(wbuf); - rbuf = (int32_t *)HDcalloc((size_t)s, sizeof(int32_t)); + rbuf = (int32_t*)HDcalloc((size_t)s, sizeof(int32_t)); HDassert(rbuf); /* Fill up write buffer with 1s */ - for(i = 0; i < s; i++) + for (i = 0; i < s; i++) wbuf[i] = 1; /* Write data to the accumulator to fill it. */ - if(accum_write(512, 512, wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(512, 512, wbuf) < 0) + FAIL_STACK_ERROR; /* Write a piece of metadata outside current accumulator to force write to disk */ - if(accum_write(0, 1, wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(0, 1, wbuf) < 0) + FAIL_STACK_ERROR; /* Fill up write buffer with 2s */ - for(i = 0; i < s; i++) + for (i = 0; i < s; i++) wbuf[i] = 2; /* Write a block of 2s of the original size that will overlap the lower half of the original block */ - if(accum_write(256, 512, wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(256, 512, wbuf) < 0) + FAIL_STACK_ERROR; /* Read 128 bytes at the original address, and then */ - if(accum_read(512, 512, rbuf) < 0) FAIL_STACK_ERROR; + if (accum_read(512, 512, rbuf) < 0) + FAIL_STACK_ERROR; /* Set the second half of wbuf back to 1s */ - for(i = 64; i < s; i++) + for (i = 64; i < s; i++) wbuf[i] = 1; /* Read in the piece we wrote to disk above, and then verify that the data is as expected */ - if(accum_read(512, 512, rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf, rbuf, (size_t)128) != 0) TEST_ERROR; + if (accum_read(512, 512, rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf, rbuf, (size_t)128) != 0) + TEST_ERROR; - if(accum_reset(f) < 0) FAIL_STACK_ERROR; + if (accum_reset(f) < 0) + FAIL_STACK_ERROR; PASSED(); @@ -1359,7 +1558,6 @@ error: return 1; } /* end test_read_after */ - /*------------------------------------------------------------------------- * Function: test_big * @@ -1375,23 +1573,23 @@ error: *------------------------------------------------------------------------- */ unsigned -test_big(H5F_t *f) +test_big(H5F_t* f) { - uint8_t *wbuf, *wbuf2, *rbuf, *zbuf; /* Buffers for reading & writing, etc */ - unsigned u; /* Local index variable */ + uint8_t* wbuf, * wbuf2, * rbuf, * zbuf; /* Buffers for reading & writing, etc */ + unsigned u; /* Local index variable */ /* Allocate space for the write & read buffers */ - wbuf = (uint8_t *)HDmalloc((size_t)BIG_BUF_SIZE); + wbuf = (uint8_t*)HDmalloc((size_t)BIG_BUF_SIZE); HDassert(wbuf); - wbuf2 = (uint8_t *)HDmalloc((size_t)BIG_BUF_SIZE); + wbuf2 = (uint8_t*)HDmalloc((size_t)BIG_BUF_SIZE); HDassert(wbuf2); - rbuf = (uint8_t *)HDcalloc((size_t)(BIG_BUF_SIZE + 1536), (size_t)1); + rbuf = (uint8_t*)HDcalloc((size_t)(BIG_BUF_SIZE + 1536), (size_t)1); HDassert(rbuf); - zbuf = (uint8_t *)HDcalloc((size_t)(BIG_BUF_SIZE + 1536), (size_t)1); + zbuf = (uint8_t*)HDcalloc((size_t)(BIG_BUF_SIZE + 1536), (size_t)1); HDassert(zbuf); /* Initialize write buffers */ - for(u = 0; u < BIG_BUF_SIZE; u++) { + for (u = 0; u < BIG_BUF_SIZE; u++) { wbuf[u] = (uint8_t)u; wbuf2[u] = (uint8_t)(u + 1); } /* end for */ @@ -1399,254 +1597,312 @@ test_big(H5F_t *f) TESTING("large metadata I/O operations"); /* Write large data segment to file */ - if(accum_write(0, BIG_BUF_SIZE, wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(0, BIG_BUF_SIZE, wbuf) < 0) + FAIL_STACK_ERROR; /* Read entire segment back from file */ - if(accum_read(0, BIG_BUF_SIZE, rbuf) < 0) FAIL_STACK_ERROR; + if (accum_read(0, BIG_BUF_SIZE, rbuf) < 0) + FAIL_STACK_ERROR; /* Verify data read */ - if(HDmemcmp(wbuf, rbuf, (size_t)BIG_BUF_SIZE) != 0) TEST_ERROR; - + if (HDmemcmp(wbuf, rbuf, (size_t)BIG_BUF_SIZE) != 0) + TEST_ERROR; /* Reset data in file back to zeros & reset the read buffer */ - if(accum_write(0, BIG_BUF_SIZE, zbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(0, BIG_BUF_SIZE, zbuf) < 0) + FAIL_STACK_ERROR; HDmemset(rbuf, 0, (size_t)BIG_BUF_SIZE); - if(accum_reset(f) < 0) FAIL_STACK_ERROR; - + if (accum_reset(f) < 0) + FAIL_STACK_ERROR; /* Write small section to middle of accumulator */ - if(accum_write(1024, 1024, wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(1024, 1024, wbuf) < 0) + FAIL_STACK_ERROR; /* Read entire segment back from file */ /* (Read covers entire dirty region) */ - if(accum_read(0, BIG_BUF_SIZE, rbuf) < 0) FAIL_STACK_ERROR; + if (accum_read(0, BIG_BUF_SIZE, rbuf) < 0) + FAIL_STACK_ERROR; /* Verify data read */ - if(HDmemcmp(zbuf, rbuf, (size_t)1024) != 0) TEST_ERROR; - if(HDmemcmp(wbuf, rbuf + 1024, (size_t)1024) != 0) TEST_ERROR; - if(HDmemcmp(zbuf, rbuf + 2048, (size_t)(BIG_BUF_SIZE - 2048)) != 0) TEST_ERROR; - + if (HDmemcmp(zbuf, rbuf, (size_t)1024) != 0) + TEST_ERROR; + if (HDmemcmp(wbuf, rbuf + 1024, (size_t)1024) != 0) + TEST_ERROR; + if (HDmemcmp(zbuf, rbuf + 2048, (size_t)(BIG_BUF_SIZE - 2048)) != 0) + TEST_ERROR; /* Reset data in file back to zeros & reset the read buffer */ - if(accum_write(1024, 1024, zbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(1024, 1024, zbuf) < 0) + FAIL_STACK_ERROR; HDmemset(rbuf, 0, (size_t)BIG_BUF_SIZE); - if(accum_reset(f) < 0) FAIL_STACK_ERROR; - + if (accum_reset(f) < 0) + FAIL_STACK_ERROR; /* Write small section to overlap with end of "big" region */ - if(accum_write(BIG_BUF_SIZE - 512, 1024, wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(BIG_BUF_SIZE - 512, 1024, wbuf) < 0) + FAIL_STACK_ERROR; /* Read entire segment back from file */ /* (Read covers bottom half of dirty region) */ - if(accum_read(0, BIG_BUF_SIZE, rbuf) < 0) FAIL_STACK_ERROR; + if (accum_read(0, BIG_BUF_SIZE, rbuf) < 0) + FAIL_STACK_ERROR; /* Verify data read */ - if(HDmemcmp(zbuf, rbuf, (size_t)(BIG_BUF_SIZE - 512)) != 0) TEST_ERROR; - if(HDmemcmp(wbuf, rbuf + (BIG_BUF_SIZE - 512), (size_t)512) != 0) TEST_ERROR; - + if (HDmemcmp(zbuf, rbuf, (size_t)(BIG_BUF_SIZE - 512)) != 0) + TEST_ERROR; + if (HDmemcmp(wbuf, rbuf + (BIG_BUF_SIZE - 512), (size_t)512) != 0) + TEST_ERROR; /* Reset data in file back to zeros & reset the read buffer */ - if(accum_write(BIG_BUF_SIZE - 512, 1024, zbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(BIG_BUF_SIZE - 512, 1024, zbuf) < 0) + FAIL_STACK_ERROR; HDmemset(rbuf, 0, (size_t)BIG_BUF_SIZE); - if(accum_reset(f) < 0) FAIL_STACK_ERROR; - + if (accum_reset(f) < 0) + FAIL_STACK_ERROR; /* Write small section to overlap with beginning of "big" region */ - if(accum_write(0, 1024, wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(0, 1024, wbuf) < 0) + FAIL_STACK_ERROR; /* Read entire segment back from file */ /* (Read covers bottom half of dirty region) */ - if(accum_read(512, BIG_BUF_SIZE, rbuf) < 0) FAIL_STACK_ERROR; + if (accum_read(512, BIG_BUF_SIZE, rbuf) < 0) + FAIL_STACK_ERROR; /* Verify data read */ - if(HDmemcmp(wbuf + 512, rbuf, (size_t)512) != 0) TEST_ERROR; - if(HDmemcmp(zbuf, rbuf + 512, (size_t)(BIG_BUF_SIZE - 512)) != 0) TEST_ERROR; - + if (HDmemcmp(wbuf + 512, rbuf, (size_t)512) != 0) + TEST_ERROR; + if (HDmemcmp(zbuf, rbuf + 512, (size_t)(BIG_BUF_SIZE - 512)) != 0) + TEST_ERROR; /* Reset data in file back to zeros & reset the read buffer */ - if(accum_write(0, 1024, zbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(0, 1024, zbuf) < 0) + FAIL_STACK_ERROR; HDmemset(rbuf, 0, (size_t)BIG_BUF_SIZE); - if(accum_reset(f) < 0) FAIL_STACK_ERROR; - + if (accum_reset(f) < 0) + FAIL_STACK_ERROR; /* Write small section to middle of accumulator */ /* (With write buffer #1) */ - if(accum_write(1024, 1024, wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(1024, 1024, wbuf) < 0) + FAIL_STACK_ERROR; /* Write entire segment to from file */ /* (With write buffer #2) */ /* (Write covers entire dirty region) */ - if(accum_write(0, BIG_BUF_SIZE, wbuf2) < 0) FAIL_STACK_ERROR; + if (accum_write(0, BIG_BUF_SIZE, wbuf2) < 0) + FAIL_STACK_ERROR; /* Read entire segment back from file */ - if(accum_read(0, BIG_BUF_SIZE, rbuf) < 0) FAIL_STACK_ERROR; + if (accum_read(0, BIG_BUF_SIZE, rbuf) < 0) + FAIL_STACK_ERROR; /* Verify data read */ - if(HDmemcmp(wbuf2, rbuf, (size_t)BIG_BUF_SIZE) != 0) TEST_ERROR; - + if (HDmemcmp(wbuf2, rbuf, (size_t)BIG_BUF_SIZE) != 0) + TEST_ERROR; /* Reset data in file back to zeros & reset the read buffer */ - if(accum_write(0, BIG_BUF_SIZE, zbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(0, BIG_BUF_SIZE, zbuf) < 0) + FAIL_STACK_ERROR; HDmemset(rbuf, 0, (size_t)BIG_BUF_SIZE); - if(accum_reset(f) < 0) FAIL_STACK_ERROR; - + if (accum_reset(f) < 0) + FAIL_STACK_ERROR; /* Write small section to overlap with end of "big" region */ /* (With write buffer #1) */ - if(accum_write(BIG_BUF_SIZE - 512, 1024, wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(BIG_BUF_SIZE - 512, 1024, wbuf) < 0) + FAIL_STACK_ERROR; /* Write entire segment to from file */ /* (With write buffer #2) */ /* (Read covers bottom half of dirty region) */ - if(accum_write(0, BIG_BUF_SIZE, wbuf2) < 0) FAIL_STACK_ERROR; + if (accum_write(0, BIG_BUF_SIZE, wbuf2) < 0) + FAIL_STACK_ERROR; /* Read both segments back from file */ - if(accum_read(0, BIG_BUF_SIZE + 512, rbuf) < 0) FAIL_STACK_ERROR; + if (accum_read(0, BIG_BUF_SIZE + 512, rbuf) < 0) + FAIL_STACK_ERROR; /* Verify data read */ - if(HDmemcmp(wbuf2, rbuf, (size_t)BIG_BUF_SIZE) != 0) TEST_ERROR; - if(HDmemcmp(wbuf + 512, rbuf + BIG_BUF_SIZE, (size_t)512) != 0) TEST_ERROR; - + if (HDmemcmp(wbuf2, rbuf, (size_t)BIG_BUF_SIZE) != 0) + TEST_ERROR; + if (HDmemcmp(wbuf + 512, rbuf + BIG_BUF_SIZE, (size_t)512) != 0) + TEST_ERROR; /* Reset data in file back to zeros & reset the read buffer */ - if(accum_write(0, BIG_BUF_SIZE + 512, zbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(0, BIG_BUF_SIZE + 512, zbuf) < 0) + FAIL_STACK_ERROR; HDmemset(rbuf, 0, (size_t)(BIG_BUF_SIZE + 512)); - if(accum_reset(f) < 0) FAIL_STACK_ERROR; - + if (accum_reset(f) < 0) + FAIL_STACK_ERROR; /* Write small section to be past "big" region */ /* (With write buffer #1) */ - if(accum_write(BIG_BUF_SIZE + 512, 1024, wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(BIG_BUF_SIZE + 512, 1024, wbuf) < 0) + FAIL_STACK_ERROR; /* Read section before "big" region */ /* (To enlarge accumulator, to it will intersect with big write) */ - if(accum_read(BIG_BUF_SIZE - 512, 1024, rbuf) < 0) FAIL_STACK_ERROR; + if (accum_read(BIG_BUF_SIZE - 512, 1024, rbuf) < 0) + FAIL_STACK_ERROR; /* Write entire segment to from file */ /* (With write buffer #2) */ /* (Doesn't overlap with small section) */ - if(accum_write(0, BIG_BUF_SIZE, wbuf2) < 0) FAIL_STACK_ERROR; + if (accum_write(0, BIG_BUF_SIZE, wbuf2) < 0) + FAIL_STACK_ERROR; /* Read both segments & gap back from file */ - if(accum_read(0, BIG_BUF_SIZE + 1024, rbuf) < 0) FAIL_STACK_ERROR; + if (accum_read(0, BIG_BUF_SIZE + 1024, rbuf) < 0) + FAIL_STACK_ERROR; /* Verify data read */ - if(HDmemcmp(wbuf2, rbuf, (size_t)BIG_BUF_SIZE) != 0) TEST_ERROR; - if(HDmemcmp(zbuf, rbuf + BIG_BUF_SIZE, (size_t)512) != 0) TEST_ERROR; - if(HDmemcmp(wbuf, rbuf + BIG_BUF_SIZE + 512, (size_t)512) != 0) TEST_ERROR; - + if (HDmemcmp(wbuf2, rbuf, (size_t)BIG_BUF_SIZE) != 0) + TEST_ERROR; + if (HDmemcmp(zbuf, rbuf + BIG_BUF_SIZE, (size_t)512) != 0) + TEST_ERROR; + if (HDmemcmp(wbuf, rbuf + BIG_BUF_SIZE + 512, (size_t)512) != 0) + TEST_ERROR; /* Reset data in file back to zeros & reset the read buffer */ - if(accum_write(0, BIG_BUF_SIZE + 1536, zbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(0, BIG_BUF_SIZE + 1536, zbuf) < 0) + FAIL_STACK_ERROR; HDmemset(rbuf, 0, (size_t)(BIG_BUF_SIZE + 1024)); - if(accum_reset(f) < 0) FAIL_STACK_ERROR; - + if (accum_reset(f) < 0) + FAIL_STACK_ERROR; /* Write small section to be past "big" region */ /* (With write buffer #1) */ - if(accum_write(BIG_BUF_SIZE + 512, 1024, wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(BIG_BUF_SIZE + 512, 1024, wbuf) < 0) + FAIL_STACK_ERROR; /* Read section before "big" region */ /* (To enlarge accumulator, so it will intersect with big write) */ - if(accum_read(BIG_BUF_SIZE - 512, 1024, rbuf) < 0) FAIL_STACK_ERROR; - if(accum_read(BIG_BUF_SIZE + 1536, 1024, rbuf) < 0) FAIL_STACK_ERROR; + if (accum_read(BIG_BUF_SIZE - 512, 1024, rbuf) < 0) + FAIL_STACK_ERROR; + if (accum_read(BIG_BUF_SIZE + 1536, 1024, rbuf) < 0) + FAIL_STACK_ERROR; /* Write entire segment to from file */ /* (With write buffer #2) */ /* (Overwriting dirty region, but not invalidating entire accumulator) */ - if(accum_write(1536, BIG_BUF_SIZE, wbuf2) < 0) FAIL_STACK_ERROR; + if (accum_write(1536, BIG_BUF_SIZE, wbuf2) < 0) + FAIL_STACK_ERROR; /* Read both segments & gap back from file */ - if(accum_read(0, BIG_BUF_SIZE + 1536, rbuf) < 0) FAIL_STACK_ERROR; + if (accum_read(0, BIG_BUF_SIZE + 1536, rbuf) < 0) + FAIL_STACK_ERROR; /* Verify data read */ - if(HDmemcmp(zbuf, rbuf, (size_t)1536) != 0) TEST_ERROR; - if(HDmemcmp(wbuf2, rbuf + 1536, (size_t)BIG_BUF_SIZE) != 0) TEST_ERROR; - + if (HDmemcmp(zbuf, rbuf, (size_t)1536) != 0) + TEST_ERROR; + if (HDmemcmp(wbuf2, rbuf + 1536, (size_t)BIG_BUF_SIZE) != 0) + TEST_ERROR; /* Reset data in file back to zeros & reset the read buffer */ - if(accum_write(1536, BIG_BUF_SIZE, zbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(1536, BIG_BUF_SIZE, zbuf) < 0) + FAIL_STACK_ERROR; HDmemset(rbuf, 0, (size_t)(BIG_BUF_SIZE + 1536)); - if(accum_reset(f) < 0) FAIL_STACK_ERROR; - + if (accum_reset(f) < 0) + FAIL_STACK_ERROR; /* Write small section before "big" region */ /* (With write buffer #1) */ - if(accum_write(1024, 1024, wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(1024, 1024, wbuf) < 0) + FAIL_STACK_ERROR; /* Read section before "big" region */ /* (To enlarge accumulator, so it will intersect with big write) */ - if(accum_read(0, 1024, rbuf) < 0) FAIL_STACK_ERROR; + if (accum_read(0, 1024, rbuf) < 0) + FAIL_STACK_ERROR; /* Write entire segment to from file */ /* (With write buffer #2) */ /* (Overwriting dirty region, but not invalidating entire accumulator) */ - if(accum_write(512, BIG_BUF_SIZE, wbuf2) < 0) FAIL_STACK_ERROR; + if (accum_write(512, BIG_BUF_SIZE, wbuf2) < 0) + FAIL_STACK_ERROR; /* Read both segments & gap back from file */ - if(accum_read(0, BIG_BUF_SIZE + 512, rbuf) < 0) FAIL_STACK_ERROR; + if (accum_read(0, BIG_BUF_SIZE + 512, rbuf) < 0) + FAIL_STACK_ERROR; /* Verify data read */ - if(HDmemcmp(zbuf, rbuf, (size_t)512) != 0) TEST_ERROR; - if(HDmemcmp(wbuf2, rbuf + 512, (size_t)BIG_BUF_SIZE) != 0) TEST_ERROR; - + if (HDmemcmp(zbuf, rbuf, (size_t)512) != 0) + TEST_ERROR; + if (HDmemcmp(wbuf2, rbuf + 512, (size_t)BIG_BUF_SIZE) != 0) + TEST_ERROR; /* Reset data in file back to zeros & reset the read buffer */ - if(accum_write(512, BIG_BUF_SIZE, zbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(512, BIG_BUF_SIZE, zbuf) < 0) + FAIL_STACK_ERROR; HDmemset(rbuf, 0, (size_t)(BIG_BUF_SIZE + 512)); - if(accum_reset(f) < 0) FAIL_STACK_ERROR; - + if (accum_reset(f) < 0) + FAIL_STACK_ERROR; /* Write small section before "big" region */ /* (With write buffer #1) */ - if(accum_write(0, 1024, wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(0, 1024, wbuf) < 0) + FAIL_STACK_ERROR; /* Read section before "big" region */ /* (To enlarge accumulator, so it will intersect with big write) */ - if(accum_read(1024, 1024, rbuf) < 0) FAIL_STACK_ERROR; + if (accum_read(1024, 1024, rbuf) < 0) + FAIL_STACK_ERROR; /* Write entire segment to from file */ /* (With write buffer #2) */ /* (Avoiding dirty region, and not invalidating entire accumulator) */ - if(accum_write(1536, BIG_BUF_SIZE, wbuf2) < 0) FAIL_STACK_ERROR; + if (accum_write(1536, BIG_BUF_SIZE, wbuf2) < 0) + FAIL_STACK_ERROR; /* Read both segments & gap back from file */ - if(accum_read(0, BIG_BUF_SIZE + 1536, rbuf) < 0) FAIL_STACK_ERROR; + if (accum_read(0, BIG_BUF_SIZE + 1536, rbuf) < 0) + FAIL_STACK_ERROR; /* Verify data read */ - if(HDmemcmp(wbuf, rbuf, (size_t)1024) != 0) TEST_ERROR; - if(HDmemcmp(zbuf, rbuf + 1024, (size_t)512) != 0) TEST_ERROR; - if(HDmemcmp(wbuf2, rbuf + 1536, (size_t)BIG_BUF_SIZE) != 0) TEST_ERROR; - + if (HDmemcmp(wbuf, rbuf, (size_t)1024) != 0) + TEST_ERROR; + if (HDmemcmp(zbuf, rbuf + 1024, (size_t)512) != 0) + TEST_ERROR; + if (HDmemcmp(wbuf2, rbuf + 1536, (size_t)BIG_BUF_SIZE) != 0) + TEST_ERROR; /* Reset data in file back to zeros & reset the read buffer */ - if(accum_write(0, BIG_BUF_SIZE + 1536, zbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(0, BIG_BUF_SIZE + 1536, zbuf) < 0) + FAIL_STACK_ERROR; HDmemset(rbuf, 0, (size_t)(BIG_BUF_SIZE + 1536)); - if(accum_reset(f) < 0) FAIL_STACK_ERROR; - + if (accum_reset(f) < 0) + FAIL_STACK_ERROR; /* Write small section before "big" region */ /* (With write buffer #1) */ - if(accum_write(0, 1024, wbuf) < 0) FAIL_STACK_ERROR; + if (accum_write(0, 1024, wbuf) < 0) + FAIL_STACK_ERROR; /* Read section before "big" region */ /* (To enlarge accumulator, so it will intersect with big write) */ - if(accum_read(1024, 1024, rbuf) < 0) FAIL_STACK_ERROR; + if (accum_read(1024, 1024, rbuf) < 0) + FAIL_STACK_ERROR; /* Write entire segment to from file */ /* (With write buffer #2) */ /* (Partially overwriting dirty region, and not invalidating entire accumulator) */ - if(accum_write(512, BIG_BUF_SIZE, wbuf2) < 0) FAIL_STACK_ERROR; + if (accum_write(512, BIG_BUF_SIZE, wbuf2) < 0) + FAIL_STACK_ERROR; /* Read both segments back from file */ - if(accum_read(0, BIG_BUF_SIZE + 512, rbuf) < 0) FAIL_STACK_ERROR; + if (accum_read(0, BIG_BUF_SIZE + 512, rbuf) < 0) + FAIL_STACK_ERROR; /* Verify data read */ - if(HDmemcmp(wbuf, rbuf, (size_t)512) != 0) TEST_ERROR; - if(HDmemcmp(wbuf2, rbuf + 512, (size_t)BIG_BUF_SIZE) != 0) TEST_ERROR; - + if (HDmemcmp(wbuf, rbuf, (size_t)512) != 0) + TEST_ERROR; + if (HDmemcmp(wbuf2, rbuf + 512, (size_t)BIG_BUF_SIZE) != 0) + TEST_ERROR; - if(accum_reset(f) < 0) FAIL_STACK_ERROR; + if (accum_reset(f) < 0) + FAIL_STACK_ERROR; PASSED(); @@ -1667,7 +1923,6 @@ error: return 1; } /* end test_big() */ - /*------------------------------------------------------------------------- * Function: test_random_write * @@ -1683,55 +1938,55 @@ error: *------------------------------------------------------------------------- */ unsigned -test_random_write(H5F_t *f) +test_random_write(H5F_t* f) { - uint8_t *wbuf, *rbuf; /* Buffers for reading & writing */ - unsigned seed = 0; /* Random # seed */ - size_t *off; /* Offset of buffer segments to write */ - size_t *len; /* Size of buffer segments to write */ - size_t cur_off; /* Current offset */ - size_t nsegments; /* Number of segments to write */ - size_t swap; /* Position to swap with */ - unsigned u; /* Local index variable */ + uint8_t* wbuf, * rbuf; /* Buffers for reading & writing */ + unsigned seed = 0; /* Random # seed */ + size_t* off; /* Offset of buffer segments to write */ + size_t* len; /* Size of buffer segments to write */ + size_t cur_off; /* Current offset */ + size_t nsegments; /* Number of segments to write */ + size_t swap; /* Position to swap with */ + unsigned u; /* Local index variable */ /* Allocate space for the write & read buffers */ - wbuf = (uint8_t *)HDmalloc((size_t)RANDOM_BUF_SIZE); + wbuf = (uint8_t*)HDmalloc((size_t)RANDOM_BUF_SIZE); HDassert(wbuf); - rbuf = (uint8_t *)HDcalloc((size_t)RANDOM_BUF_SIZE, (size_t)1); + rbuf = (uint8_t*)HDcalloc((size_t)RANDOM_BUF_SIZE, (size_t)1); HDassert(rbuf); /* Initialize write buffer */ - for(u = 0; u < RANDOM_BUF_SIZE; u++) + for (u = 0; u < RANDOM_BUF_SIZE; u++) wbuf[u] = (uint8_t)u; TESTING("random writes to accumulator"); /* Choose random # seed */ seed = (unsigned)HDtime(NULL); -#ifdef QAK -/* seed = (unsigned)1155438845; */ -HDfprintf(stderr, "Random # seed was: %u\n", seed); -#endif /* QAK */ +#if 0 + /* seed = (unsigned)1155438845; */ + HDfprintf(stderr, "Random # seed was: %u\n", seed); +#endif HDsrandom(seed); /* Allocate space for the segment length buffer */ - off = (size_t *)HDmalloc(MAX_RANDOM_SEGMENTS * sizeof(size_t)); + off = (size_t*)HDmalloc(MAX_RANDOM_SEGMENTS * sizeof(size_t)); HDassert(off); - len = (size_t *)HDmalloc(MAX_RANDOM_SEGMENTS * sizeof(size_t)); + len = (size_t*)HDmalloc(MAX_RANDOM_SEGMENTS * sizeof(size_t)); HDassert(len); /* Randomly choose lengths of segments */ cur_off = 0; - for(u = 0; u < MAX_RANDOM_SEGMENTS; ) { - size_t length = 0; /* Length of current segment */ + for (u = 0; u < MAX_RANDOM_SEGMENTS;) { + size_t length = 0; /* Length of current segment */ /* Choose random length of segment, allowing for variance */ do { length += (size_t)(HDrandom() % RAND_SEG_LEN) + 1; - } while((HDrandom() & 256) >= 128); /* end while */ + } while ((HDrandom() & 256) >= 128); /* end while */ /* Check for going off end of buffer */ - if((cur_off + length) > RANDOM_BUF_SIZE) + if ((cur_off + length) > RANDOM_BUF_SIZE) length = RANDOM_BUF_SIZE - cur_off; /* Set offset & length of segment */ @@ -1745,45 +2000,55 @@ HDfprintf(stderr, "Random # seed was: %u\n", seed); cur_off += length; /* If we've used up entire buffer before hitting limit of segments, get out */ - if(cur_off >= RANDOM_BUF_SIZE) + if (cur_off >= RANDOM_BUF_SIZE) break; } /* end for */ nsegments = u; /* Increase length of last segment, if it doesn't reach end of buffer */ - if(nsegments < MAX_RANDOM_SEGMENTS) + if (nsegments < MAX_RANDOM_SEGMENTS) len[nsegments - 1] = RANDOM_BUF_SIZE - off[nsegments - 1]; /* Shuffle order of segments, to randomize positions to write */ - for(u = 0; u < nsegments; u++) { - size_t tmp; /* Temporary holder for offset & length values */ + for (u = 0; u < nsegments; u++) { + size_t tmp; /* Temporary holder for offset & length values */ /* Choose value within next few elements to to swap with */ swap = ((size_t)HDrandom() % 8) + u; - if(swap >= nsegments) + if (swap >= nsegments) swap = nsegments - 1; /* Swap values */ - tmp = off[u]; off[u] = off[swap]; off[swap] = tmp; - tmp = len[u]; len[u] = len[swap]; len[swap] = tmp; + tmp = off[u]; + off[u] = off[swap]; + off[swap] = tmp; + tmp = len[u]; + len[u] = len[swap]; + len[swap] = tmp; } /* end for */ /* Write data segments to file */ - for(u = 0; u < nsegments; u++) { - if(accum_write(RANDOM_BASE_OFF + off[u], len[u], wbuf + off[u]) < 0) FAIL_STACK_ERROR; + for (u = 0; u < nsegments; u++) { + if (accum_write(RANDOM_BASE_OFF + off[u], len[u], wbuf + off[u]) < 0) + FAIL_STACK_ERROR; /* Verify individual reads */ - if(accum_read(RANDOM_BASE_OFF + off[u], len[u], rbuf) < 0) FAIL_STACK_ERROR; - if(HDmemcmp(wbuf + off[u], rbuf, len[u]) != 0) TEST_ERROR; + if (accum_read(RANDOM_BASE_OFF + off[u], len[u], rbuf) < 0) + FAIL_STACK_ERROR; + if (HDmemcmp(wbuf + off[u], rbuf, len[u]) != 0) + TEST_ERROR; } /* end for */ /* Read entire region back from file */ - if(accum_read(RANDOM_BASE_OFF, RANDOM_BUF_SIZE, rbuf) < 0) FAIL_STACK_ERROR; + if (accum_read(RANDOM_BASE_OFF, RANDOM_BUF_SIZE, rbuf) < 0) + FAIL_STACK_ERROR; /* Verify data read back in */ - if(HDmemcmp(wbuf, rbuf, (size_t)RANDOM_BUF_SIZE) != 0) TEST_ERROR; + if (HDmemcmp(wbuf, rbuf, (size_t)RANDOM_BUF_SIZE) != 0) + TEST_ERROR; - if(accum_reset(f) < 0) FAIL_STACK_ERROR; + if (accum_reset(f) < 0) + FAIL_STACK_ERROR; PASSED(); @@ -1809,13 +2074,14 @@ error: /*------------------------------------------------------------------------- * Function: test_swmr_write_big * - * Purpose: A SWMR test: verifies that writing "large" metadata to a file - * opened with SWMR_WRITE will flush the existing metadata in the - * accumulator to disk first before writing the "large" metadata - * to disk. - * This test will fork and exec a reader "accum_swmr_reader" which - * opens the same file with SWMR_READ and verifies that the correct - * metadata is read from disk. + * Purpose: A SWMR test: verifies that writing "large" metadata to a file + * opened with SWMR_WRITE will flush the existing metadata in the + * accumulator to disk first before writing the "large" metadata + * to disk. + * + * This test will fork and exec a reader "accum_swmr_reader" which + * opens the same file with SWMR_READ and verifies that the correct + * metadata is read from disk. * * Return: Success: 0 * Failure: 1 @@ -1827,211 +2093,250 @@ error: unsigned test_swmr_write_big(hbool_t newest_format) { - hid_t fid = -1; /* File ID */ - hid_t fapl = -1; /* File access property list */ - H5F_t *rf = NULL; /* File pointer */ - char filename[1024]; - uint8_t *wbuf2 = NULL, *rbuf = NULL; /* Buffers for reading & writing */ - uint8_t wbuf[1024]; /* Buffer for reading & writing */ - unsigned u; /* Local index variable */ -#ifdef H5_HAVE_UNISTD_H - pid_t pid; /* Process ID */ -#endif /* H5_HAVE_UNISTD_H */ - int status; /* Status returned from child process */ - char *driver = NULL; /* VFD string (from env variable) */ - hbool_t api_ctx_pushed = FALSE; /* Whether API context pushed */ - - if(newest_format) + + hid_t fid = -1; /* File ID */ + hid_t fapl = -1; /* File access property list */ + H5F_t* rf = NULL; /* File pointer */ + char filename[1024]; + uint8_t* wbuf2 = NULL, * rbuf = NULL; /* Buffers for reading & writing */ + uint8_t wbuf[1024]; /* Buffer for reading & writing */ + unsigned u; /* Local index variable */ + hbool_t process_success = FALSE; + char* driver = NULL; /* VFD string (from env variable) */ + hbool_t api_ctx_pushed = FALSE; /* Whether API context pushed */ + + if (newest_format) TESTING("SWMR write of large metadata: with latest format") else TESTING("SWMR write of large metadata: with non-latest-format") -#if !(defined(H5_HAVE_FORK) && defined(H5_HAVE_WAITPID)) +#if !defined(H5_HAVE_UNISTD_H) && !defined(H5_HAVE_WIN32_API) - SKIPPED(); - HDputs(" Test skipped due to fork or waitpid not defined."); + /* Not a Windows or POSIX system */ + SKIPPED(); + HDputs(" Test skipped: Not a Windows or POSIX system."); return 0; -#else /* defined(H5_HAVE_FORK && defined(H5_HAVE_WAITPID) */ - - /* Skip this test if SWMR I/O is not supported for the VFD specified - * by the environment variable. - */ - driver = HDgetenv("HDF5_DRIVER"); - if(!H5FD__supports_swmr_test(driver)) { +#else + /* Skip this test if SWMR I/O is not supported for the VFD specified + * by the environment variable. + */ + driver = HDgetenv("HDF5_DRIVER"); + if (!H5FD__supports_swmr_test(driver)) { SKIPPED(); HDputs(" Test skipped due to VFD not supporting SWMR I/O."); return 0; } /* File access property list */ - if((fapl = h5_fileaccess()) < 0) + if ((fapl = h5_fileaccess()) < 0) FAIL_STACK_ERROR - h5_fixname(FILENAME[1], fapl, filename, sizeof filename); + h5_fixname(FILENAME[1], fapl, filename, sizeof filename); /* Both cases will result in v3 superblock and version 2 object header for SWMR */ - if(newest_format) { /* latest format */ - if(H5Pset_libver_bounds(fapl, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST) < 0) + if (newest_format) { /* latest format */ + if (H5Pset_libver_bounds(fapl, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST) < 0) FAIL_STACK_ERROR - if((fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0) - FAIL_STACK_ERROR + if ((fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0) + FAIL_STACK_ERROR } else { /* non-latest-format */ - if((fid = H5Fcreate(filename, H5F_ACC_TRUNC|H5F_ACC_SWMR_WRITE, H5P_DEFAULT, fapl)) < 0) + if ((fid = H5Fcreate(filename, H5F_ACC_TRUNC | H5F_ACC_SWMR_WRITE, H5P_DEFAULT, fapl)) < 0) FAIL_STACK_ERROR } /* end if */ /* Close the file */ - if(H5Fclose(fid) < 0) + if (H5Fclose(fid) < 0) FAIL_STACK_ERROR - /* Open the file with SWMR_WRITE */ - if((fid = H5Fopen(filename, H5F_ACC_RDWR | H5F_ACC_SWMR_WRITE, fapl)) < 0) - FAIL_STACK_ERROR + /* Open the file with SWMR_WRITE */ + if ((fid = H5Fopen(filename, H5F_ACC_RDWR | H5F_ACC_SWMR_WRITE, fapl)) < 0) + FAIL_STACK_ERROR - /* Push API context */ - if(H5CX_push() < 0) FAIL_STACK_ERROR - api_ctx_pushed = TRUE; + /* Push API context */ + if (H5CX_push() < 0) + FAIL_STACK_ERROR + api_ctx_pushed = TRUE; /* Get H5F_t * to internal file structure */ - if(NULL == (rf = (H5F_t *)H5VL_object(fid))) FAIL_STACK_ERROR - - /* We'll be writing lots of garbage data, so extend the - file a ways. 10MB should do. */ - if(H5FD_set_eoa(rf->shared->lf, H5FD_MEM_DEFAULT, (haddr_t)(1024*1024*10)) < 0) + if (NULL == (rf = (H5F_t*)H5VL_object(fid))) FAIL_STACK_ERROR - if(H5Fflush(fid, H5F_SCOPE_GLOBAL) < 0) - FAIL_STACK_ERROR; + /* We'll be writing lots of garbage data, so extend the + file a ways. 10MB should do. */ + if (H5FD_set_eoa(rf->shared->lf, H5FD_MEM_DEFAULT, (haddr_t)(1024 * 1024 * 10)) < 0) + FAIL_STACK_ERROR + + if (H5Fflush(fid, H5F_SCOPE_GLOBAL) < 0) + FAIL_STACK_ERROR; /* Reset metadata accumulator for the file */ - if(accum_reset(rf) < 0) + if (accum_reset(rf) < 0) FAIL_STACK_ERROR; /* Allocate space for the write & read buffers */ - if((wbuf2 = (uint8_t *)HDmalloc((size_t)BIG_BUF_SIZE)) == NULL) - FAIL_STACK_ERROR; - if((rbuf = (uint8_t *)HDmalloc((size_t)BIG_BUF_SIZE)) == NULL) - FAIL_STACK_ERROR; + if ((wbuf2 = (uint8_t*)HDmalloc((size_t)BIG_BUF_SIZE)) == NULL) + FAIL_STACK_ERROR; + if ((rbuf = (uint8_t*)HDmalloc((size_t)BIG_BUF_SIZE)) == NULL) + FAIL_STACK_ERROR; /* Initialize wbuf with "0, 1, 2...1024"*/ - for(u = 0; u < 1024; u++) + for (u = 0; u < 1024; u++) wbuf[u] = (uint8_t)u; /* Write [1024, 1024] bytes with wbuf */ - if(H5F_block_write(rf, H5FD_MEM_DEFAULT, (haddr_t)1024, (size_t)1024, wbuf) < 0) - FAIL_STACK_ERROR; + if (H5F_block_write(rf, H5FD_MEM_DEFAULT, (haddr_t)1024, (size_t)1024, wbuf) < 0) + FAIL_STACK_ERROR; /* Read the data */ - if(H5F_block_read(rf, H5FD_MEM_DEFAULT, (haddr_t)1024, (size_t)1024, rbuf) < 0) - FAIL_STACK_ERROR; + if (H5F_block_read(rf, H5FD_MEM_DEFAULT, (haddr_t)1024, (size_t)1024, rbuf) < 0) + FAIL_STACK_ERROR; /* Verify the data read is correct */ - if(HDmemcmp(wbuf, rbuf, (size_t)1024) != 0) + if (HDmemcmp(wbuf, rbuf, (size_t)1024) != 0) TEST_ERROR; /* Flush the data to disk */ - if(accum_reset(rf) < 0) + if (accum_reset(rf) < 0) FAIL_STACK_ERROR; /* Initialize wbuf with all 1s */ - for(u = 0; u < 1024; u++) + for (u = 0; u < 1024; u++) wbuf[u] = (uint8_t)1; /* Initialize wbuf2 */ - for(u = 0; u < BIG_BUF_SIZE; u++) + for (u = 0; u < BIG_BUF_SIZE; u++) wbuf2[u] = (uint8_t)(u + 1); /* Write [1024,1024] with wbuf--all 1s */ - if(H5F_block_write(rf, H5FD_MEM_DEFAULT, (haddr_t)1024, (size_t)1024, wbuf) < 0) - FAIL_STACK_ERROR; + if (H5F_block_write(rf, H5FD_MEM_DEFAULT, (haddr_t)1024, (size_t)1024, wbuf) < 0) + FAIL_STACK_ERROR; /* Read the data */ - if(H5F_block_read(rf, H5FD_MEM_DEFAULT, (haddr_t)1024, (size_t)1024, rbuf) < 0) - FAIL_STACK_ERROR; + if (H5F_block_read(rf, H5FD_MEM_DEFAULT, (haddr_t)1024, (size_t)1024, rbuf) < 0) + FAIL_STACK_ERROR; /* Verify the data read is correct */ - if(HDmemcmp(wbuf, rbuf, (size_t)1024) != 0) + if (HDmemcmp(wbuf, rbuf, (size_t)1024) != 0) TEST_ERROR; /* The data stays in the accumulator */ /* Write a large piece of metadata [2048, BIG_BUF_SIZE] with wbuf2 */ - if(H5F_block_write(rf, H5FD_MEM_DEFAULT, (haddr_t)2048, (size_t)BIG_BUF_SIZE, wbuf2) < 0) - FAIL_STACK_ERROR; + if (H5F_block_write(rf, H5FD_MEM_DEFAULT, (haddr_t)2048, (size_t)BIG_BUF_SIZE, wbuf2) < 0) + FAIL_STACK_ERROR; /* Read the data */ - if(H5F_block_read(rf, H5FD_MEM_DEFAULT, (haddr_t)2048, (size_t)BIG_BUF_SIZE, rbuf) < 0) - FAIL_STACK_ERROR; + if (H5F_block_read(rf, H5FD_MEM_DEFAULT, (haddr_t)2048, (size_t)BIG_BUF_SIZE, rbuf) < 0) + FAIL_STACK_ERROR; /* Verify the data read is correct */ - if(HDmemcmp(wbuf2, rbuf, (size_t)BIG_BUF_SIZE) != 0) + if (HDmemcmp(wbuf2, rbuf, (size_t)BIG_BUF_SIZE) != 0) TEST_ERROR; - /* Fork child process to verify that the data at [1024, 2014] does get written to disk */ - if((pid = HDfork()) < 0) { - HDperror("fork"); - FAIL_STACK_ERROR; - } - else if(0 == pid) { /* Child process */ - /* By convention, argv[0] tells the name of program invoked. - * - * execv on NetBSD 8 will actually return EFAULT if there is a - * NULL at argv[0], so we follow the convention unconditionally. - */ - char swmr_reader[] = SWMR_READER; - char * const new_argv[] = {swmr_reader, NULL}; - /* Run the reader */ - status = HDexecv(SWMR_READER, new_argv); - HDprintf("errno from execv = %s\n", strerror(errno)); - FAIL_STACK_ERROR; - } /* end if */ +#if defined(H5_HAVE_WIN32_API) + { + STARTUPINFO si; + PROCESS_INFORMATION pi; + DWORD exit_code = EXIT_FAILURE; - /* Parent process -- wait for the child process to complete */ - while(pid != HDwaitpid(pid, &status, 0)) - /*void*/; + ZeroMemory(&si, sizeof(si)); + si.cb = sizeof(si); + ZeroMemory(&pi, sizeof(pi)); - /* Check if child process terminates normally and its return value */ - if(WIFEXITED(status) && !WEXITSTATUS(status)) { - /* Flush the accumulator */ - if(accum_reset(rf) < 0) + if (0 == CreateProcess(NULL, SWMR_READER, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) { + HDprintf("CreateProcess failed (%d).\n", GetLastError()); FAIL_STACK_ERROR; + } + + (void)WaitForSingleObject(pi.hProcess, INFINITE); + + if (FALSE == GetExitCodeProcess(pi.hProcess, &exit_code) || EXIT_FAILURE == exit_code) + process_success = FALSE; + else + process_success = TRUE; - /* Close and remove the file */ - if(H5Fclose(fid) < 0) + CloseHandle(pi.hProcess); + CloseHandle(pi.hThread); + } +#else /* defined(H5_HAVE_WIN32_API) */ + { + pid_t pid; /* Process ID */ + int status; /* Status returned from child process */ + + /* Fork child process to verify that the data at [1024, 2014] does get written to disk */ + if ((pid = HDfork()) < 0) { + HDperror("fork"); + FAIL_STACK_ERROR; + } + else if (0 == pid) { /* Child process */ + /* By convention, argv[0] tells the name of program invoked. + * + * execv on NetBSD 8 will actually return EFAULT if there is a + * NULL at argv[0], so we follow the convention unconditionally. + */ + char swmr_reader[] = SWMR_READER; + char* const new_argv[] = { swmr_reader, NULL }; + /* Run the reader */ + status = HDexecv(SWMR_READER, new_argv); + HDprintf("errno from execv = %s\n", HDstrerror(errno)); FAIL_STACK_ERROR; + } /* end if */ + + /* Parent process -- wait for the child process to complete */ + while (pid != HDwaitpid(pid, &status, 0)) + /*void*/; + + /* Check if child process terminates normally and its return value */ + if (WIFEXITED(status) && !WEXITSTATUS(status)) + process_success = TRUE; + } +#endif /* defined(H5_HAVE_WIN32_API) */ - /* Close the property list */ - if(H5Pclose(fapl) < 0) + /* Check if the process terminated correctly */ + if (!process_success) + FAIL_PUTS_ERROR("child process exited abnormally") + + /* Flush the accumulator */ + if (accum_reset(rf) < 0) FAIL_STACK_ERROR; - /* Pop API context */ - if(api_ctx_pushed && H5CX_pop() < 0) FAIL_STACK_ERROR + /* Close and remove the file */ + if (H5Fclose(fid) < 0) + FAIL_STACK_ERROR; + + /* Close the property list */ + if (H5Pclose(fapl) < 0) + FAIL_STACK_ERROR; + + /* Pop API context */ + if (api_ctx_pushed && H5CX_pop(FALSE) < 0) + FAIL_STACK_ERROR api_ctx_pushed = FALSE; - /* Release memory */ - if(wbuf2) - HDfree(wbuf2); - if(rbuf) - HDfree(rbuf); - PASSED(); - return 0; - } /* end if */ + /* Release memory */ + if (wbuf2) + HDfree(wbuf2); + if (rbuf) + HDfree(rbuf); + + PASSED(); + return 0; error: /* Closing and remove the file */ H5Fclose(fid); - if(api_ctx_pushed) H5CX_pop(); + if (api_ctx_pushed) + H5CX_pop(FALSE); H5Pclose(fapl); /* Release memory */ - if(wbuf2) + if (wbuf2) HDfree(wbuf2); - if(rbuf) + if (rbuf) HDfree(rbuf); return 1; -#endif +#endif /* !defined(H5_HAVE_UNISTD_H) && !defined(H5_HAVE_WIN32_API) */ } /* end test_swmr_write_big() */ - /*------------------------------------------------------------------------- * Function: accum_printf * @@ -2046,13 +2351,13 @@ error: *------------------------------------------------------------------------- */ void -accum_printf(const H5F_t *f) +accum_printf(const H5F_t* f) { - H5F_meta_accum_t * accum = &f->shared->accum; + H5F_meta_accum_t* accum = &f->shared->accum; HDprintf("\n"); HDprintf("Current contents of accumulator:\n"); - if(accum->alloc_size == 0) { + if (accum->alloc_size == 0) { HDprintf("=====================================================\n"); HDprintf(" No accumulator allocated.\n"); HDprintf("=====================================================\n"); @@ -2061,17 +2366,20 @@ accum_printf(const H5F_t *f) HDprintf("=====================================================\n"); HDprintf(" accumulator allocated size == %zu\n", accum->alloc_size); HDprintf(" accumulated data size == %zu\n", accum->size); - HDfprintf(stdout, " accumulator dirty? == %t\n", accum->dirty); + HDfprintf(stdout, " accumulator dirty? == %s\n", accum->dirty ? "TRUE" : "FALSE"); HDprintf("=====================================================\n"); - HDfprintf(stdout, " start of accumulated data, loc = %a\n", accum->loc); - if(accum->dirty) { - HDfprintf(stdout, " start of dirty region, loc = %a\n", (haddr_t)(accum->loc + accum->dirty_off)); - HDfprintf(stdout, " end of dirty region, loc = %a\n", (haddr_t)(accum->loc + accum->dirty_off + accum->dirty_len)); + HDfprintf(stdout, " start of accumulated data, loc = %" PRIuHADDR "\n", accum->loc); + if (accum->dirty) { + HDfprintf(stdout, " start of dirty region, loc = %" PRIuHADDR "\n", + (haddr_t)(accum->loc + accum->dirty_off)); + HDfprintf(stdout, " end of dirty region, loc = %" PRIuHADDR "\n", + (haddr_t)(accum->loc + accum->dirty_off + accum->dirty_len)); } /* end if */ - HDfprintf(stdout, " end of accumulated data, loc = %a\n", (haddr_t)(accum->loc + accum->size)); - HDfprintf(stdout, " end of accumulator allocation, loc = %a\n", (haddr_t)(accum->loc + accum->alloc_size)); + HDfprintf(stdout, " end of accumulated data, loc = %" PRIuHADDR "\n", + (haddr_t)(accum->loc + accum->size)); + HDfprintf(stdout, " end of accumulator allocation, loc = %" PRIuHADDR "\n", + (haddr_t)(accum->loc + accum->alloc_size)); HDprintf("=====================================================\n"); } HDprintf("\n\n"); } /* accum_printf() */ - -- cgit v0.12