mirrors/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2026-09-25 04:09:44 +03:00
Code Issues Packages Projects Releases Wiki Activity

Remove HD from memory allocate/free calls (#3195)

Browse Source 
* HDcalloc
* HDfree
* HDmalloc
* HDrealloc
This commit is contained in:
Dana Robinson
2023-06-28 15:48:12 -07:00
committed by GitHub
parent 605cea4af6
commit aebac33a1f
246 changed files with 5889 additions and 5909 deletions
Download Patch File Download Diff File Expand all files Collapse all files
testpar/API/H5_api_async_test_parallel.c
+77 -77
View File
@@ -125,13 +125,13 @@ test_one_dataset_io(void)
data_size *= dims[i];
data_size *= sizeof(int);
if (NULL == (write_buf = HDmalloc(data_size))) {
if (NULL == (write_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset write\n");
TEST_ERROR;
}
if (NULL == (read_buf = HDmalloc(data_size))) {
if (NULL == (read_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset read\n");
TEST_ERROR;
@@ -364,17 +364,17 @@ test_one_dataset_io(void)
TEST_ERROR;
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
if (dims) {
HDfree(dims);
free(dims);
dims = NULL;
}
@@ -395,11 +395,11 @@ error:
H5E_BEGIN_TRY
{
if (read_buf)
HDfree(read_buf);
free(read_buf);
if (write_buf)
HDfree(write_buf);
free(write_buf);
if (dims)
HDfree(dims);
free(dims);
H5Sclose(space_id);
H5Sclose(mspace_id);
H5Dclose(dset_id);
@@ -483,13 +483,13 @@ test_multi_dataset_io(void)
data_size *= sizeof(int);
data_size *= MULTI_DATASET_IO_TEST_NDSETS;
if (NULL == (write_buf = HDmalloc(data_size))) {
if (NULL == (write_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset write\n");
TEST_ERROR;
}
if (NULL == (read_buf = HDmalloc(data_size))) {
if (NULL == (read_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset read\n");
TEST_ERROR;
@@ -687,17 +687,17 @@ test_multi_dataset_io(void)
TEST_ERROR;
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
if (dims) {
HDfree(dims);
free(dims);
dims = NULL;
}
@@ -718,11 +718,11 @@ error:
H5E_BEGIN_TRY
{
if (read_buf)
HDfree(read_buf);
free(read_buf);
if (write_buf)
HDfree(write_buf);
free(write_buf);
if (dims)
HDfree(dims);
free(dims);
H5Sclose(space_id);
H5Sclose(mspace_id);
for (i = 0; i < MULTI_DATASET_IO_TEST_NDSETS; i++)
@@ -805,13 +805,13 @@ test_multi_file_dataset_io(void)
data_size *= sizeof(int);
data_size *= MULTI_FILE_DATASET_IO_TEST_NFILES;
if (NULL == (write_buf = HDmalloc(data_size))) {
if (NULL == (write_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset write\n");
TEST_ERROR;
}
if (NULL == (read_buf = HDmalloc(data_size))) {
if (NULL == (read_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset read\n");
TEST_ERROR;
@@ -1111,17 +1111,17 @@ test_multi_file_dataset_io(void)
TEST_ERROR;
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
if (dims) {
HDfree(dims);
free(dims);
dims = NULL;
}
@@ -1142,11 +1142,11 @@ error:
H5E_BEGIN_TRY
{
if (read_buf)
HDfree(read_buf);
free(read_buf);
if (write_buf)
HDfree(write_buf);
free(write_buf);
if (dims)
HDfree(dims);
free(dims);
H5Sclose(space_id);
H5Sclose(mspace_id);
for (i = 0; i < MULTI_FILE_DATASET_IO_TEST_NFILES; i++) {
@@ -1228,13 +1228,13 @@ test_multi_file_grp_dset_io(void)
data_size *= sizeof(int);
data_size *= MULTI_FILE_GRP_DSET_IO_TEST_NFILES;
if (NULL == (write_buf = HDmalloc(data_size))) {
if (NULL == (write_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset write\n");
TEST_ERROR;
}
if (NULL == (read_buf = HDmalloc(data_size))) {
if (NULL == (read_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset read\n");
TEST_ERROR;
@@ -1527,17 +1527,17 @@ test_multi_file_grp_dset_io(void)
TEST_ERROR;
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
if (dims) {
HDfree(dims);
free(dims);
dims = NULL;
}
@@ -1558,11 +1558,11 @@ error:
H5E_BEGIN_TRY
{
if (read_buf)
HDfree(read_buf);
free(read_buf);
if (write_buf)
HDfree(write_buf);
free(write_buf);
if (dims)
HDfree(dims);
free(dims);
H5Sclose(space_id);
H5Sclose(mspace_id);
H5Dclose(dset_id);
@@ -1633,13 +1633,13 @@ test_set_extent(void)
if (generate_random_parallel_dimensions(SET_EXTENT_TEST_SPACE_RANK, &dims) < 0)
TEST_ERROR;
if (NULL == (maxdims = HDmalloc(SET_EXTENT_TEST_SPACE_RANK * sizeof(hsize_t)))) {
if (NULL == (maxdims = malloc(SET_EXTENT_TEST_SPACE_RANK * sizeof(hsize_t)))) {
H5_FAILED();
printf(" couldn't allocate max dataspace dimension buffer\n");
TEST_ERROR;
}
if (NULL == (cdims = HDmalloc(SET_EXTENT_TEST_SPACE_RANK * sizeof(hsize_t)))) {
if (NULL == (cdims = malloc(SET_EXTENT_TEST_SPACE_RANK * sizeof(hsize_t)))) {
H5_FAILED();
printf(" couldn't allocate chunk dimension buffer\n");
TEST_ERROR;
@@ -1685,13 +1685,13 @@ test_set_extent(void)
data_size *= sizeof(int);
data_size *= SET_EXTENT_TEST_NUM_EXTENDS;
if (NULL == (write_buf = HDmalloc(data_size))) {
if (NULL == (write_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset write\n");
TEST_ERROR;
}
if (NULL == (read_buf = HDmalloc(data_size))) {
if (NULL == (read_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset read\n");
TEST_ERROR;
@@ -1844,27 +1844,27 @@ test_set_extent(void)
FAIL_PUTS_ERROR(" dataspaces are not equal\n");
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
if (cdims) {
HDfree(cdims);
free(cdims);
cdims = NULL;
}
if (maxdims) {
HDfree(maxdims);
free(maxdims);
maxdims = NULL;
}
if (dims) {
HDfree(dims);
free(dims);
dims = NULL;
}
@@ -1897,15 +1897,15 @@ error:
H5E_BEGIN_TRY
{
if (read_buf)
HDfree(read_buf);
free(read_buf);
if (write_buf)
HDfree(write_buf);
free(write_buf);
if (cdims)
HDfree(cdims);
free(cdims);
if (maxdims)
HDfree(maxdims);
free(maxdims);
if (dims)
HDfree(dims);
free(dims);
H5Sclose(space_id);
H5Sclose(mspace_id);
H5Sclose(space_id_out);
@@ -2045,7 +2045,7 @@ test_attribute_exists(void)
TEST_ERROR;
if (dims) {
HDfree(dims);
free(dims);
dims = NULL;
}
@@ -2060,7 +2060,7 @@ error:
H5E_BEGIN_TRY
{
if (dims)
HDfree(dims);
free(dims);
H5Sclose(space_id);
H5Aclose(attr_id);
H5Dclose(dset_id);
@@ -2150,13 +2150,13 @@ test_attribute_io(void)
data_size *= dims[i];
data_size *= sizeof(int);
if (NULL == (write_buf = HDmalloc(data_size))) {
if (NULL == (write_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for attribute write\n");
TEST_ERROR;
}
if (NULL == (read_buf = HDmalloc(data_size))) {
if (NULL == (read_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for attribute read\n");
TEST_ERROR;
@@ -2240,17 +2240,17 @@ test_attribute_io(void)
TEST_ERROR;
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
if (dims) {
HDfree(dims);
free(dims);
dims = NULL;
}
@@ -2265,11 +2265,11 @@ error:
H5E_BEGIN_TRY
{
if (read_buf)
HDfree(read_buf);
free(read_buf);
if (write_buf)
HDfree(write_buf);
free(write_buf);
if (dims)
HDfree(dims);
free(dims);
H5Sclose(space_id);
H5Aclose(attr_id);
H5Dclose(dset_id);
@@ -2348,13 +2348,13 @@ test_attribute_io_tconv(void)
data_size *= dims[i];
data_size *= sizeof(int);
if (NULL == (write_buf = HDmalloc(data_size))) {
if (NULL == (write_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for attribute write\n");
TEST_ERROR;
}
if (NULL == (read_buf = HDmalloc(data_size))) {
if (NULL == (read_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for attribute read\n");
TEST_ERROR;
@@ -2433,17 +2433,17 @@ test_attribute_io_tconv(void)
TEST_ERROR;
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
if (dims) {
HDfree(dims);
free(dims);
dims = NULL;
}
@@ -2460,11 +2460,11 @@ error:
H5E_BEGIN_TRY
{
if (read_buf)
HDfree(read_buf);
free(read_buf);
if (write_buf)
HDfree(write_buf);
free(write_buf);
if (dims)
HDfree(dims);
free(dims);
H5Sclose(space_id);
H5Aclose(attr_id);
H5Dclose(dset_id);
@@ -2577,19 +2577,19 @@ test_attribute_io_compound(void)
data_size *= dims[i];
data_size *= sizeof(tattr_cmpd_t);
if (NULL == (write_buf = HDmalloc(data_size))) {
if (NULL == (write_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for attribute write\n");
TEST_ERROR;
}
if (NULL == (read_buf = HDmalloc(data_size))) {
if (NULL == (read_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for attribute read\n");
TEST_ERROR;
}
if (NULL == (fbuf = HDmalloc(data_size))) {
if (NULL == (fbuf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for attribute read verification\n");
TEST_ERROR;
@@ -2835,22 +2835,22 @@ test_attribute_io_compound(void)
TEST_ERROR;
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
if (fbuf) {
HDfree(fbuf);
free(fbuf);
fbuf = NULL;
}
if (dims) {
HDfree(dims);
free(dims);
dims = NULL;
}
@@ -2867,13 +2867,13 @@ error:
H5E_BEGIN_TRY
{
if (read_buf)
HDfree(read_buf);
free(read_buf);
if (write_buf)
HDfree(write_buf);
free(write_buf);
if (fbuf)
HDfree(fbuf);
free(fbuf);
if (dims)
HDfree(dims);
free(dims);
H5Sclose(space_id);
H5Tclose(mtype_id);
H5Tclose(ftype_id);
@@ -3457,7 +3457,7 @@ test_ocopy_orefresh(void)
TEST_ERROR;
if (dims) {
HDfree(dims);
free(dims);
dims = NULL;
}
@@ -3474,7 +3474,7 @@ error:
H5E_BEGIN_TRY
{
if (dims)
HDfree(dims);
free(dims);
H5Sclose(space_id);
H5Dclose(dset_id);
H5Gclose(parent_group_id);
testpar/API/H5_api_dataset_test_parallel.c
+223 -224
View File
@@ -215,7 +215,7 @@ test_write_dataset_data_verification(void)
data_size *= dims[i];
data_size *= DATASET_WRITE_DATA_VERIFY_TEST_DTYPE_SIZE;
if (NULL != (write_buf = HDmalloc(data_size))) {
if (NULL != (write_buf = malloc(data_size))) {
for (i = 0; i < data_size / DATASET_WRITE_DATA_VERIFY_TEST_DTYPE_SIZE; i++)
((int *)write_buf)[i] = (int)i;
@@ -227,7 +227,7 @@ test_write_dataset_data_verification(void)
op_failed = TRUE;
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
}
@@ -317,7 +317,7 @@ test_write_dataset_data_verification(void)
}
if (NULL ==
(read_buf = HDmalloc((hsize_t)space_npoints * DATASET_WRITE_DATA_VERIFY_TEST_DTYPE_SIZE))) {
(read_buf = malloc((hsize_t)space_npoints * DATASET_WRITE_DATA_VERIFY_TEST_DTYPE_SIZE))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset read\n");
PART_ERROR(H5Dwrite_all_read);
@@ -338,7 +338,7 @@ test_write_dataset_data_verification(void)
}
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
@@ -347,11 +347,11 @@ test_write_dataset_data_verification(void)
PART_END(H5Dwrite_all_read);
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
if (fspace_id >= 0) {
@@ -379,7 +379,7 @@ test_write_dataset_data_verification(void)
data_size *= dims[i];
data_size *= DATASET_WRITE_DATA_VERIFY_TEST_DTYPE_SIZE;
if (NULL == (write_buf = HDmalloc(data_size))) {
if (NULL == (write_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset write\n");
PART_ERROR(H5Dwrite_hyperslab_read);
@@ -442,7 +442,7 @@ test_write_dataset_data_verification(void)
}
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
if (mspace_id >= 0) {
@@ -525,7 +525,7 @@ test_write_dataset_data_verification(void)
}
if (NULL ==
(read_buf = HDmalloc((hsize_t)space_npoints * DATASET_WRITE_DATA_VERIFY_TEST_DTYPE_SIZE))) {
(read_buf = malloc((hsize_t)space_npoints * DATASET_WRITE_DATA_VERIFY_TEST_DTYPE_SIZE))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset read\n");
PART_ERROR(H5Dwrite_hyperslab_read);
@@ -553,7 +553,7 @@ test_write_dataset_data_verification(void)
}
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
@@ -562,11 +562,11 @@ test_write_dataset_data_verification(void)
PART_END(H5Dwrite_hyperslab_read);
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
if (fspace_id >= 0) {
@@ -602,7 +602,7 @@ test_write_dataset_data_verification(void)
data_size *= dims[i];
data_size *= DATASET_WRITE_DATA_VERIFY_TEST_DTYPE_SIZE;
if (NULL == (write_buf = HDmalloc(data_size))) {
if (NULL == (write_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset write\n");
PART_ERROR(H5Dwrite_point_sel_read);
@@ -612,9 +612,9 @@ test_write_dataset_data_verification(void)
for (i = 0; i < data_size / DATASET_WRITE_DATA_VERIFY_TEST_DTYPE_SIZE; i++)
((int *)write_buf)[i] = mpi_size - mpi_rank;
if (NULL == (points = HDmalloc(DATASET_WRITE_DATA_VERIFY_TEST_SPACE_RANK *
(data_size / DATASET_WRITE_DATA_VERIFY_TEST_DTYPE_SIZE) *
sizeof(hsize_t)))) {
if (NULL == (points = malloc(DATASET_WRITE_DATA_VERIFY_TEST_SPACE_RANK *
(data_size / DATASET_WRITE_DATA_VERIFY_TEST_DTYPE_SIZE) *
sizeof(hsize_t)))) {
H5_FAILED();
printf(" couldn't allocate buffer for point selection\n");
PART_ERROR(H5Dwrite_point_sel_read);
@@ -676,7 +676,7 @@ test_write_dataset_data_verification(void)
}
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
if (mspace_id >= 0) {
@@ -759,7 +759,7 @@ test_write_dataset_data_verification(void)
}
if (NULL ==
(read_buf = HDmalloc((hsize_t)space_npoints * DATASET_WRITE_DATA_VERIFY_TEST_DTYPE_SIZE))) {
(read_buf = malloc((hsize_t)space_npoints * DATASET_WRITE_DATA_VERIFY_TEST_DTYPE_SIZE))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset read\n");
PART_ERROR(H5Dwrite_point_sel_read);
@@ -787,7 +787,7 @@ test_write_dataset_data_verification(void)
}
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
@@ -796,15 +796,15 @@ test_write_dataset_data_verification(void)
PART_END(H5Dwrite_point_sel_read);
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
if (points) {
HDfree(points);
free(points);
points = NULL;
}
if (fspace_id >= 0) {
@@ -837,22 +837,22 @@ test_write_dataset_data_verification(void)
TESTING_2("test cleanup");
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
if (points) {
HDfree(points);
free(points);
points = NULL;
}
if (dims) {
HDfree(dims);
free(dims);
dims = NULL;
}
@@ -873,13 +873,13 @@ error:
H5E_BEGIN_TRY
{
if (read_buf)
HDfree(read_buf);
free(read_buf);
if (write_buf)
HDfree(write_buf);
free(write_buf);
if (points)
HDfree(points);
free(points);
if (dims)
HDfree(dims);
free(dims);
H5Sclose(mspace_id);
H5Sclose(fspace_id);
H5Dclose(dset_id);
@@ -988,7 +988,7 @@ test_write_dataset_independent(void)
data_size *= dims[i];
data_size *= DATASET_INDEPENDENT_WRITE_TEST_DTYPE_SIZE;
if (NULL == (write_buf = HDmalloc(data_size))) {
if (NULL == (write_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset write\n");
goto error;
@@ -1066,7 +1066,7 @@ test_write_dataset_independent(void)
END_INDEPENDENT_OP(dset_write);
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
@@ -1139,7 +1139,7 @@ test_write_dataset_independent(void)
goto error;
}
if (NULL == (read_buf = HDmalloc((hsize_t)space_npoints * DATASET_INDEPENDENT_WRITE_TEST_DTYPE_SIZE))) {
if (NULL == (read_buf = malloc((hsize_t)space_npoints * DATASET_INDEPENDENT_WRITE_TEST_DTYPE_SIZE))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset read\n");
goto error;
@@ -1186,12 +1186,12 @@ test_write_dataset_independent(void)
}
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
if (dims) {
HDfree(dims);
free(dims);
dims = NULL;
}
@@ -1218,11 +1218,11 @@ error:
H5E_BEGIN_TRY
{
if (read_buf)
HDfree(read_buf);
free(read_buf);
if (write_buf)
HDfree(write_buf);
free(write_buf);
if (dims)
HDfree(dims);
free(dims);
H5Sclose(mspace_id);
H5Sclose(fspace_id);
H5Dclose(dset_id1);
@@ -1319,7 +1319,7 @@ test_write_dataset_one_proc_0_selection(void)
BEGIN_INDEPENDENT_OP(write_buf_alloc)
{
if (!MAINPROCESS) {
if (NULL == (write_buf = HDmalloc(data_size))) {
if (NULL == (write_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset write\n");
INDEPENDENT_OP_ERROR(write_buf_alloc);
@@ -1376,7 +1376,7 @@ test_write_dataset_one_proc_0_selection(void)
END_INDEPENDENT_OP(dset_write);
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
if (mspace_id >= 0) {
@@ -1457,8 +1457,7 @@ test_write_dataset_one_proc_0_selection(void)
goto error;
}
if (NULL ==
(read_buf = HDmalloc((hsize_t)space_npoints * DATASET_WRITE_ONE_PROC_0_SEL_TEST_DTYPE_SIZE))) {
if (NULL == (read_buf = malloc((hsize_t)space_npoints * DATASET_WRITE_ONE_PROC_0_SEL_TEST_DTYPE_SIZE))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset read\n");
goto error;
@@ -1487,12 +1486,12 @@ test_write_dataset_one_proc_0_selection(void)
}
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
if (dims) {
HDfree(dims);
free(dims);
dims = NULL;
}
@@ -1517,11 +1516,11 @@ error:
H5E_BEGIN_TRY
{
if (read_buf)
HDfree(read_buf);
free(read_buf);
if (write_buf)
HDfree(write_buf);
free(write_buf);
if (dims)
HDfree(dims);
free(dims);
H5Sclose(mspace_id);
H5Sclose(fspace_id);
H5Dclose(dset_id);
@@ -1617,7 +1616,7 @@ test_write_dataset_one_proc_none_selection(void)
BEGIN_INDEPENDENT_OP(write_buf_alloc)
{
if (!MAINPROCESS) {
if (NULL == (write_buf = HDmalloc(data_size))) {
if (NULL == (write_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset write\n");
INDEPENDENT_OP_ERROR(write_buf_alloc);
@@ -1687,7 +1686,7 @@ test_write_dataset_one_proc_none_selection(void)
END_INDEPENDENT_OP(dset_write);
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
if (mspace_id >= 0) {
@@ -1770,7 +1769,7 @@ test_write_dataset_one_proc_none_selection(void)
}
if (NULL ==
(read_buf = HDmalloc((hsize_t)space_npoints * DATASET_WRITE_ONE_PROC_NONE_SEL_TEST_DTYPE_SIZE))) {
(read_buf = malloc((hsize_t)space_npoints * DATASET_WRITE_ONE_PROC_NONE_SEL_TEST_DTYPE_SIZE))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset read\n");
goto error;
@@ -1800,12 +1799,12 @@ test_write_dataset_one_proc_none_selection(void)
}
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
if (dims) {
HDfree(dims);
free(dims);
dims = NULL;
}
@@ -1830,11 +1829,11 @@ error:
H5E_BEGIN_TRY
{
if (read_buf)
HDfree(read_buf);
free(read_buf);
if (write_buf)
HDfree(write_buf);
free(write_buf);
if (dims)
HDfree(dims);
free(dims);
H5Sclose(mspace_id);
H5Sclose(fspace_id);
H5Dclose(dset_id);
@@ -1927,7 +1926,7 @@ test_write_dataset_one_proc_all_selection(void)
BEGIN_INDEPENDENT_OP(write_buf_alloc)
{
if (MAINPROCESS) {
if (NULL == (write_buf = HDmalloc(data_size))) {
if (NULL == (write_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset write\n");
INDEPENDENT_OP_ERROR(write_buf_alloc);
@@ -1983,7 +1982,7 @@ test_write_dataset_one_proc_all_selection(void)
END_INDEPENDENT_OP(dset_write);
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
if (mspace_id >= 0) {
@@ -2066,7 +2065,7 @@ test_write_dataset_one_proc_all_selection(void)
}
if (NULL ==
(read_buf = HDmalloc((hsize_t)space_npoints * DATASET_WRITE_ONE_PROC_ALL_SEL_TEST_DTYPE_SIZE))) {
(read_buf = malloc((hsize_t)space_npoints * DATASET_WRITE_ONE_PROC_ALL_SEL_TEST_DTYPE_SIZE))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset read\n");
goto error;
@@ -2088,12 +2087,12 @@ test_write_dataset_one_proc_all_selection(void)
}
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
if (dims) {
HDfree(dims);
free(dims);
dims = NULL;
}
@@ -2118,11 +2117,11 @@ error:
H5E_BEGIN_TRY
{
if (read_buf)
HDfree(read_buf);
free(read_buf);
if (write_buf)
HDfree(write_buf);
free(write_buf);
if (dims)
HDfree(dims);
free(dims);
H5Sclose(mspace_id);
H5Sclose(fspace_id);
H5Dclose(dset_id);
@@ -2221,7 +2220,7 @@ test_write_dataset_hyper_file_all_mem(void)
data_size *= dims[i];
data_size *= DATASET_WRITE_HYPER_FILE_ALL_MEM_TEST_DTYPE_SIZE;
if (NULL == (write_buf = HDmalloc(data_size))) {
if (NULL == (write_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset write\n");
goto error;
@@ -2258,7 +2257,7 @@ test_write_dataset_hyper_file_all_mem(void)
}
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
if (fspace_id >= 0) {
@@ -2333,7 +2332,7 @@ test_write_dataset_hyper_file_all_mem(void)
}
if (NULL ==
(read_buf = HDmalloc((hsize_t)space_npoints * DATASET_WRITE_HYPER_FILE_ALL_MEM_TEST_DTYPE_SIZE))) {
(read_buf = malloc((hsize_t)space_npoints * DATASET_WRITE_HYPER_FILE_ALL_MEM_TEST_DTYPE_SIZE))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset read\n");
goto error;
@@ -2360,12 +2359,12 @@ test_write_dataset_hyper_file_all_mem(void)
}
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
if (dims) {
HDfree(dims);
free(dims);
dims = NULL;
}
@@ -2394,11 +2393,11 @@ error:
H5E_BEGIN_TRY
{
if (read_buf)
HDfree(read_buf);
free(read_buf);
if (write_buf)
HDfree(write_buf);
free(write_buf);
if (dims)
HDfree(dims);
free(dims);
H5Sclose(mspace_id);
H5Sclose(fspace_id);
H5Dclose(dset_id);
@@ -2497,7 +2496,7 @@ test_write_dataset_all_file_hyper_mem(void)
* buffer in order to prove that the mapping from hyperslab selection <-> all
* selection works correctly.
*/
if (NULL == (write_buf = HDmalloc(2 * data_size))) {
if (NULL == (write_buf = malloc(2 * data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset write\n");
INDEPENDENT_OP_ERROR(write_buf_alloc);
@@ -2552,7 +2551,7 @@ test_write_dataset_all_file_hyper_mem(void)
END_INDEPENDENT_OP(dset_write);
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
if (mspace_id >= 0) {
@@ -2635,7 +2634,7 @@ test_write_dataset_all_file_hyper_mem(void)
}
if (NULL ==
(read_buf = HDmalloc((hsize_t)space_npoints * DATASET_WRITE_ALL_FILE_HYPER_MEM_TEST_DTYPE_SIZE))) {
(read_buf = malloc((hsize_t)space_npoints * DATASET_WRITE_ALL_FILE_HYPER_MEM_TEST_DTYPE_SIZE))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset read\n");
goto error;
@@ -2657,12 +2656,12 @@ test_write_dataset_all_file_hyper_mem(void)
}
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
if (dims) {
HDfree(dims);
free(dims);
dims = NULL;
}
@@ -2687,11 +2686,11 @@ error:
H5E_BEGIN_TRY
{
if (read_buf)
HDfree(read_buf);
free(read_buf);
if (write_buf)
HDfree(write_buf);
free(write_buf);
if (dims)
HDfree(dims);
free(dims);
H5Sclose(mspace_id);
H5Sclose(fspace_id);
H5Dclose(dset_id);
@@ -2805,7 +2804,7 @@ test_write_dataset_all_file_point_mem(void)
* buffer in order to prove that the mapping from point selection <-> all
* selection works correctly.
*/
if (NULL == (write_buf = HDmalloc(2 * data_size))) {
if (NULL == (write_buf = malloc(2 * data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset write\n");
INDEPENDENT_OP_ERROR(write_buf_alloc);
@@ -2839,8 +2838,8 @@ test_write_dataset_all_file_point_mem(void)
INDEPENDENT_OP_ERROR(dset_write);
}
if (NULL == (points = HDmalloc((data_size / DATASET_WRITE_ALL_FILE_POINT_MEM_TEST_DTYPE_SIZE) *
sizeof(hsize_t)))) {
if (NULL == (points = malloc((data_size / DATASET_WRITE_ALL_FILE_POINT_MEM_TEST_DTYPE_SIZE) *
sizeof(hsize_t)))) {
H5_FAILED();
printf(" couldn't allocate buffer for point selection\n");
INDEPENDENT_OP_ERROR(dset_write);
@@ -2872,11 +2871,11 @@ test_write_dataset_all_file_point_mem(void)
END_INDEPENDENT_OP(dset_write);
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
if (points) {
HDfree(points);
free(points);
points = NULL;
}
if (mspace_id >= 0) {
@@ -2959,7 +2958,7 @@ test_write_dataset_all_file_point_mem(void)
}
if (NULL ==
(read_buf = HDmalloc((hsize_t)space_npoints * DATASET_WRITE_ALL_FILE_POINT_MEM_TEST_DTYPE_SIZE))) {
(read_buf = malloc((hsize_t)space_npoints * DATASET_WRITE_ALL_FILE_POINT_MEM_TEST_DTYPE_SIZE))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset read\n");
goto error;
@@ -2981,12 +2980,12 @@ test_write_dataset_all_file_point_mem(void)
}
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
if (dims) {
HDfree(dims);
free(dims);
dims = NULL;
}
@@ -3011,13 +3010,13 @@ error:
H5E_BEGIN_TRY
{
if (read_buf)
HDfree(read_buf);
free(read_buf);
if (write_buf)
HDfree(write_buf);
free(write_buf);
if (points)
HDfree(points);
free(points);
if (dims)
HDfree(dims);
free(dims);
H5Sclose(mspace_id);
H5Sclose(fspace_id);
H5Dclose(dset_id);
@@ -3117,7 +3116,7 @@ test_write_dataset_hyper_file_point_mem(void)
* buffer in order to prove that the mapping from point selection <-> hyperslab
* selection works correctly.
*/
if (NULL == (write_buf = HDmalloc(2 * data_size))) {
if (NULL == (write_buf = malloc(2 * data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset write\n");
goto error;
@@ -3161,8 +3160,8 @@ test_write_dataset_hyper_file_point_mem(void)
goto error;
}
if (NULL == (points = HDmalloc((data_size / DATASET_WRITE_HYPER_FILE_POINT_MEM_TEST_DTYPE_SIZE) *
sizeof(hsize_t)))) {
if (NULL == (points = malloc((data_size / DATASET_WRITE_HYPER_FILE_POINT_MEM_TEST_DTYPE_SIZE) *
sizeof(hsize_t)))) {
H5_FAILED();
printf(" couldn't allocate buffer for point selection\n");
goto error;
@@ -3190,11 +3189,11 @@ test_write_dataset_hyper_file_point_mem(void)
}
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
if (points) {
HDfree(points);
free(points);
points = NULL;
}
if (mspace_id >= 0) {
@@ -3277,7 +3276,7 @@ test_write_dataset_hyper_file_point_mem(void)
}
if (NULL ==
(read_buf = HDmalloc((hsize_t)space_npoints * DATASET_WRITE_HYPER_FILE_POINT_MEM_TEST_DTYPE_SIZE))) {
(read_buf = malloc((hsize_t)space_npoints * DATASET_WRITE_HYPER_FILE_POINT_MEM_TEST_DTYPE_SIZE))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset read\n");
goto error;
@@ -3305,12 +3304,12 @@ test_write_dataset_hyper_file_point_mem(void)
}
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
if (dims) {
HDfree(dims);
free(dims);
dims = NULL;
}
@@ -3335,13 +3334,13 @@ error:
H5E_BEGIN_TRY
{
if (read_buf)
HDfree(read_buf);
free(read_buf);
if (write_buf)
HDfree(write_buf);
free(write_buf);
if (points)
HDfree(points);
free(points);
if (dims)
HDfree(dims);
free(dims);
H5Sclose(mspace_id);
H5Sclose(fspace_id);
H5Dclose(dset_id);
@@ -3437,7 +3436,7 @@ test_write_dataset_point_file_hyper_mem(void)
* buffer in order to prove that the mapping from hyperslab selection <-> point
* selection works correctly.
*/
if (NULL == (write_buf = HDmalloc(2 * data_size))) {
if (NULL == (write_buf = malloc(2 * data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset write\n");
goto error;
@@ -3451,8 +3450,8 @@ test_write_dataset_point_file_hyper_mem(void)
((int *)write_buf)[i] = 0;
}
if (NULL == (points = HDmalloc((data_size / DATASET_WRITE_POINT_FILE_HYPER_MEM_TEST_DTYPE_SIZE) *
DATASET_WRITE_POINT_FILE_HYPER_MEM_TEST_SPACE_RANK * sizeof(hsize_t)))) {
if (NULL == (points = malloc((data_size / DATASET_WRITE_POINT_FILE_HYPER_MEM_TEST_DTYPE_SIZE) *
DATASET_WRITE_POINT_FILE_HYPER_MEM_TEST_SPACE_RANK * sizeof(hsize_t)))) {
H5_FAILED();
printf(" couldn't allocate buffer for point selection\n");
goto error;
@@ -3508,11 +3507,11 @@ test_write_dataset_point_file_hyper_mem(void)
}
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
if (points) {
HDfree(points);
free(points);
points = NULL;
}
if (mspace_id >= 0) {
@@ -3595,7 +3594,7 @@ test_write_dataset_point_file_hyper_mem(void)
}
if (NULL ==
(read_buf = HDmalloc((hsize_t)space_npoints * DATASET_WRITE_POINT_FILE_HYPER_MEM_TEST_DTYPE_SIZE))) {
(read_buf = malloc((hsize_t)space_npoints * DATASET_WRITE_POINT_FILE_HYPER_MEM_TEST_DTYPE_SIZE))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset read\n");
goto error;
@@ -3623,12 +3622,12 @@ test_write_dataset_point_file_hyper_mem(void)
}
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
if (dims) {
HDfree(dims);
free(dims);
dims = NULL;
}
@@ -3653,13 +3652,13 @@ error:
H5E_BEGIN_TRY
{
if (read_buf)
HDfree(read_buf);
free(read_buf);
if (write_buf)
HDfree(write_buf);
free(write_buf);
if (points)
HDfree(points);
free(points);
if (dims)
HDfree(dims);
free(dims);
H5Sclose(mspace_id);
H5Sclose(fspace_id);
H5Dclose(dset_id);
@@ -3758,7 +3757,7 @@ test_read_dataset_one_proc_0_selection(void)
data_size *= dims[i];
data_size *= DATASET_READ_ONE_PROC_0_SEL_TEST_DTYPE_SIZE;
if (NULL == (write_buf = HDmalloc(data_size))) {
if (NULL == (write_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset write\n");
INDEPENDENT_OP_ERROR(dset_create);
@@ -3793,7 +3792,7 @@ test_read_dataset_one_proc_0_selection(void)
}
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
if (mspace_id >= 0) {
@@ -3889,7 +3888,7 @@ test_read_dataset_one_proc_0_selection(void)
read_buf_size =
((size_t)(space_npoints / mpi_size) * DATASET_READ_ONE_PROC_0_SEL_TEST_DTYPE_SIZE);
if (NULL == (read_buf = HDmalloc(read_buf_size))) {
if (NULL == (read_buf = malloc(read_buf_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset read\n");
INDEPENDENT_OP_ERROR(read_buf_alloc);
@@ -3957,12 +3956,12 @@ test_read_dataset_one_proc_0_selection(void)
END_INDEPENDENT_OP(data_verify);
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
if (dims) {
HDfree(dims);
free(dims);
dims = NULL;
}
@@ -3989,11 +3988,11 @@ error:
H5E_BEGIN_TRY
{
if (read_buf)
HDfree(read_buf);
free(read_buf);
if (write_buf)
HDfree(write_buf);
free(write_buf);
if (dims)
HDfree(dims);
free(dims);
H5Sclose(mspace_id);
H5Sclose(fspace_id);
H5Dclose(dset_id);
@@ -4093,7 +4092,7 @@ test_read_dataset_one_proc_none_selection(void)
data_size *= dims[i];
data_size *= DATASET_READ_ONE_PROC_NONE_SEL_TEST_DTYPE_SIZE;
if (NULL == (write_buf = HDmalloc(data_size))) {
if (NULL == (write_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset write\n");
INDEPENDENT_OP_ERROR(dset_create);
@@ -4128,7 +4127,7 @@ test_read_dataset_one_proc_none_selection(void)
}
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
if (mspace_id >= 0) {
@@ -4225,7 +4224,7 @@ test_read_dataset_one_proc_none_selection(void)
read_buf_size =
((size_t)(space_npoints / mpi_size) * DATASET_READ_ONE_PROC_NONE_SEL_TEST_DTYPE_SIZE);
if (NULL == (read_buf = HDmalloc(read_buf_size))) {
if (NULL == (read_buf = malloc(read_buf_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset read\n");
INDEPENDENT_OP_ERROR(read_buf_alloc);
@@ -4306,12 +4305,12 @@ test_read_dataset_one_proc_none_selection(void)
END_INDEPENDENT_OP(data_verify);
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
if (dims) {
HDfree(dims);
free(dims);
dims = NULL;
}
@@ -4338,11 +4337,11 @@ error:
H5E_BEGIN_TRY
{
if (read_buf)
HDfree(read_buf);
free(read_buf);
if (write_buf)
HDfree(write_buf);
free(write_buf);
if (dims)
HDfree(dims);
free(dims);
H5Sclose(mspace_id);
H5Sclose(fspace_id);
H5Dclose(dset_id);
@@ -4439,7 +4438,7 @@ test_read_dataset_one_proc_all_selection(void)
data_size *= dims[i];
data_size *= DATASET_READ_ONE_PROC_ALL_SEL_TEST_DTYPE_SIZE;
if (NULL == (write_buf = HDmalloc(data_size))) {
if (NULL == (write_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset write\n");
INDEPENDENT_OP_ERROR(dset_create);
@@ -4474,7 +4473,7 @@ test_read_dataset_one_proc_all_selection(void)
}
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
if (mspace_id >= 0) {
@@ -4569,7 +4568,7 @@ test_read_dataset_one_proc_all_selection(void)
if (MAINPROCESS) {
read_buf_size = (size_t)space_npoints * DATASET_READ_ONE_PROC_ALL_SEL_TEST_DTYPE_SIZE;
if (NULL == (read_buf = HDmalloc(read_buf_size))) {
if (NULL == (read_buf = malloc(read_buf_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset read\n");
INDEPENDENT_OP_ERROR(read_buf_alloc);
@@ -4643,12 +4642,12 @@ test_read_dataset_one_proc_all_selection(void)
END_INDEPENDENT_OP(data_verify);
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
if (dims) {
HDfree(dims);
free(dims);
dims = NULL;
}
@@ -4675,11 +4674,11 @@ error:
H5E_BEGIN_TRY
{
if (read_buf)
HDfree(read_buf);
free(read_buf);
if (write_buf)
HDfree(write_buf);
free(write_buf);
if (dims)
HDfree(dims);
free(dims);
H5Sclose(mspace_id);
H5Sclose(fspace_id);
H5Dclose(dset_id);
@@ -4791,7 +4790,7 @@ test_read_dataset_all_file_hyper_mem(void)
data_size *= dims[i];
data_size *= DATASET_READ_ALL_FILE_HYPER_MEM_TEST_DTYPE_SIZE;
if (NULL == (write_buf = HDmalloc(data_size))) {
if (NULL == (write_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset write\n");
INDEPENDENT_OP_ERROR(dset_create);
@@ -4828,7 +4827,7 @@ test_read_dataset_all_file_hyper_mem(void)
}
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
if (mspace_id >= 0) {
@@ -4938,7 +4937,7 @@ test_read_dataset_all_file_hyper_mem(void)
* selection works correctly.
*/
read_buf_size = (size_t)(2 * space_npoints) * DATASET_READ_ALL_FILE_HYPER_MEM_TEST_DTYPE_SIZE;
if (NULL == (read_buf = HDcalloc(1, read_buf_size))) {
if (NULL == (read_buf = calloc(1, read_buf_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset read\n");
INDEPENDENT_OP_ERROR(dset_read);
@@ -4992,12 +4991,12 @@ test_read_dataset_all_file_hyper_mem(void)
END_INDEPENDENT_OP(dset_read);
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
if (dims) {
HDfree(dims);
free(dims);
dims = NULL;
}
@@ -5022,11 +5021,11 @@ error:
H5E_BEGIN_TRY
{
if (read_buf)
HDfree(read_buf);
free(read_buf);
if (write_buf)
HDfree(write_buf);
free(write_buf);
if (dims)
HDfree(dims);
free(dims);
H5Sclose(mspace_id);
H5Sclose(fspace_id);
H5Dclose(dset_id);
@@ -5139,7 +5138,7 @@ test_read_dataset_all_file_point_mem(void)
data_size *= dims[i];
data_size *= DATASET_READ_ALL_FILE_POINT_MEM_TEST_DTYPE_SIZE;
if (NULL == (write_buf = HDmalloc(data_size))) {
if (NULL == (write_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset write\n");
INDEPENDENT_OP_ERROR(dset_create);
@@ -5176,7 +5175,7 @@ test_read_dataset_all_file_point_mem(void)
}
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
if (mspace_id >= 0) {
@@ -5283,7 +5282,7 @@ test_read_dataset_all_file_point_mem(void)
* selection works correctly.
*/
read_buf_size = (size_t)(2 * space_npoints) * DATASET_READ_ALL_FILE_POINT_MEM_TEST_DTYPE_SIZE;
if (NULL == (read_buf = HDcalloc(1, read_buf_size))) {
if (NULL == (read_buf = calloc(1, read_buf_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset read\n");
INDEPENDENT_OP_ERROR(dset_read);
@@ -5295,7 +5294,7 @@ test_read_dataset_all_file_point_mem(void)
INDEPENDENT_OP_ERROR(dset_read);
}
if (NULL == (points = HDmalloc((size_t)space_npoints * sizeof(hsize_t)))) {
if (NULL == (points = malloc((size_t)space_npoints * sizeof(hsize_t)))) {
H5_FAILED();
printf(" couldn't allocate buffer for point selection\n");
INDEPENDENT_OP_ERROR(dset_read);
@@ -5348,17 +5347,17 @@ test_read_dataset_all_file_point_mem(void)
END_INDEPENDENT_OP(dset_read);
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
if (points) {
HDfree(points);
free(points);
points = NULL;
}
if (dims) {
HDfree(dims);
free(dims);
dims = NULL;
}
@@ -5383,13 +5382,13 @@ error:
H5E_BEGIN_TRY
{
if (read_buf)
HDfree(read_buf);
free(read_buf);
if (write_buf)
HDfree(write_buf);
free(write_buf);
if (points)
HDfree(points);
free(points);
if (dims)
HDfree(dims);
free(dims);
H5Sclose(mspace_id);
H5Sclose(fspace_id);
H5Dclose(dset_id);
@@ -5492,7 +5491,7 @@ test_read_dataset_hyper_file_point_mem(void)
data_size *= dims[i];
data_size *= DATASET_READ_HYPER_FILE_POINT_MEM_TEST_DTYPE_SIZE;
if (NULL == (write_buf = HDmalloc(data_size))) {
if (NULL == (write_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset write\n");
INDEPENDENT_OP_ERROR(dset_create);
@@ -5529,7 +5528,7 @@ test_read_dataset_hyper_file_point_mem(void)
}
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
if (mspace_id >= 0) {
@@ -5626,7 +5625,7 @@ test_read_dataset_hyper_file_point_mem(void)
* selection works correctly.
*/
read_buf_size = (2 * (size_t)(space_npoints / mpi_size) * DATASET_READ_ONE_PROC_NONE_SEL_TEST_DTYPE_SIZE);
if (NULL == (read_buf = HDcalloc(1, read_buf_size))) {
if (NULL == (read_buf = calloc(1, read_buf_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset read\n");
goto error;
@@ -5662,7 +5661,7 @@ test_read_dataset_hyper_file_point_mem(void)
goto error;
}
if (NULL == (points = HDmalloc((size_t)(space_npoints / mpi_size) * sizeof(hsize_t)))) {
if (NULL == (points = malloc((size_t)(space_npoints / mpi_size) * sizeof(hsize_t)))) {
H5_FAILED();
printf(" couldn't allocate buffer for point selection\n");
goto error;
@@ -5706,17 +5705,17 @@ test_read_dataset_hyper_file_point_mem(void)
}
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
if (points) {
HDfree(points);
free(points);
points = NULL;
}
if (dims) {
HDfree(dims);
free(dims);
dims = NULL;
}
@@ -5741,13 +5740,13 @@ error:
H5E_BEGIN_TRY
{
if (read_buf)
HDfree(read_buf);
free(read_buf);
if (write_buf)
HDfree(write_buf);
free(write_buf);
if (points)
HDfree(points);
free(points);
if (dims)
HDfree(dims);
free(dims);
H5Sclose(mspace_id);
H5Sclose(fspace_id);
H5Dclose(dset_id);
@@ -5846,7 +5845,7 @@ test_read_dataset_point_file_hyper_mem(void)
data_size *= dims[i];
data_size *= DATASET_READ_POINT_FILE_HYPER_MEM_TEST_DTYPE_SIZE;
if (NULL == (write_buf = HDmalloc(data_size))) {
if (NULL == (write_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset write\n");
INDEPENDENT_OP_ERROR(dset_create);
@@ -5883,7 +5882,7 @@ test_read_dataset_point_file_hyper_mem(void)
}
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
if (mspace_id >= 0) {
@@ -5981,15 +5980,15 @@ test_read_dataset_point_file_hyper_mem(void)
*/
read_buf_size =
(2 * (size_t)(space_npoints / mpi_size) * DATASET_READ_POINT_FILE_HYPER_MEM_TEST_DTYPE_SIZE);
if (NULL == (read_buf = HDcalloc(1, read_buf_size))) {
if (NULL == (read_buf = calloc(1, read_buf_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset read\n");
goto error;
}
if (NULL == (points = HDmalloc((size_t)((space_npoints / mpi_size) *
DATASET_READ_POINT_FILE_HYPER_MEM_TEST_SPACE_RANK) *
sizeof(hsize_t)))) {
if (NULL == (points = malloc((size_t)((space_npoints / mpi_size) *
DATASET_READ_POINT_FILE_HYPER_MEM_TEST_SPACE_RANK) *
sizeof(hsize_t)))) {
H5_FAILED();
printf(" couldn't allocate buffer for point selection\n");
goto error;
@@ -6061,17 +6060,17 @@ test_read_dataset_point_file_hyper_mem(void)
}
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
if (points) {
HDfree(points);
free(points);
points = NULL;
}
if (dims) {
HDfree(dims);
free(dims);
dims = NULL;
}
@@ -6098,13 +6097,13 @@ error:
H5E_BEGIN_TRY
{
if (read_buf)
HDfree(read_buf);
free(read_buf);
if (write_buf)
HDfree(write_buf);
free(write_buf);
if (points)
HDfree(points);
free(points);
if (dims)
HDfree(dims);
free(dims);
H5Sclose(mspace_id);
H5Sclose(fspace_id);
H5Dclose(dset_id);
@@ -6166,14 +6165,14 @@ test_write_multi_chunk_dataset_same_shape_read(void)
}
if (NULL ==
(dims = HDmalloc(DATASET_MULTI_CHUNK_WRITE_SAME_SPACE_READ_TEST_DSET_SPACE_RANK * sizeof(hsize_t)))) {
(dims = malloc(DATASET_MULTI_CHUNK_WRITE_SAME_SPACE_READ_TEST_DSET_SPACE_RANK * sizeof(hsize_t)))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset dimensionality\n");
goto error;
}
if (NULL == (chunk_dims = HDmalloc(DATASET_MULTI_CHUNK_WRITE_SAME_SPACE_READ_TEST_DSET_SPACE_RANK *
sizeof(hsize_t)))) {
if (NULL == (chunk_dims = malloc(DATASET_MULTI_CHUNK_WRITE_SAME_SPACE_READ_TEST_DSET_SPACE_RANK *
sizeof(hsize_t)))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset dimensionality\n");
goto error;
@@ -6286,7 +6285,7 @@ test_write_multi_chunk_dataset_same_shape_read(void)
}
}
if (NULL == (write_buf = HDmalloc(data_size))) {
if (NULL == (write_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset write\n");
INDEPENDENT_OP_ERROR(dset_create);
@@ -6360,7 +6359,7 @@ test_write_multi_chunk_dataset_same_shape_read(void)
}
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
@@ -6527,12 +6526,12 @@ test_write_multi_chunk_dataset_same_shape_read(void)
}
if (chunk_dims) {
HDfree(chunk_dims);
free(chunk_dims);
chunk_dims = NULL;
}
if (dims) {
HDfree(dims);
free(dims);
dims = NULL;
}
@@ -6559,11 +6558,11 @@ error:
H5E_BEGIN_TRY
{
if (write_buf)
HDfree(write_buf);
free(write_buf);
if (chunk_dims)
HDfree(chunk_dims);
free(chunk_dims);
if (dims)
HDfree(dims);
free(dims);
H5Pclose(dcpl_id);
H5Sclose(mspace_id);
H5Sclose(fspace_id);
@@ -6629,14 +6628,14 @@ test_write_multi_chunk_dataset_diff_shape_read(void)
}
if (NULL ==
(dims = HDmalloc(DATASET_MULTI_CHUNK_WRITE_DIFF_SPACE_READ_TEST_DSET_SPACE_RANK * sizeof(hsize_t)))) {
(dims = malloc(DATASET_MULTI_CHUNK_WRITE_DIFF_SPACE_READ_TEST_DSET_SPACE_RANK * sizeof(hsize_t)))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset dimensionality\n");
goto error;
}
if (NULL == (chunk_dims = HDmalloc(DATASET_MULTI_CHUNK_WRITE_DIFF_SPACE_READ_TEST_DSET_SPACE_RANK *
sizeof(hsize_t)))) {
if (NULL == (chunk_dims = malloc(DATASET_MULTI_CHUNK_WRITE_DIFF_SPACE_READ_TEST_DSET_SPACE_RANK *
sizeof(hsize_t)))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset dimensionality\n");
goto error;
@@ -6749,7 +6748,7 @@ test_write_multi_chunk_dataset_diff_shape_read(void)
}
}
if (NULL == (write_buf = HDmalloc(data_size))) {
if (NULL == (write_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset write\n");
INDEPENDENT_OP_ERROR(dset_create);
@@ -6823,7 +6822,7 @@ test_write_multi_chunk_dataset_diff_shape_read(void)
}
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
@@ -6992,12 +6991,12 @@ test_write_multi_chunk_dataset_diff_shape_read(void)
}
if (chunk_dims) {
HDfree(chunk_dims);
free(chunk_dims);
chunk_dims = NULL;
}
if (dims) {
HDfree(dims);
free(dims);
dims = NULL;
}
@@ -7024,11 +7023,11 @@ error:
H5E_BEGIN_TRY
{
if (write_buf)
HDfree(write_buf);
free(write_buf);
if (chunk_dims)
HDfree(chunk_dims);
free(chunk_dims);
if (dims)
HDfree(dims);
free(dims);
H5Pclose(dcpl_id);
H5Sclose(mspace_id);
H5Sclose(fspace_id);
@@ -7093,15 +7092,15 @@ test_overwrite_multi_chunk_dataset_same_shape_read(void)
return 0;
}
if (NULL == (dims = HDmalloc(DATASET_MULTI_CHUNK_OVERWRITE_SAME_SPACE_READ_TEST_DSET_SPACE_RANK *
sizeof(hsize_t)))) {
if (NULL == (dims = malloc(DATASET_MULTI_CHUNK_OVERWRITE_SAME_SPACE_READ_TEST_DSET_SPACE_RANK *
sizeof(hsize_t)))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset dimensionality\n");
goto error;
}
if (NULL == (chunk_dims = HDmalloc(DATASET_MULTI_CHUNK_OVERWRITE_SAME_SPACE_READ_TEST_DSET_SPACE_RANK *
sizeof(hsize_t)))) {
if (NULL == (chunk_dims = malloc(DATASET_MULTI_CHUNK_OVERWRITE_SAME_SPACE_READ_TEST_DSET_SPACE_RANK *
sizeof(hsize_t)))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset dimensionality\n");
goto error;
@@ -7222,7 +7221,7 @@ test_overwrite_multi_chunk_dataset_same_shape_read(void)
}
}
if (NULL == (write_buf = HDmalloc(data_size))) {
if (NULL == (write_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset write\n");
INDEPENDENT_OP_ERROR(dset_create);
@@ -7514,17 +7513,17 @@ test_overwrite_multi_chunk_dataset_same_shape_read(void)
}
if (chunk_dims) {
HDfree(chunk_dims);
free(chunk_dims);
chunk_dims = NULL;
}
if (dims) {
HDfree(dims);
free(dims);
dims = NULL;
}
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
@@ -7547,11 +7546,11 @@ error:
H5E_BEGIN_TRY
{
if (write_buf)
HDfree(write_buf);
free(write_buf);
if (chunk_dims)
HDfree(chunk_dims);
free(chunk_dims);
if (dims)
HDfree(dims);
free(dims);
H5Pclose(dcpl_id);
H5Sclose(mspace_id);
H5Sclose(fspace_id);
@@ -7619,15 +7618,15 @@ test_overwrite_multi_chunk_dataset_diff_shape_read(void)
return 0;
}
if (NULL == (dims = HDmalloc(DATASET_MULTI_CHUNK_OVERWRITE_DIFF_SPACE_READ_TEST_DSET_SPACE_RANK *
sizeof(hsize_t)))) {
if (NULL == (dims = malloc(DATASET_MULTI_CHUNK_OVERWRITE_DIFF_SPACE_READ_TEST_DSET_SPACE_RANK *
sizeof(hsize_t)))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset dimensionality\n");
goto error;
}
if (NULL == (chunk_dims = HDmalloc(DATASET_MULTI_CHUNK_OVERWRITE_DIFF_SPACE_READ_TEST_DSET_SPACE_RANK *
sizeof(hsize_t)))) {
if (NULL == (chunk_dims = malloc(DATASET_MULTI_CHUNK_OVERWRITE_DIFF_SPACE_READ_TEST_DSET_SPACE_RANK *
sizeof(hsize_t)))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset dimensionality\n");
goto error;
@@ -7748,7 +7747,7 @@ test_overwrite_multi_chunk_dataset_diff_shape_read(void)
}
}
if (NULL == (write_buf = HDmalloc(data_size))) {
if (NULL == (write_buf = malloc(data_size))) {
H5_FAILED();
printf(" couldn't allocate buffer for dataset write\n");
INDEPENDENT_OP_ERROR(dset_create);
@@ -8042,17 +8041,17 @@ test_overwrite_multi_chunk_dataset_diff_shape_read(void)
}
if (chunk_dims) {
HDfree(chunk_dims);
free(chunk_dims);
chunk_dims = NULL;
}
if (dims) {
HDfree(dims);
free(dims);
dims = NULL;
}
if (write_buf) {
HDfree(write_buf);
free(write_buf);
write_buf = NULL;
}
@@ -8075,11 +8074,11 @@ error:
H5E_BEGIN_TRY
{
if (write_buf)
HDfree(write_buf);
free(write_buf);
if (chunk_dims)
HDfree(chunk_dims);
free(chunk_dims);
if (dims)
HDfree(dims);
free(dims);
H5Pclose(dcpl_id);
H5Sclose(mspace_id);
H5Sclose(fspace_id);
testpar/API/H5_api_test_parallel.c
+3 -3
View File
@@ -141,7 +141,7 @@ generate_random_parallel_dimensions(int space_rank, hsize_t **dims_out)
if (space_rank <= 0)
goto error;
if (NULL == (dims = HDmalloc((size_t)space_rank * sizeof(hsize_t))))
if (NULL == (dims = malloc((size_t)space_rank * sizeof(hsize_t))))
goto error;
if (MAINPROCESS) {
for (i = 0; i < (size_t)space_rank; i++) {
@@ -164,7 +164,7 @@ generate_random_parallel_dimensions(int space_rank, hsize_t **dims_out)
error:
if (dims)
HDfree(dims);
free(dims);
return -1;
}
@@ -445,7 +445,7 @@ main(int argc, char **argv)
HDexit(EXIT_SUCCESS);
error:
HDfree(vol_connector_string_copy);
free(vol_connector_string_copy);
H5E_BEGIN_TRY
{
testpar/API/t_bigio.c
+19 -19
View File
@@ -477,7 +477,7 @@ dataset_big_write(void)
B_DATATYPE *wdata;
/* allocate memory for data buffer */
wdata = (B_DATATYPE *)HDmalloc(bigcount * sizeof(B_DATATYPE));
wdata = (B_DATATYPE *)malloc(bigcount * sizeof(B_DATATYPE));
VRFY_G((wdata != NULL), "wdata malloc succeeded");
/* setup file access template */
@@ -700,7 +700,7 @@ dataset_big_write(void)
num_points = bigcount;
coords = (hsize_t *)HDmalloc(num_points * RANK * sizeof(hsize_t));
coords = (hsize_t *)malloc(num_points * RANK * sizeof(hsize_t));
VRFY_G((coords != NULL), "coords malloc succeeded");
set_coords(start, count, stride, block, num_points, coords, IN_ORDER);
@@ -749,7 +749,7 @@ dataset_big_write(void)
ret = H5Dclose(dataset);
VRFY_G((ret >= 0), "H5Dclose1 succeeded");
HDfree(wdata);
free(wdata);
H5Fclose(fid);
}
@@ -782,9 +782,9 @@ dataset_big_read(void)
herr_t ret; /* Generic return value */
/* allocate memory for data buffer */
rdata = (B_DATATYPE *)HDmalloc(bigcount * sizeof(B_DATATYPE));
rdata = (B_DATATYPE *)malloc(bigcount * sizeof(B_DATATYPE));
VRFY_G((rdata != NULL), "rdata malloc succeeded");
wdata = (B_DATATYPE *)HDmalloc(bigcount * sizeof(B_DATATYPE));
wdata = (B_DATATYPE *)malloc(bigcount * sizeof(B_DATATYPE));
VRFY_G((wdata != NULL), "wdata malloc succeeded");
HDmemset(rdata, 0, bigcount * sizeof(B_DATATYPE));
@@ -1020,7 +1020,7 @@ dataset_big_read(void)
num_points = bigcount;
coords = (hsize_t *)HDmalloc(num_points * RANK * sizeof(hsize_t));
coords = (hsize_t *)malloc(num_points * RANK * sizeof(hsize_t));
VRFY_G((coords != NULL), "coords malloc succeeded");
set_coords(start, count, stride, block, num_points, coords, IN_ORDER);
@@ -1031,7 +1031,7 @@ dataset_big_read(void)
VRFY_G((ret >= 0), "H5Sselect_elements succeeded");
if (coords)
HDfree(coords);
free(coords);
/* create a memory dataspace */
/* Warning: H5Screate_simple requires an array of hsize_t elements
@@ -1068,8 +1068,8 @@ dataset_big_read(void)
ret = H5Dclose(dataset);
VRFY_G((ret >= 0), "H5Dclose1 succeeded");
HDfree(wdata);
HDfree(rdata);
free(wdata);
free(rdata);
wdata = NULL;
rdata = NULL;
@@ -1096,9 +1096,9 @@ dataset_big_read(void)
/* release data buffers */
if (rdata)
HDfree(rdata);
free(rdata);
if (wdata)
HDfree(wdata);
free(wdata);
} /* dataset_large_readAll */
@@ -1448,7 +1448,7 @@ coll_chunktest(const char *filename, int chunk_factor, int select_factor, int ap
dims[1] = space_dim2;
/* allocate memory for data buffer */
data_array1 = (int *)HDmalloc(dims[0] * dims[1] * sizeof(int));
data_array1 = (int *)malloc(dims[0] * dims[1] * sizeof(int));
VRFY_G((data_array1 != NULL), "data_array1 malloc succeeded");
/* set up dimensions of the slab this process accesses */
@@ -1456,7 +1456,7 @@ coll_chunktest(const char *filename, int chunk_factor, int select_factor, int ap
/* set up the coords array selection */
num_points = block[0] * block[1] * count[0] * count[1];
coords = (hsize_t *)HDmalloc(num_points * RANK * sizeof(hsize_t));
coords = (hsize_t *)malloc(num_points * RANK * sizeof(hsize_t));
VRFY_G((coords != NULL), "coords malloc succeeded");
point_set(start, count, stride, block, num_points, coords, mode);
@@ -1715,16 +1715,16 @@ coll_chunktest(const char *filename, int chunk_factor, int select_factor, int ap
VRFY_G((status >= 0), "");
if (data_array1)
HDfree(data_array1);
free(data_array1);
/* Use collective read to verify the correctness of collective write. */
/* allocate memory for data buffer */
data_array1 = (int *)HDmalloc(dims[0] * dims[1] * sizeof(int));
data_array1 = (int *)malloc(dims[0] * dims[1] * sizeof(int));
VRFY_G((data_array1 != NULL), "data_array1 malloc succeeded");
/* allocate memory for data buffer */
data_origin1 = (int *)HDmalloc(dims[0] * dims[1] * sizeof(int));
data_origin1 = (int *)malloc(dims[0] * dims[1] * sizeof(int));
VRFY_G((data_origin1 != NULL), "data_origin1 malloc succeeded");
acc_plist = create_faccess_plist(comm, info, facc_type);
@@ -1847,11 +1847,11 @@ coll_chunktest(const char *filename, int chunk_factor, int select_factor, int ap
/* release data buffers */
if (coords)
HDfree(coords);
free(coords);
if (data_array1)
HDfree(data_array1);
free(data_array1);
if (data_origin1)
HDfree(data_origin1);
free(data_origin1);
}
int
testpar/API/t_coll_chunk.c
+8 -8
View File
@@ -789,7 +789,7 @@ coll_chunktest(const char *filename, int chunk_factor, int select_factor, int ap
dims[1] = SPACE_DIM2;
/* allocate memory for data buffer */
data_array1 = (int *)HDmalloc(dims[0] * dims[1] * sizeof(int));
data_array1 = (int *)malloc(dims[0] * dims[1] * sizeof(int));
VRFY((data_array1 != NULL), "data_array1 malloc succeeded");
/* set up dimensions of the slab this process accesses */
@@ -797,7 +797,7 @@ coll_chunktest(const char *filename, int chunk_factor, int select_factor, int ap
/* set up the coords array selection */
num_points = block[0] * block[1] * count[0] * count[1];
coords = (hsize_t *)HDmalloc(num_points * RANK * sizeof(hsize_t));
coords = (hsize_t *)malloc(num_points * RANK * sizeof(hsize_t));
VRFY((coords != NULL), "coords malloc succeeded");
point_set(start, count, stride, block, num_points, coords, mode);
@@ -1054,16 +1054,16 @@ coll_chunktest(const char *filename, int chunk_factor, int select_factor, int ap
VRFY((status >= 0), "");
if (data_array1)
HDfree(data_array1);
free(data_array1);
/* Use collective read to verify the correctness of collective write. */
/* allocate memory for data buffer */
data_array1 = (int *)HDmalloc(dims[0] * dims[1] * sizeof(int));
data_array1 = (int *)malloc(dims[0] * dims[1] * sizeof(int));
VRFY((data_array1 != NULL), "data_array1 malloc succeeded");
/* allocate memory for data buffer */
data_origin1 = (int *)HDmalloc(dims[0] * dims[1] * sizeof(int));
data_origin1 = (int *)malloc(dims[0] * dims[1] * sizeof(int));
VRFY((data_origin1 != NULL), "data_origin1 malloc succeeded");
acc_plist = create_faccess_plist(comm, info, facc_type);
@@ -1182,11 +1182,11 @@ coll_chunktest(const char *filename, int chunk_factor, int select_factor, int ap
/* release data buffers */
if (coords)
HDfree(coords);
free(coords);
if (data_array1)
HDfree(data_array1);
free(data_array1);
if (data_origin1)
HDfree(data_origin1);
free(data_origin1);
}
/* Set up the selection */
testpar/API/t_coll_md_read.c
+14 -14
View File
@@ -113,7 +113,7 @@ test_partial_no_selection_coll_md_read(void)
file_id = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl_id);
VRFY((file_id >= 0), "H5Fcreate succeeded");
dataset_dims = HDmalloc(PARTIAL_NO_SELECTION_DATASET_NDIMS * sizeof(*dataset_dims));
dataset_dims = malloc(PARTIAL_NO_SELECTION_DATASET_NDIMS * sizeof(*dataset_dims));
VRFY((dataset_dims != NULL), "malloc succeeded");
dataset_dims[0] = (hsize_t)PARTIAL_NO_SELECTION_Y_DIM_SCALE * (hsize_t)mpi_size;
@@ -159,8 +159,8 @@ test_partial_no_selection_coll_md_read(void)
mspace_id = H5Screate_simple(1, sel_dims, NULL);
VRFY((mspace_id >= 0), "H5Screate_simple succeeded");
data = HDcalloc(1, count[1] * (PARTIAL_NO_SELECTION_Y_DIM_SCALE * PARTIAL_NO_SELECTION_X_DIM_SCALE) *
sizeof(int));
data = calloc(1, count[1] * (PARTIAL_NO_SELECTION_Y_DIM_SCALE * PARTIAL_NO_SELECTION_X_DIM_SCALE) *
sizeof(int));
VRFY((data != NULL), "calloc succeeded");
dxpl_id = H5Pcreate(H5P_DATASET_XFER);
@@ -183,8 +183,8 @@ test_partial_no_selection_coll_md_read(void)
VRFY((H5Pset_dxpl_mpio_chunk_opt(dxpl_id, H5FD_MPIO_CHUNK_ONE_IO) >= 0),
"H5Pset_dxpl_mpio_chunk_opt succeeded");
read_buf = HDmalloc(count[1] * (PARTIAL_NO_SELECTION_Y_DIM_SCALE * PARTIAL_NO_SELECTION_X_DIM_SCALE) *
sizeof(int));
read_buf = malloc(count[1] * (PARTIAL_NO_SELECTION_Y_DIM_SCALE * PARTIAL_NO_SELECTION_X_DIM_SCALE) *
sizeof(int));
VRFY((read_buf != NULL), "malloc succeeded");
/*
@@ -212,17 +212,17 @@ test_partial_no_selection_coll_md_read(void)
}
if (dataset_dims) {
HDfree(dataset_dims);
free(dataset_dims);
dataset_dims = NULL;
}
if (data) {
HDfree(data);
free(data);
data = NULL;
}
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
@@ -346,13 +346,13 @@ test_multi_chunk_io_addrmap_issue(void)
VRFY((H5Fflush(file_id, H5F_SCOPE_GLOBAL) >= 0), "H5Fflush succeeded");
read_buf = HDmalloc(50 * sizeof(int));
read_buf = malloc(50 * sizeof(int));
VRFY((read_buf != NULL), "malloc succeeded");
VRFY((H5Dread(dset_id, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, dxpl_id, read_buf) >= 0), "H5Dread succeeded");
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
@@ -509,7 +509,7 @@ test_link_chunk_io_sort_chunk_issue(void)
mspace_id = H5Screate_simple(1, sel_dims, NULL);
VRFY((mspace_id >= 0), "H5Screate_simple succeeded");
data = HDcalloc(1, count[0] * sizeof(int));
data = calloc(1, count[0] * sizeof(int));
VRFY((data != NULL), "calloc succeeded");
dxpl_id = H5Pcreate(H5P_DATASET_XFER);
@@ -532,7 +532,7 @@ test_link_chunk_io_sort_chunk_issue(void)
VRFY((H5Pset_dxpl_mpio_chunk_opt(dxpl_id, H5FD_MPIO_CHUNK_ONE_IO) >= 0),
"H5Pset_dxpl_mpio_chunk_opt succeeded");
read_buf = HDmalloc(count[0] * sizeof(int));
read_buf = malloc(count[0] * sizeof(int));
VRFY((read_buf != NULL), "malloc succeeded");
VRFY((H5Sselect_hyperslab(fspace_id, H5S_SELECT_SET, start, stride, count, block) >= 0),
@@ -552,12 +552,12 @@ test_link_chunk_io_sort_chunk_issue(void)
"H5Dread succeeded");
if (data) {
HDfree(data);
free(data);
data = NULL;
}
if (read_buf) {
HDfree(read_buf);
free(read_buf);
read_buf = NULL;
}
testpar/API/t_dset.c
+81 -81
View File
@@ -316,8 +316,8 @@ dataset_writeInd(void)
}
/* allocate memory for data buffer */
data_array1 = (DATATYPE *)HDmalloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
VRFY((data_array1 != NULL), "data_array1 HDmalloc succeeded");
data_array1 = (DATATYPE *)malloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
VRFY((data_array1 != NULL), "data_array1 malloc succeeded");
/* ----------------------------------------
* CREATE AN HDF5 FILE WITH PARALLEL ACCESS
@@ -419,7 +419,7 @@ dataset_writeInd(void)
/* release data buffers */
if (data_array1)
HDfree(data_array1);
free(data_array1);
}
/* Example of using the parallel HDF5 library to read a dataset */
@@ -467,10 +467,10 @@ dataset_readInd(void)
}
/* allocate memory for data buffer */
data_array1 = (DATATYPE *)HDmalloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
VRFY((data_array1 != NULL), "data_array1 HDmalloc succeeded");
data_origin1 = (DATATYPE *)HDmalloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
VRFY((data_origin1 != NULL), "data_origin1 HDmalloc succeeded");
data_array1 = (DATATYPE *)malloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
VRFY((data_array1 != NULL), "data_array1 malloc succeeded");
data_origin1 = (DATATYPE *)malloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
VRFY((data_origin1 != NULL), "data_origin1 malloc succeeded");
/* setup file access template */
acc_tpl = create_faccess_plist(comm, info, facc_type);
@@ -540,9 +540,9 @@ dataset_readInd(void)
/* release data buffers */
if (data_array1)
HDfree(data_array1);
free(data_array1);
if (data_origin1)
HDfree(data_origin1);
free(data_origin1);
}
/*
@@ -611,12 +611,12 @@ dataset_writeAll(void)
/* set up the coords array selection */
num_points = (size_t)dim1;
coords = (hsize_t *)HDmalloc((size_t)dim1 * (size_t)RANK * sizeof(hsize_t));
coords = (hsize_t *)malloc((size_t)dim1 * (size_t)RANK * sizeof(hsize_t));
VRFY((coords != NULL), "coords malloc succeeded");
/* allocate memory for data buffer */
data_array1 = (DATATYPE *)HDmalloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
VRFY((data_array1 != NULL), "data_array1 HDmalloc succeeded");
data_array1 = (DATATYPE *)malloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
VRFY((data_array1 != NULL), "data_array1 malloc succeeded");
/* -------------------
* START AN HDF5 FILE
@@ -927,7 +927,7 @@ dataset_writeAll(void)
if (data_array1)
free(data_array1);
data_array1 = (DATATYPE *)HDmalloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
data_array1 = (DATATYPE *)malloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
VRFY((data_array1 != NULL), "data_array1 malloc succeeded");
block[0] = 1;
@@ -1076,9 +1076,9 @@ dataset_writeAll(void)
/* release data buffers */
if (coords)
HDfree(coords);
free(coords);
if (data_array1)
HDfree(data_array1);
free(data_array1);
}
/*
@@ -1140,14 +1140,14 @@ dataset_readAll(void)
/* set up the coords array selection */
num_points = (size_t)dim1;
coords = (hsize_t *)HDmalloc((size_t)dim0 * (size_t)dim1 * RANK * sizeof(hsize_t));
coords = (hsize_t *)malloc((size_t)dim0 * (size_t)dim1 * RANK * sizeof(hsize_t));
VRFY((coords != NULL), "coords malloc succeeded");
/* allocate memory for data buffer */
data_array1 = (DATATYPE *)HDmalloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
VRFY((data_array1 != NULL), "data_array1 HDmalloc succeeded");
data_origin1 = (DATATYPE *)HDmalloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
VRFY((data_origin1 != NULL), "data_origin1 HDmalloc succeeded");
data_array1 = (DATATYPE *)malloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
VRFY((data_array1 != NULL), "data_array1 malloc succeeded");
data_origin1 = (DATATYPE *)malloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
VRFY((data_origin1 != NULL), "data_origin1 malloc succeeded");
/* -------------------
* OPEN AN HDF5 FILE
@@ -1323,9 +1323,9 @@ dataset_readAll(void)
free(data_array1);
if (data_origin1)
free(data_origin1);
data_array1 = (DATATYPE *)HDmalloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
data_array1 = (DATATYPE *)malloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
VRFY((data_array1 != NULL), "data_array1 malloc succeeded");
data_origin1 = (DATATYPE *)HDmalloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
data_origin1 = (DATATYPE *)malloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
VRFY((data_origin1 != NULL), "data_origin1 malloc succeeded");
block[0] = 1;
@@ -1384,7 +1384,7 @@ dataset_readAll(void)
if (data_array1)
free(data_array1);
data_array1 = (DATATYPE *)HDmalloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
data_array1 = (DATATYPE *)malloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
VRFY((data_array1 != NULL), "data_array1 malloc succeeded");
/* Dataset6: point selection in File - Point selection in Memory*/
@@ -1430,7 +1430,7 @@ dataset_readAll(void)
if (data_array1)
free(data_array1);
data_array1 = (DATATYPE *)HDmalloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
data_array1 = (DATATYPE *)malloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
VRFY((data_array1 != NULL), "data_array1 malloc succeeded");
/* Dataset7: point selection in memory - All selection in file*/
@@ -1498,11 +1498,11 @@ dataset_readAll(void)
/* release data buffers */
if (coords)
HDfree(coords);
free(coords);
if (data_array1)
HDfree(data_array1);
free(data_array1);
if (data_origin1)
HDfree(data_origin1);
free(data_origin1);
}
/*
@@ -1570,8 +1570,8 @@ extend_writeInd(void)
chunk_dims[1] = (hsize_t)chunkdim1;
/* allocate memory for data buffer */
data_array1 = (DATATYPE *)HDmalloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
VRFY((data_array1 != NULL), "data_array1 HDmalloc succeeded");
data_array1 = (DATATYPE *)malloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
VRFY((data_array1 != NULL), "data_array1 malloc succeeded");
/* -------------------
* START AN HDF5 FILE
@@ -1742,7 +1742,7 @@ extend_writeInd(void)
/* release data buffers */
if (data_array1)
HDfree(data_array1);
free(data_array1);
}
/*
@@ -1969,12 +1969,12 @@ extend_readInd(void)
}
/* allocate memory for data buffer */
data_array1 = (DATATYPE *)HDmalloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
VRFY((data_array1 != NULL), "data_array1 HDmalloc succeeded");
data_array2 = (DATATYPE *)HDmalloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
VRFY((data_array2 != NULL), "data_array2 HDmalloc succeeded");
data_origin1 = (DATATYPE *)HDmalloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
VRFY((data_origin1 != NULL), "data_origin1 HDmalloc succeeded");
data_array1 = (DATATYPE *)malloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
VRFY((data_array1 != NULL), "data_array1 malloc succeeded");
data_array2 = (DATATYPE *)malloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
VRFY((data_array2 != NULL), "data_array2 malloc succeeded");
data_origin1 = (DATATYPE *)malloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
VRFY((data_origin1 != NULL), "data_origin1 malloc succeeded");
/* -------------------
* OPEN AN HDF5 FILE
@@ -2094,11 +2094,11 @@ extend_readInd(void)
/* release data buffers */
if (data_array1)
HDfree(data_array1);
free(data_array1);
if (data_array2)
HDfree(data_array2);
free(data_array2);
if (data_origin1)
HDfree(data_origin1);
free(data_origin1);
}
/*
@@ -2167,8 +2167,8 @@ extend_writeAll(void)
chunk_dims[1] = (hsize_t)chunkdim1;
/* allocate memory for data buffer */
data_array1 = (DATATYPE *)HDmalloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
VRFY((data_array1 != NULL), "data_array1 HDmalloc succeeded");
data_array1 = (DATATYPE *)malloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
VRFY((data_array1 != NULL), "data_array1 malloc succeeded");
/* -------------------
* START AN HDF5 FILE
@@ -2362,7 +2362,7 @@ extend_writeAll(void)
/* release data buffers */
if (data_array1)
HDfree(data_array1);
free(data_array1);
}
/* Example of using the parallel HDF5 library to read an extendible dataset */
@@ -2413,12 +2413,12 @@ extend_readAll(void)
}
/* allocate memory for data buffer */
data_array1 = (DATATYPE *)HDmalloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
VRFY((data_array1 != NULL), "data_array1 HDmalloc succeeded");
data_array2 = (DATATYPE *)HDmalloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
VRFY((data_array2 != NULL), "data_array2 HDmalloc succeeded");
data_origin1 = (DATATYPE *)HDmalloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
VRFY((data_origin1 != NULL), "data_origin1 HDmalloc succeeded");
data_array1 = (DATATYPE *)malloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
VRFY((data_array1 != NULL), "data_array1 malloc succeeded");
data_array2 = (DATATYPE *)malloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
VRFY((data_array2 != NULL), "data_array2 malloc succeeded");
data_origin1 = (DATATYPE *)malloc((size_t)dim0 * (size_t)dim1 * sizeof(DATATYPE));
VRFY((data_origin1 != NULL), "data_origin1 malloc succeeded");
/* -------------------
* OPEN AN HDF5 FILE
@@ -2560,11 +2560,11 @@ extend_readAll(void)
/* release data buffers */
if (data_array1)
HDfree(data_array1);
free(data_array1);
if (data_array2)
HDfree(data_array2);
free(data_array2);
if (data_origin1)
HDfree(data_origin1);
free(data_origin1);
}
#ifdef H5_HAVE_FILTER_DEFLATE
@@ -2614,10 +2614,10 @@ compress_readAll(void)
}
/* Allocate data buffer */
data_orig = (DATATYPE *)HDmalloc((size_t)dim * sizeof(DATATYPE));
VRFY((data_orig != NULL), "data_origin1 HDmalloc succeeded");
data_read = (DATATYPE *)HDmalloc((size_t)dim * sizeof(DATATYPE));
VRFY((data_read != NULL), "data_array1 HDmalloc succeeded");
data_orig = (DATATYPE *)malloc((size_t)dim * sizeof(DATATYPE));
VRFY((data_orig != NULL), "data_origin1 malloc succeeded");
data_read = (DATATYPE *)malloc((size_t)dim * sizeof(DATATYPE));
VRFY((data_read != NULL), "data_array1 malloc succeeded");
/* Initialize data buffers */
for (u = 0; u < dim; u++)
@@ -2750,9 +2750,9 @@ compress_readAll(void)
/* release data buffers */
if (data_read)
HDfree(data_read);
free(data_read);
if (data_orig)
HDfree(data_orig);
free(data_orig);
}
#endif /* H5_HAVE_FILTER_DEFLATE */
@@ -2874,11 +2874,11 @@ none_selection_chunk(void)
/* allocate memory for data buffer. Only allocate enough buffer for
* each processor's data. */
if (mpi_rank) {
data_origin = (DATATYPE *)HDmalloc(block[0] * block[1] * sizeof(DATATYPE));
VRFY((data_origin != NULL), "data_origin HDmalloc succeeded");
data_origin = (DATATYPE *)malloc(block[0] * block[1] * sizeof(DATATYPE));
VRFY((data_origin != NULL), "data_origin malloc succeeded");
data_array = (DATATYPE *)HDmalloc(block[0] * block[1] * sizeof(DATATYPE));
VRFY((data_array != NULL), "data_array HDmalloc succeeded");
data_array = (DATATYPE *)malloc(block[0] * block[1] * sizeof(DATATYPE));
VRFY((data_array != NULL), "data_array malloc succeeded");
/* put some trivial data in the data_array */
mstart[0] = mstart[1] = 0;
@@ -2973,9 +2973,9 @@ none_selection_chunk(void)
/* release data buffers */
if (data_origin)
HDfree(data_origin);
free(data_origin);
if (data_array)
HDfree(data_array);
free(data_array);
}
/* Function: test_actual_io_mode
@@ -3333,8 +3333,8 @@ test_actual_io_mode(int selection_mode)
length = dim0 * dim1;
/* Allocate and initialize the buffer */
buffer = (int *)HDmalloc(sizeof(int) * (size_t)length);
VRFY((buffer != NULL), "HDmalloc of buffer succeeded");
buffer = (int *)malloc(sizeof(int) * (size_t)length);
VRFY((buffer != NULL), "malloc of buffer succeeded");
for (i = 0; i < length; i++)
buffer[i] = i;
@@ -3484,7 +3484,7 @@ test_actual_io_mode(int selection_mode)
VRFY((ret >= 0), "H5Sclose succeeded");
ret = H5Fclose(fid);
VRFY((ret >= 0), "H5Fclose succeeded");
HDfree(buffer);
free(buffer);
return;
}
@@ -3768,8 +3768,8 @@ test_no_collective_cause_mode(int selection_mode)
length = (int)(dims[0] * dims[1]);
/* Allocate and initialize the buffer */
buffer = (int *)HDmalloc(sizeof(int) * (size_t)length);
VRFY((buffer != NULL), "HDmalloc of buffer succeeded");
buffer = (int *)malloc(sizeof(int) * (size_t)length);
VRFY((buffer != NULL), "malloc of buffer succeeded");
for (i = 0; i < length; i++)
buffer[i] = i;
@@ -3861,7 +3861,7 @@ test_no_collective_cause_mode(int selection_mode)
H5Sclose(file_space);
if (fid)
H5Fclose(fid);
HDfree(buffer);
free(buffer);
/* clean up external file */
if (selection_mode & TEST_NOT_CONTIGUOUS_OR_CHUNKED_DATASET_EXTERNAL)
@@ -3971,11 +3971,11 @@ dataset_atomicity(void)
buf_size = dim0 * dim1;
/* allocate memory for data buffer */
write_buf = (int *)HDcalloc((size_t)buf_size, sizeof(int));
VRFY((write_buf != NULL), "write_buf HDcalloc succeeded");
write_buf = (int *)calloc((size_t)buf_size, sizeof(int));
VRFY((write_buf != NULL), "write_buf calloc succeeded");
/* allocate memory for data buffer */
read_buf = (int *)HDcalloc((size_t)buf_size, sizeof(int));
VRFY((read_buf != NULL), "read_buf HDcalloc succeeded");
read_buf = (int *)calloc((size_t)buf_size, sizeof(int));
VRFY((read_buf != NULL), "read_buf calloc succeeded");
/* setup file access template */
acc_tpl = create_faccess_plist(comm, info, facc_type);
@@ -4123,20 +4123,20 @@ dataset_atomicity(void)
/* release data buffers */
if (write_buf)
HDfree(write_buf);
free(write_buf);
if (read_buf)
HDfree(read_buf);
free(read_buf);
/* open dataset2 (non-contiguous case) */
dataset2 = H5Dopen2(fid, DATASETNAME6, H5P_DEFAULT);
VRFY((dataset2 >= 0), "H5Dopen2 succeeded");
/* allocate memory for data buffer */
write_buf = (int *)HDcalloc((size_t)buf_size, sizeof(int));
VRFY((write_buf != NULL), "write_buf HDcalloc succeeded");
write_buf = (int *)calloc((size_t)buf_size, sizeof(int));
VRFY((write_buf != NULL), "write_buf calloc succeeded");
/* allocate memory for data buffer */
read_buf = (int *)HDcalloc((size_t)buf_size, sizeof(int));
VRFY((read_buf != NULL), "read_buf HDcalloc succeeded");
read_buf = (int *)calloc((size_t)buf_size, sizeof(int));
VRFY((read_buf != NULL), "read_buf calloc succeeded");
for (i = 0; i < buf_size; i++) {
write_buf[i] = 5;
@@ -4249,9 +4249,9 @@ dataset_atomicity(void)
/* release data buffers */
if (write_buf)
HDfree(write_buf);
free(write_buf);
if (read_buf)
HDfree(read_buf);
free(read_buf);
ret = H5Fclose(fid);
VRFY((ret >= 0), "H5Fclose succeeded");
testpar/API/t_file.c
+8 -8
View File
@@ -192,7 +192,7 @@ test_page_buffer_access(void)
ret = H5Pset_file_space_page_size(fcpl, sizeof(int) * 100);
VRFY((ret == 0), "");
data = (int *)HDmalloc(sizeof(int) * (size_t)num_elements);
data = (int *)malloc(sizeof(int) * (size_t)num_elements);
/* initialize all the elements to have a value of -1 */
for (i = 0; i < num_elements; i++)
@@ -441,7 +441,7 @@ test_page_buffer_access(void)
api_ctx_pushed = FALSE;
}
HDfree(data);
free(data);
data = NULL;
MPI_Barrier(MPI_COMM_WORLD);
}
@@ -515,8 +515,8 @@ create_file(const char *filename, hid_t fcpl, hid_t fapl, int metadata_write_str
num_elements = block[0] * block[1];
/* allocate memory for data buffer */
data_array = (DATATYPE *)HDmalloc(num_elements * sizeof(DATATYPE));
VRFY((data_array != NULL), "data_array HDmalloc succeeded");
data_array = (DATATYPE *)malloc(num_elements * sizeof(DATATYPE));
VRFY((data_array != NULL), "data_array malloc succeeded");
/* put some trivial data in the data_array */
for (i = 0; i < num_elements; i++)
data_array[i] = mpi_rank + 1;
@@ -598,7 +598,7 @@ create_file(const char *filename, hid_t fcpl, hid_t fapl, int metadata_write_str
}
MPI_Barrier(MPI_COMM_WORLD);
HDfree(data_array);
free(data_array);
return 0;
} /* create_file */
@@ -674,8 +674,8 @@ open_file(const char *filename, hid_t fapl, int metadata_write_strategy, hsize_t
num_elements = block[0] * block[1];
/* allocate memory for data buffer */
data_array = (DATATYPE *)HDmalloc(num_elements * sizeof(DATATYPE));
VRFY((data_array != NULL), "data_array HDmalloc succeeded");
data_array = (DATATYPE *)malloc(num_elements * sizeof(DATATYPE));
VRFY((data_array != NULL), "data_array malloc succeeded");
/* create a memory dataspace independently */
mem_dataspace = H5Screate_simple(1, &num_elements, NULL);
@@ -761,7 +761,7 @@ open_file(const char *filename, hid_t fapl, int metadata_write_strategy, hsize_t
api_ctx_pushed = FALSE;
}
HDfree(data_array);
free(data_array);
return nerrors;
}
testpar/API/t_file_image.c
+13 -13
View File
@@ -127,7 +127,7 @@ file_image_daisy_chain_test(void)
* to -1 everywhere else.
*/
vector_ptr = (int *)HDmalloc((size_t)(mpi_size) * sizeof(int));
vector_ptr = (int *)malloc((size_t)(mpi_size) * sizeof(int));
VRFY((vector_ptr != NULL), "allocated in memory representation of vector");
vector_ptr[0] = 0;
@@ -137,7 +137,7 @@ file_image_daisy_chain_test(void)
err = H5Dwrite(dset_id, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, (void *)vector_ptr);
VRFY((err >= 0), "wrote initial data to vector.");
HDfree(vector_ptr);
free(vector_ptr);
vector_ptr = NULL;
/* 3) Flush the core file, and get an image of it. Close
@@ -149,7 +149,7 @@ file_image_daisy_chain_test(void)
image_len = H5Fget_file_image(file_id, NULL, (size_t)0);
VRFY((image_len > 0), "got image file size");
image_ptr = (void *)HDmalloc((size_t)image_len);
image_ptr = (void *)malloc((size_t)image_len);
VRFY(image_ptr != NULL, "allocated file image buffer.");
bytes_read = H5Fget_file_image(file_id, image_ptr, (size_t)image_len);
@@ -175,7 +175,7 @@ file_image_daisy_chain_test(void)
mpi_result = MPI_Ssend((void *)image_ptr, (int)image_len, MPI_BYTE, 1, 0, MPI_COMM_WORLD);
VRFY((mpi_result == MPI_SUCCESS), "sent image to process 1");
HDfree(image_ptr);
free(image_ptr);
image_ptr = NULL;
image_len = 0;
@@ -185,7 +185,7 @@ file_image_daisy_chain_test(void)
MPI_COMM_WORLD, &rcvstat);
VRFY((mpi_result == MPI_SUCCESS), "received image len from process n-1");
image_ptr = (void *)HDmalloc((size_t)image_len);
image_ptr = (void *)malloc((size_t)image_len);
VRFY(image_ptr != NULL, "allocated file image receive buffer.");
mpi_result =
@@ -227,7 +227,7 @@ file_image_daisy_chain_test(void)
VRFY((space_ndims == 1), "verified data space num dims(2)");
VRFY((dims[0] == (hsize_t)mpi_size), "verified data space dims");
vector_ptr = (int *)HDmalloc((size_t)(mpi_size) * sizeof(int));
vector_ptr = (int *)malloc((size_t)(mpi_size) * sizeof(int));
VRFY((vector_ptr != NULL), "allocated in memory rep of vector");
err = H5Dread(dset_id, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, (void *)vector_ptr);
@@ -239,7 +239,7 @@ file_image_daisy_chain_test(void)
vector_ok = FALSE;
VRFY((vector_ok), "verified received vector.");
HDfree(vector_ptr);
free(vector_ptr);
vector_ptr = NULL;
/* 7) closes the core file and exit. */
@@ -256,7 +256,7 @@ file_image_daisy_chain_test(void)
err = H5Pclose(fapl_id);
VRFY((err >= 0), "closed fapl(1).");
HDfree(image_ptr);
free(image_ptr);
image_ptr = NULL;
image_len = 0;
}
@@ -267,7 +267,7 @@ file_image_daisy_chain_test(void)
MPI_COMM_WORLD, &rcvstat);
VRFY((mpi_result == MPI_SUCCESS), "received image size from process mpi_rank-1");
image_ptr = (void *)HDmalloc((size_t)image_len);
image_ptr = (void *)malloc((size_t)image_len);
VRFY(image_ptr != NULL, "allocated file image receive buffer.");
mpi_result =
@@ -310,7 +310,7 @@ file_image_daisy_chain_test(void)
VRFY((space_ndims == 1), "verified data space num dims(2)");
VRFY((dims[0] == (hsize_t)mpi_size), "verified data space dims");
vector_ptr = (int *)HDmalloc((size_t)(mpi_size) * sizeof(int));
vector_ptr = (int *)malloc((size_t)(mpi_size) * sizeof(int));
VRFY((vector_ptr != NULL), "allocated in memory rep of vector");
err = H5Dread(dset_id, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, (void *)vector_ptr);
@@ -336,7 +336,7 @@ file_image_daisy_chain_test(void)
err = H5Dwrite(dset_id, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, (void *)vector_ptr);
VRFY((err >= 0), "wrote modified data to vector.");
HDfree(vector_ptr);
free(vector_ptr);
vector_ptr = NULL;
/* 4) Flush the core file and send it to process (mpi_rank + 1) % n. */
@@ -347,7 +347,7 @@ file_image_daisy_chain_test(void)
image_len = H5Fget_file_image(file_id, NULL, (size_t)0);
VRFY((image_len > 0), "got (possibly modified) image file len");
image_ptr = (void *)HDrealloc((void *)image_ptr, (size_t)image_len);
image_ptr = (void *)realloc((void *)image_ptr, (size_t)image_len);
VRFY(image_ptr != NULL, "re-allocated file image buffer.");
bytes_read = H5Fget_file_image(file_id, image_ptr, (size_t)image_len);
@@ -361,7 +361,7 @@ file_image_daisy_chain_test(void)
MPI_COMM_WORLD);
VRFY((mpi_result == MPI_SUCCESS), "sent image to process (mpi_rank + 1) % mpi_size");
HDfree(image_ptr);
free(image_ptr);
image_ptr = NULL;
image_len = 0;
testpar/API/t_filter_read.c
+6 -6
View File
@@ -129,11 +129,11 @@ filter_read_internal(const char *filename, hid_t dcpl, hsize_t *dset_size)
VRFY(sid >= 0, "H5Screate_simple");
/* Create buffers */
points = (int *)HDmalloc(size[0] * size[1] * sizeof(int));
VRFY(points != NULL, "HDmalloc");
points = (int *)malloc(size[0] * size[1] * sizeof(int));
VRFY(points != NULL, "malloc");
check = (int *)HDmalloc(hs_size[0] * hs_size[1] * sizeof(int));
VRFY(check != NULL, "HDmalloc");
check = (int *)malloc(hs_size[0] * hs_size[1] * sizeof(int));
VRFY(check != NULL, "malloc");
/* Initialize writing buffer with random data */
for (i = 0; i < size[0]; i++)
@@ -227,8 +227,8 @@ filter_read_internal(const char *filename, hid_t dcpl, hsize_t *dset_size)
hrc = H5Fclose(file);
VRFY(hrc >= 0, "H5Fclose");
HDfree(points);
HDfree(check);
free(points);
free(check);
MPI_Barrier(MPI_COMM_WORLD);
}
testpar/API/t_mdset.c
+33 -33
View File
@@ -185,8 +185,8 @@ multiple_dset_write(void)
return;
}
outme = HDmalloc((size_t)size * (size_t)size * sizeof(double));
VRFY((outme != NULL), "HDmalloc succeeded for outme");
outme = malloc((size_t)size * (size_t)size * sizeof(double));
VRFY((outme != NULL), "malloc succeeded for outme");
plist = create_faccess_plist(MPI_COMM_WORLD, MPI_INFO_NULL, facc_type);
VRFY((plist >= 0), "create_faccess_plist succeeded");
@@ -236,7 +236,7 @@ multiple_dset_write(void)
H5Pclose(dcpl);
H5Fclose(iof);
HDfree(outme);
free(outme);
}
/* Example of using PHDF5 to create, write, and read compact dataset.
@@ -275,11 +275,11 @@ compact_dataset(void)
return;
}
outme = HDmalloc((size_t)((size_t)size * (size_t)size * sizeof(double)));
VRFY((outme != NULL), "HDmalloc succeeded for outme");
outme = malloc((size_t)((size_t)size * (size_t)size * sizeof(double)));
VRFY((outme != NULL), "malloc succeeded for outme");
inme = HDmalloc((size_t)size * (size_t)size * sizeof(double));
VRFY((outme != NULL), "HDmalloc succeeded for inme");
inme = malloc((size_t)size * (size_t)size * sizeof(double));
VRFY((outme != NULL), "malloc succeeded for inme");
filename = PARATESTFILE /* GetTestParameters() */;
VRFY((mpi_size <= size), "mpi_size <= size");
@@ -373,8 +373,8 @@ compact_dataset(void)
H5Pclose(dxpl);
H5Dclose(dataset);
H5Fclose(iof);
HDfree(inme);
HDfree(outme);
free(inme);
free(outme);
}
/*
@@ -683,10 +683,10 @@ dataset_fillvalue(void)
dset_size = dset_dims[0] * dset_dims[1] * dset_dims[2] * dset_dims[3];
/* Allocate space for the buffers */
rdata = HDmalloc((size_t)(dset_size * sizeof(int)));
VRFY((rdata != NULL), "HDcalloc succeeded for read buffer");
wdata = HDmalloc((size_t)(dset_size * sizeof(int)));
VRFY((wdata != NULL), "HDmalloc succeeded for write buffer");
rdata = malloc((size_t)(dset_size * sizeof(int)));
VRFY((rdata != NULL), "calloc succeeded for read buffer");
wdata = malloc((size_t)(dset_size * sizeof(int)));
VRFY((wdata != NULL), "malloc succeeded for write buffer");
fapl = create_faccess_plist(MPI_COMM_WORLD, MPI_INFO_NULL, facc_type);
VRFY((fapl >= 0), "create_faccess_plist succeeded");
@@ -885,8 +885,8 @@ dataset_fillvalue(void)
VRFY((ret >= 0), "H5Pclose succeeded");
/* free the buffers */
HDfree(rdata);
HDfree(wdata);
free(rdata);
free(wdata);
}
/* combined cngrpw and ingrpr tests because ingrpr reads file created by cngrpw. */
@@ -945,8 +945,8 @@ collective_group_write(void)
chunk_size[0] = (hsize_t)(size / 2);
chunk_size[1] = (hsize_t)(size / 2);
outme = HDmalloc((size_t)size * (size_t)size * sizeof(DATATYPE));
VRFY((outme != NULL), "HDmalloc succeeded for outme");
outme = malloc((size_t)size * (size_t)size * sizeof(DATATYPE));
VRFY((outme != NULL), "malloc succeeded for outme");
plist = create_faccess_plist(MPI_COMM_WORLD, MPI_INFO_NULL, facc_type);
fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, plist);
@@ -1011,7 +1011,7 @@ collective_group_write(void)
ret1 = H5Fclose(fid);
VRFY((ret1 == 0), "H5Fclose");
HDfree(outme);
free(outme);
}
/* Let two sets of processes open and read different groups and chunked
@@ -1086,11 +1086,11 @@ group_dataset_read(hid_t fid, int mpi_rank, int m)
size = get_size();
indata = (DATATYPE *)HDmalloc((size_t)size * (size_t)size * sizeof(DATATYPE));
VRFY((indata != NULL), "HDmalloc succeeded for indata");
indata = (DATATYPE *)malloc((size_t)size * (size_t)size * sizeof(DATATYPE));
VRFY((indata != NULL), "malloc succeeded for indata");
outdata = (DATATYPE *)HDmalloc((size_t)size * (size_t)size * sizeof(DATATYPE));
VRFY((outdata != NULL), "HDmalloc succeeded for outdata");
outdata = (DATATYPE *)malloc((size_t)size * (size_t)size * sizeof(DATATYPE));
VRFY((outdata != NULL), "malloc succeeded for outdata");
/* open every group under root group. */
HDsnprintf(gname, sizeof(gname), "group%d", m);
@@ -1118,8 +1118,8 @@ group_dataset_read(hid_t fid, int mpi_rank, int m)
ret = H5Gclose(gid);
VRFY((ret == 0), "H5Gclose");
HDfree(indata);
HDfree(outdata);
free(indata);
free(outdata);
}
/*
@@ -1263,8 +1263,8 @@ write_dataset(hid_t memspace, hid_t filespace, hid_t gid)
size = get_size();
outme = HDmalloc((size_t)size * (size_t)size * sizeof(double));
VRFY((outme != NULL), "HDmalloc succeeded for outme");
outme = malloc((size_t)size * (size_t)size * sizeof(double));
VRFY((outme != NULL), "malloc succeeded for outme");
for (n = 0; n < NDATASET; n++) {
HDsnprintf(dname, sizeof(dname), "dataset%d", n);
@@ -1282,7 +1282,7 @@ write_dataset(hid_t memspace, hid_t filespace, hid_t gid)
H5Dclose(did);
}
HDfree(outme);
free(outme);
}
/*
@@ -1426,11 +1426,11 @@ read_dataset(hid_t memspace, hid_t filespace, hid_t gid)
size = get_size();
indata = (DATATYPE *)HDmalloc((size_t)size * (size_t)size * sizeof(DATATYPE));
VRFY((indata != NULL), "HDmalloc succeeded for indata");
indata = (DATATYPE *)malloc((size_t)size * (size_t)size * sizeof(DATATYPE));
VRFY((indata != NULL), "malloc succeeded for indata");
outdata = (DATATYPE *)HDmalloc((size_t)size * (size_t)size * sizeof(DATATYPE));
VRFY((outdata != NULL), "HDmalloc succeeded for outdata");
outdata = (DATATYPE *)malloc((size_t)size * (size_t)size * sizeof(DATATYPE));
VRFY((outdata != NULL), "malloc succeeded for outdata");
for (n = 0; n < NDATASET; n++) {
HDsnprintf(dname, sizeof(dname), "dataset%d", n);
@@ -1457,8 +1457,8 @@ read_dataset(hid_t memspace, hid_t filespace, hid_t gid)
H5Dclose(did);
}
HDfree(indata);
HDfree(outdata);
free(indata);
free(outdata);
return vrfy_errors;
}
testpar/API/t_prop.c
+4 -4
View File
@@ -39,7 +39,7 @@ test_encode_decode(hid_t orig_pl, int mpi_rank, int recv_proc)
ret = H5Pencode2(orig_pl, NULL, &buf_size, H5P_DEFAULT);
VRFY((ret >= 0), "H5Pencode succeeded");
sbuf = (uint8_t *)HDmalloc(buf_size);
sbuf = (uint8_t *)malloc(buf_size);
ret = H5Pencode2(orig_pl, sbuf, &buf_size, H5P_DEFAULT);
VRFY((ret >= 0), "H5Pencode succeeded");
@@ -58,7 +58,7 @@ test_encode_decode(hid_t orig_pl, int mpi_rank, int recv_proc)
MPI_Recv(&recv_size, 1, MPI_INT, 0, 123, MPI_COMM_WORLD, &status);
VRFY((recv_size >= 0), "MPI_Recv succeeded");
buf_size = (size_t)recv_size;
rbuf = (uint8_t *)HDmalloc(buf_size);
rbuf = (uint8_t *)malloc(buf_size);
MPI_Recv(rbuf, recv_size, MPI_BYTE, 0, 124, MPI_COMM_WORLD, &status);
pl = H5Pdecode(rbuf);
@@ -70,7 +70,7 @@ test_encode_decode(hid_t orig_pl, int mpi_rank, int recv_proc)
VRFY((ret >= 0), "H5Pclose succeeded");
if (NULL != rbuf)
HDfree(rbuf);
free(rbuf);
} /* end if */
if (0 == mpi_rank) {
@@ -85,7 +85,7 @@ test_encode_decode(hid_t orig_pl, int mpi_rank, int recv_proc)
}
if (NULL != sbuf)
HDfree(sbuf);
free(sbuf);
MPI_Barrier(MPI_COMM_WORLD);
return 0;
testpar/API/t_pshutdown.c
+3 -3
View File
@@ -99,8 +99,8 @@ main(int argc, char **argv)
VRFY((dset_id >= 0), "H5Dcreate succeeded");
/* allocate memory for data buffer */
data_array = (DATATYPE *)HDmalloc(dims[0] * dims[1] * sizeof(DATATYPE));
VRFY((data_array != NULL), "data_array HDmalloc succeeded");
data_array = (DATATYPE *)malloc(dims[0] * dims[1] * sizeof(DATATYPE));
VRFY((data_array != NULL), "data_array malloc succeeded");
/* Each process takes a slabs of rows. */
block[0] = dims[0] / (hsize_t)mpi_size;
@@ -129,7 +129,7 @@ main(int argc, char **argv)
/* release data buffers */
if (data_array)
HDfree(data_array);
free(data_array);
MPI_Finalize();
testpar/API/t_shapesame.c
+18 -18
View File
@@ -209,28 +209,28 @@ hs_dr_pio_test__setup(const int test_num, const int edge_size, const int checker
tv_ptr->block_ptr = &(tv_ptr->block[PAR_SS_DR_MAX_RANK - tv_ptr->large_rank]);
/* Allocate buffers */
tv_ptr->small_ds_buf_0 = (uint32_t *)HDmalloc(sizeof(uint32_t) * tv_ptr->small_ds_size);
tv_ptr->small_ds_buf_0 = (uint32_t *)malloc(sizeof(uint32_t) * tv_ptr->small_ds_size);
VRFY((tv_ptr->small_ds_buf_0 != NULL), "malloc of small_ds_buf_0 succeeded");
tv_ptr->small_ds_buf_1 = (uint32_t *)HDmalloc(sizeof(uint32_t) * tv_ptr->small_ds_size);
tv_ptr->small_ds_buf_1 = (uint32_t *)malloc(sizeof(uint32_t) * tv_ptr->small_ds_size);
VRFY((tv_ptr->small_ds_buf_1 != NULL), "malloc of small_ds_buf_1 succeeded");
tv_ptr->small_ds_buf_2 = (uint32_t *)HDmalloc(sizeof(uint32_t) * tv_ptr->small_ds_size);
tv_ptr->small_ds_buf_2 = (uint32_t *)malloc(sizeof(uint32_t) * tv_ptr->small_ds_size);
VRFY((tv_ptr->small_ds_buf_2 != NULL), "malloc of small_ds_buf_2 succeeded");
tv_ptr->small_ds_slice_buf = (uint32_t *)HDmalloc(sizeof(uint32_t) * tv_ptr->small_ds_slice_size);
tv_ptr->small_ds_slice_buf = (uint32_t *)malloc(sizeof(uint32_t) * tv_ptr->small_ds_slice_size);
VRFY((tv_ptr->small_ds_slice_buf != NULL), "malloc of small_ds_slice_buf succeeded");
tv_ptr->large_ds_buf_0 = (uint32_t *)HDmalloc(sizeof(uint32_t) * tv_ptr->large_ds_size);
tv_ptr->large_ds_buf_0 = (uint32_t *)malloc(sizeof(uint32_t) * tv_ptr->large_ds_size);
VRFY((tv_ptr->large_ds_buf_0 != NULL), "malloc of large_ds_buf_0 succeeded");
tv_ptr->large_ds_buf_1 = (uint32_t *)HDmalloc(sizeof(uint32_t) * tv_ptr->large_ds_size);
tv_ptr->large_ds_buf_1 = (uint32_t *)malloc(sizeof(uint32_t) * tv_ptr->large_ds_size);
VRFY((tv_ptr->large_ds_buf_1 != NULL), "malloc of large_ds_buf_1 succeeded");
tv_ptr->large_ds_buf_2 = (uint32_t *)HDmalloc(sizeof(uint32_t) * tv_ptr->large_ds_size);
tv_ptr->large_ds_buf_2 = (uint32_t *)malloc(sizeof(uint32_t) * tv_ptr->large_ds_size);
VRFY((tv_ptr->large_ds_buf_2 != NULL), "malloc of large_ds_buf_2 succeeded");
tv_ptr->large_ds_slice_buf = (uint32_t *)HDmalloc(sizeof(uint32_t) * tv_ptr->large_ds_slice_size);
tv_ptr->large_ds_slice_buf = (uint32_t *)malloc(sizeof(uint32_t) * tv_ptr->large_ds_slice_size);
VRFY((tv_ptr->large_ds_slice_buf != NULL), "malloc of large_ds_slice_buf succeeded");
/* initialize the buffers */
@@ -657,22 +657,22 @@ hs_dr_pio_test__takedown(struct hs_dr_pio_test_vars_t *tv_ptr)
/* Free memory buffers */
if (tv_ptr->small_ds_buf_0 != NULL)
HDfree(tv_ptr->small_ds_buf_0);
free(tv_ptr->small_ds_buf_0);
if (tv_ptr->small_ds_buf_1 != NULL)
HDfree(tv_ptr->small_ds_buf_1);
free(tv_ptr->small_ds_buf_1);
if (tv_ptr->small_ds_buf_2 != NULL)
HDfree(tv_ptr->small_ds_buf_2);
free(tv_ptr->small_ds_buf_2);
if (tv_ptr->small_ds_slice_buf != NULL)
HDfree(tv_ptr->small_ds_slice_buf);
free(tv_ptr->small_ds_slice_buf);
if (tv_ptr->large_ds_buf_0 != NULL)
HDfree(tv_ptr->large_ds_buf_0);
free(tv_ptr->large_ds_buf_0);
if (tv_ptr->large_ds_buf_1 != NULL)
HDfree(tv_ptr->large_ds_buf_1);
free(tv_ptr->large_ds_buf_1);
if (tv_ptr->large_ds_buf_2 != NULL)
HDfree(tv_ptr->large_ds_buf_2);
free(tv_ptr->large_ds_buf_2);
if (tv_ptr->large_ds_slice_buf != NULL)
HDfree(tv_ptr->large_ds_slice_buf);
free(tv_ptr->large_ds_slice_buf);
return;
@@ -4364,7 +4364,7 @@ main(int argc, char **argv)
#if 0
HDmemset(filenames, 0, sizeof(filenames));
for (int i = 0; i < NFILENAME; i++) {
if (NULL == (filenames[i] = HDmalloc(PATH_MAX))) {
if (NULL == (filenames[i] = malloc(PATH_MAX))) {
printf("couldn't allocate filename array\n");
MPI_Abort(MPI_COMM_WORLD, -1);
}
@@ -4495,7 +4495,7 @@ main(int argc, char **argv)
#if 0
for (int i = 0; i < NFILENAME; i++) {
HDfree(filenames[i]);
free(filenames[i]);
filenames[i] = NULL;
}
#endif
testpar/API/t_span_tree.c
+18 -18
View File
@@ -337,9 +337,9 @@ coll_write_test(int chunk_factor)
fsdim[0] = FSPACE_DIM1;
fsdim[1] = (hsize_t)(FSPACE_DIM2 * mpi_size);
vector = (int *)HDmalloc(sizeof(int) * (size_t)mdim1[0] * (size_t)mpi_size);
matrix_out = (int *)HDmalloc(sizeof(int) * (size_t)mdim[0] * (size_t)mdim[1] * (size_t)mpi_size);
matrix_out1 = (int *)HDmalloc(sizeof(int) * (size_t)mdim[0] * (size_t)mdim[1] * (size_t)mpi_size);
vector = (int *)malloc(sizeof(int) * (size_t)mdim1[0] * (size_t)mpi_size);
matrix_out = (int *)malloc(sizeof(int) * (size_t)mdim[0] * (size_t)mdim[1] * (size_t)mpi_size);
matrix_out1 = (int *)malloc(sizeof(int) * (size_t)mdim[0] * (size_t)mdim[1] * (size_t)mpi_size);
HDmemset(vector, 0, sizeof(int) * (size_t)mdim1[0] * (size_t)mpi_size);
vector[0] = vector[MSPACE1_DIM * mpi_size - 1] = -1;
@@ -718,11 +718,11 @@ coll_write_test(int chunk_factor)
VRFY((ret >= 0), "");
if (vector)
HDfree(vector);
free(vector);
if (matrix_out)
HDfree(matrix_out);
free(matrix_out);
if (matrix_out1)
HDfree(matrix_out1);
free(matrix_out1);
return;
}
@@ -784,8 +784,8 @@ coll_read_test(void)
mdim[0] = MSPACE_DIM1;
mdim[1] = (hsize_t)(MSPACE_DIM2 * mpi_size);
matrix_out = (int *)HDmalloc(sizeof(int) * (size_t)MSPACE_DIM1 * (size_t)MSPACE_DIM2 * (size_t)mpi_size);
matrix_out1 = (int *)HDmalloc(sizeof(int) * (size_t)MSPACE_DIM1 * (size_t)MSPACE_DIM2 * (size_t)mpi_size);
matrix_out = (int *)malloc(sizeof(int) * (size_t)MSPACE_DIM1 * (size_t)MSPACE_DIM2 * (size_t)mpi_size);
matrix_out1 = (int *)malloc(sizeof(int) * (size_t)MSPACE_DIM1 * (size_t)MSPACE_DIM2 * (size_t)mpi_size);
/*** For testing collective hyperslab selection read ***/
@@ -945,8 +945,8 @@ coll_read_test(void)
/*
* Free read buffers.
*/
HDfree(matrix_out);
HDfree(matrix_out1);
free(matrix_out);
free(matrix_out1);
/*
* Close memory file and memory dataspaces.
@@ -1625,16 +1625,16 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size, const hbool_t use_
#endif /* LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG */
/* Allocate buffers */
small_ds_buf_0 = (uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_size);
small_ds_buf_0 = (uint32_t *)malloc(sizeof(uint32_t) * small_ds_size);
VRFY((small_ds_buf_0 != NULL), "malloc of small_ds_buf_0 succeeded");
small_ds_buf_1 = (uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_size);
small_ds_buf_1 = (uint32_t *)malloc(sizeof(uint32_t) * small_ds_size);
VRFY((small_ds_buf_1 != NULL), "malloc of small_ds_buf_1 succeeded");
large_ds_buf_0 = (uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_size);
large_ds_buf_0 = (uint32_t *)malloc(sizeof(uint32_t) * large_ds_size);
VRFY((large_ds_buf_0 != NULL), "malloc of large_ds_buf_0 succeeded");
large_ds_buf_1 = (uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_size);
large_ds_buf_1 = (uint32_t *)malloc(sizeof(uint32_t) * large_ds_size);
VRFY((large_ds_buf_1 != NULL), "malloc of large_ds_buf_1 succeeded");
/* initialize the buffers */
@@ -2352,14 +2352,14 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size, const hbool_t use_
/* Free memory buffers */
if (small_ds_buf_0 != NULL)
HDfree(small_ds_buf_0);
free(small_ds_buf_0);
if (small_ds_buf_1 != NULL)
HDfree(small_ds_buf_1);
free(small_ds_buf_1);
if (large_ds_buf_0 != NULL)
HDfree(large_ds_buf_0);
free(large_ds_buf_0);
if (large_ds_buf_1 != NULL)
HDfree(large_ds_buf_1);
free(large_ds_buf_1);
return;
testpar/API/testphdf5.c
+2 -2
View File
@@ -353,7 +353,7 @@ main(int argc, char **argv)
#if 0
HDmemset(filenames, 0, sizeof(filenames));
for (int i = 0; i < NFILENAME; i++) {
if (NULL == (filenames[i] = HDmalloc(PATH_MAX))) {
if (NULL == (filenames[i] = malloc(PATH_MAX))) {
printf("couldn't allocate filename array\n");
MPI_Abort(MPI_COMM_WORLD, -1);
}
@@ -987,7 +987,7 @@ main(int argc, char **argv)
#if 0
for (int i = 0; i < NFILENAME; i++) {
HDfree(filenames[i]);
free(filenames[i]);
filenames[i] = NULL;
}
#endif