mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2024-11-27 02:10:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add final list of single testphdf5 tests

Browse Source
This commit is contained in:
Allen Byrne 2019-05-02 16:18:58 -05:00
parent c389149d66
commit 813d8fd597
2 changed files with 214 additions and 204 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
testpar/CMakeTests.cmake
View File

@ -26,10 +26,20 @@ add_test (NAME MPI_TEST-clear-testphdf5-objects
set_tests_properties (MPI_TEST-clear-testphdf5-objects PROPERTIES FIXTURES_SETUP par_clear_testphdf5) set_tests_properties (MPI_TEST-clear-testphdf5-objects PROPERTIES FIXTURES_SETUP par_clear_testphdf5)
set (SKIP_tests set (SKIP_tests
cchunk1
cchunk2
cchunk3 cchunk3
cchunk4
ecdsetw ecdsetw
eidsetw2 eidsetw2
selnone
cngrpw
ingrpr
cschunkw
ccchunkw
tldsc tldsc
actualio
MC_coll_MD_read
) )
set (SKIP_testphdf5 "") set (SKIP_testphdf5 "")
foreach (skiptest ${SKIP_tests}) foreach (skiptest ${SKIP_tests})

408
testpar/testphdf5.c
View File

@ -26,15 +26,15 @@ int dim0;
int dim1; int dim1;
int chunkdim0; int chunkdim0;
int chunkdim1; int chunkdim1;
int nerrors = 0; /* errors count */ int nerrors = 0; /* errors count */
int ndatasets = 300; /* number of datasets to create*/ int ndatasets = 300; /* number of datasets to create*/
int ngroups = 512; /* number of groups to create in root int ngroups = 512; /* number of groups to create in root
* group. */ * group. */
int facc_type = FACC_MPIO; /*Test file access type */ int facc_type = FACC_MPIO; /*Test file access type */
int dxfer_coll_type = DXFER_COLLECTIVE_IO; int dxfer_coll_type = DXFER_COLLECTIVE_IO;
H5E_auto2_t old_func; /* previous error handler */ H5E_auto2_t old_func; /* previous error handler */
void *old_client_data; /* previous error handler arg.*/ void *old_client_data; /* previous error handler arg.*/
/* other option flags */ /* other option flags */
@ -46,10 +46,10 @@ void *old_client_data; /* previous error handler arg.*/
#define NFILENAME 2 #define NFILENAME 2
#define PARATESTFILE filenames[0] #define PARATESTFILE filenames[0]
const char *FILENAME[NFILENAME]={ const char *FILENAME[NFILENAME]={
"ParaTest", "ParaTest",
NULL}; NULL};
char filenames[NFILENAME][PATH_MAX]; char filenames[NFILENAME][PATH_MAX];
hid_t fapl; /* file access property list */ hid_t fapl; /* file access property list */
#ifdef USE_PAUSE #ifdef USE_PAUSE
/* pause the process for a moment to allow debugger to attach if desired. */ /* pause the process for a moment to allow debugger to attach if desired. */
@ -62,7 +62,7 @@ void pause_proc(void)
{ {
int pid; int pid;
h5_stat_t statbuf; h5_stat_t statbuf;
char greenlight[] = "go"; char greenlight[] = "go";
int maxloop = 10; int maxloop = 10;
int loops = 0; int loops = 0;
@ -80,14 +80,14 @@ void pause_proc(void)
if (MAINPROCESS) if (MAINPROCESS)
while ((HDstat(greenlight, &statbuf) == -1) && loops < maxloop){ while ((HDstat(greenlight, &statbuf) == -1) && loops < maxloop){
if (!loops++){ if (!loops++){
printf("Proc %d (%*s, %d): to debug, attach %d\n", printf("Proc %d (%*s, %d): to debug, attach %d\n",
mpi_rank, mpi_namelen, mpi_name, pid, pid); mpi_rank, mpi_namelen, mpi_name, pid, pid);
} }
printf("waiting(%ds) for file %s ...\n", time_int, greenlight); printf("waiting(%ds) for file %s ...\n", time_int, greenlight);
fflush(stdout); fflush(stdout);
HDsleep(time_int); HDsleep(time_int);
} }
MPI_Barrier(MPI_COMM_WORLD); MPI_Barrier(MPI_COMM_WORLD);
} }
@ -99,7 +99,7 @@ int MPI_Init(int *argc, char ***argv)
pause_proc(); pause_proc();
return (ret_code); return (ret_code);
} }
#endif /* USE_PAUSE */ #endif /* USE_PAUSE */
/* /*
@ -109,15 +109,15 @@ static void
usage(void) usage(void)
{ {
printf(" [-r] [-w] [-m<n_datasets>] [-n<n_groups>] " printf(" [-r] [-w] [-m<n_datasets>] [-n<n_groups>] "
"[-o] [-f <prefix>] [-d <dim0> <dim1>]\n"); "[-o] [-f <prefix>] [-d <dim0> <dim1>]\n");
printf("\t-m<n_datasets>" printf("\t-m<n_datasets>"
"\tset number of datasets for the multiple dataset test\n"); "\tset number of datasets for the multiple dataset test\n");
printf("\t-n<n_groups>" printf("\t-n<n_groups>"
"\tset number of groups for the multiple group test\n"); "\tset number of groups for the multiple group test\n");
printf("\t-f <prefix>\tfilename prefix\n"); printf("\t-f <prefix>\tfilename prefix\n");
printf("\t-2\t\tuse Split-file together with MPIO\n"); printf("\t-2\t\tuse Split-file together with MPIO\n");
printf("\t-d <factor0> <factor1>\tdataset dimensions factors. Defaults (%d,%d)\n", printf("\t-d <factor0> <factor1>\tdataset dimensions factors. Defaults (%d,%d)\n",
ROW_FACTOR, COL_FACTOR); ROW_FACTOR, COL_FACTOR);
printf("\t-c <dim0> <dim1>\tdataset chunk dimensions. Defaults (dim0/10,dim1/10)\n"); printf("\t-c <dim0> <dim1>\tdataset chunk dimensions. Defaults (dim0/10,dim1/10)\n");
printf("\n"); printf("\n");
} }
@ -129,7 +129,7 @@ usage(void)
static int static int
parse_options(int argc, char **argv) parse_options(int argc, char **argv)
{ {
int mpi_size, mpi_rank; /* mpi variables */ int mpi_size, mpi_rank; /* mpi variables */
MPI_Comm_size(MPI_COMM_WORLD, &mpi_size); MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank); MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
@ -140,107 +140,107 @@ parse_options(int argc, char **argv)
chunkdim1 = (dim1+9)/10; chunkdim1 = (dim1+9)/10;
while (--argc){ while (--argc){
if (**(++argv) != '-'){ if (**(++argv) != '-'){
break; break;
}else{ }else{
switch(*(*argv+1)){ switch(*(*argv+1)){
case 'm': ndatasets = atoi((*argv+1)+1); case 'm': ndatasets = atoi((*argv+1)+1);
if (ndatasets < 0){ if (ndatasets < 0){
nerrors++; nerrors++;
return(1); return(1);
} }
break; break;
case 'n': ngroups = atoi((*argv+1)+1); case 'n': ngroups = atoi((*argv+1)+1);
if (ngroups < 0){ if (ngroups < 0){
nerrors++; nerrors++;
return(1); return(1);
} }
break; break;
case 'f': if (--argc < 1) { case 'f': if (--argc < 1) {
nerrors++; nerrors++;
return(1); return(1);
} }
if (**(++argv) == '-') { if (**(++argv) == '-') {
nerrors++; nerrors++;
return(1); return(1);
} }
paraprefix = *argv; paraprefix = *argv;
break; break;
case 'i': /* Collective MPI-IO access with independent IO */ case 'i': /* Collective MPI-IO access with independent IO */
dxfer_coll_type = DXFER_INDEPENDENT_IO; dxfer_coll_type = DXFER_INDEPENDENT_IO;
break; break;
case '2': /* Use the split-file driver with MPIO access */ case '2': /* Use the split-file driver with MPIO access */
/* Can use $HDF5_METAPREFIX to define the */ /* Can use $HDF5_METAPREFIX to define the */
/* meta-file-prefix. */ /* meta-file-prefix. */
facc_type = FACC_MPIO | FACC_SPLIT; facc_type = FACC_MPIO | FACC_SPLIT;
break; break;
case 'd': /* dimensizes */ case 'd': /* dimensizes */
if (--argc < 2){ if (--argc < 2){
nerrors++; nerrors++;
return(1); return(1);
} }
dim0 = atoi(*(++argv))*mpi_size; dim0 = atoi(*(++argv))*mpi_size;
argc--; argc--;
dim1 = atoi(*(++argv))*mpi_size; dim1 = atoi(*(++argv))*mpi_size;
/* set default chunkdim sizes too */ /* set default chunkdim sizes too */
chunkdim0 = (dim0+9)/10; chunkdim0 = (dim0+9)/10;
chunkdim1 = (dim1+9)/10; chunkdim1 = (dim1+9)/10;
break; break;
case 'c': /* chunk dimensions */ case 'c': /* chunk dimensions */
if (--argc < 2){ if (--argc < 2){
nerrors++; nerrors++;
return(1); return(1);
} }
chunkdim0 = atoi(*(++argv)); chunkdim0 = atoi(*(++argv));
argc--; argc--;
chunkdim1 = atoi(*(++argv)); chunkdim1 = atoi(*(++argv));
break; break;
case 'h': /* print help message--return with nerrors set */ case 'h': /* print help message--return with nerrors set */
return(1); return(1);
default: printf("Illegal option(%s)\n", *argv); default: printf("Illegal option(%s)\n", *argv);
nerrors++; nerrors++;
return(1); return(1);
} }
} }
} /*while*/ } /*while*/
/* check validity of dimension and chunk sizes */ /* check validity of dimension and chunk sizes */
if (dim0 <= 0 || dim1 <= 0){ if (dim0 <= 0 || dim1 <= 0){
printf("Illegal dim sizes (%d, %d)\n", dim0, dim1); printf("Illegal dim sizes (%d, %d)\n", dim0, dim1);
nerrors++; nerrors++;
return(1); return(1);
} }
if (chunkdim0 <= 0 || chunkdim1 <= 0){ if (chunkdim0 <= 0 || chunkdim1 <= 0){
printf("Illegal chunkdim sizes (%d, %d)\n", chunkdim0, chunkdim1); printf("Illegal chunkdim sizes (%d, %d)\n", chunkdim0, chunkdim1);
nerrors++; nerrors++;
return(1); return(1);
} }
/* Make sure datasets can be divided into equal portions by the processes */ /* Make sure datasets can be divided into equal portions by the processes */
if ((dim0 % mpi_size) || (dim1 % mpi_size)){ if ((dim0 % mpi_size) || (dim1 % mpi_size)){
if (MAINPROCESS) if (MAINPROCESS)
printf("dim0(%d) and dim1(%d) must be multiples of processes(%d)\n", printf("dim0(%d) and dim1(%d) must be multiples of processes(%d)\n",
dim0, dim1, mpi_size); dim0, dim1, mpi_size);
nerrors++; nerrors++;
return(1); return(1);
} }
/* compose the test filenames */ /* compose the test filenames */
{ {
int i, n; int i, n;
n = sizeof(FILENAME)/sizeof(FILENAME[0]) - 1; /* exclude the NULL */ n = sizeof(FILENAME)/sizeof(FILENAME[0]) - 1; /* exclude the NULL */
for (i=0; i < n; i++) for (i=0; i < n; i++)
if (h5_fixname(FILENAME[i],fapl,filenames[i],sizeof(filenames[i])) if (h5_fixname(FILENAME[i],fapl,filenames[i],sizeof(filenames[i]))
== NULL){ == NULL){
printf("h5_fixname failed\n"); printf("h5_fixname failed\n");
nerrors++; nerrors++;
return(1); return(1);
} }
printf("Test filenames are:\n"); printf("Test filenames are:\n");
for (i=0; i < n; i++) for (i=0; i < n; i++)
printf(" %s\n", filenames[i]); printf(" %s\n", filenames[i]);
} }
return(0); return(0);
@ -255,7 +255,7 @@ create_faccess_plist(MPI_Comm comm, MPI_Info info, int l_facc_type)
{ {
hid_t ret_pl = -1; hid_t ret_pl = -1;
herr_t ret; /* generic return value */ herr_t ret; /* generic return value */
int mpi_rank; /* mpi variables */ int mpi_rank; /* mpi variables */
/* need the rank for error checking macros */ /* need the rank for error checking macros */
MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank); MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
@ -264,36 +264,36 @@ create_faccess_plist(MPI_Comm comm, MPI_Info info, int l_facc_type)
VRFY((ret_pl >= 0), "H5P_FILE_ACCESS"); VRFY((ret_pl >= 0), "H5P_FILE_ACCESS");
if (l_facc_type == FACC_DEFAULT) if (l_facc_type == FACC_DEFAULT)
return (ret_pl); return (ret_pl);
if (l_facc_type == FACC_MPIO){ if (l_facc_type == FACC_MPIO){
/* set Parallel access with communicator */ /* set Parallel access with communicator */
ret = H5Pset_fapl_mpio(ret_pl, comm, info); ret = H5Pset_fapl_mpio(ret_pl, comm, info);
VRFY((ret >= 0), ""); VRFY((ret >= 0), "");
ret = H5Pset_all_coll_metadata_ops(ret_pl, TRUE); ret = H5Pset_all_coll_metadata_ops(ret_pl, TRUE);
VRFY((ret >= 0), ""); VRFY((ret >= 0), "");
ret = H5Pset_coll_metadata_write(ret_pl, TRUE); ret = H5Pset_coll_metadata_write(ret_pl, TRUE);
VRFY((ret >= 0), ""); VRFY((ret >= 0), "");
return(ret_pl); return(ret_pl);
} }
if (l_facc_type == (FACC_MPIO | FACC_SPLIT)){ if (l_facc_type == (FACC_MPIO | FACC_SPLIT)){
hid_t mpio_pl; hid_t mpio_pl;
mpio_pl = H5Pcreate (H5P_FILE_ACCESS); mpio_pl = H5Pcreate (H5P_FILE_ACCESS);
VRFY((mpio_pl >= 0), ""); VRFY((mpio_pl >= 0), "");
/* set Parallel access with communicator */ /* set Parallel access with communicator */
ret = H5Pset_fapl_mpio(mpio_pl, comm, info); ret = H5Pset_fapl_mpio(mpio_pl, comm, info);
VRFY((ret >= 0), ""); VRFY((ret >= 0), "");
/* setup file access template */ /* setup file access template */
ret_pl = H5Pcreate (H5P_FILE_ACCESS); ret_pl = H5Pcreate (H5P_FILE_ACCESS);
VRFY((ret_pl >= 0), ""); VRFY((ret_pl >= 0), "");
/* set Parallel access with communicator */ /* set Parallel access with communicator */
ret = H5Pset_fapl_split(ret_pl, ".meta", mpio_pl, ".raw", mpio_pl); ret = H5Pset_fapl_split(ret_pl, ".meta", mpio_pl, ".raw", mpio_pl);
VRFY((ret >= 0), "H5Pset_fapl_split succeeded"); VRFY((ret >= 0), "H5Pset_fapl_split succeeded");
H5Pclose(mpio_pl); H5Pclose(mpio_pl);
return(ret_pl); return(ret_pl);
} }
/* unknown file access types */ /* unknown file access types */
@ -303,7 +303,7 @@ create_faccess_plist(MPI_Comm comm, MPI_Info info, int l_facc_type)
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
int mpi_size, mpi_rank; /* mpi variables */ int mpi_size, mpi_rank; /* mpi variables */
H5Ptest_param_t ndsets_params, ngroups_params; H5Ptest_param_t ndsets_params, ngroups_params;
H5Ptest_param_t collngroups_params; H5Ptest_param_t collngroups_params;
H5Ptest_param_t io_mode_confusion_params; H5Ptest_param_t io_mode_confusion_params;
@ -323,9 +323,9 @@ int main(int argc, char **argv)
dim1 = COL_FACTOR*mpi_size; dim1 = COL_FACTOR*mpi_size;
if (MAINPROCESS){ if (MAINPROCESS){
printf("===================================\n"); printf("===================================\n");
printf("PHDF5 TESTS START\n"); printf("PHDF5 TESTS START\n");
printf("===================================\n"); printf("===================================\n");
} }
/* Attempt to turn off atexit post processing so that in case errors /* Attempt to turn off atexit post processing so that in case errors
@ -334,7 +334,7 @@ int main(int argc, char **argv)
* calls. By then, MPI calls may not work. * calls. By then, MPI calls may not work.
*/ */
if (H5dont_atexit() < 0){ if (H5dont_atexit() < 0){
printf("Failed to turn off atexit processing. Continue.\n"); printf("Failed to turn off atexit processing. Continue.\n");
}; };
H5open(); H5open();
h5_show_hostname(); h5_show_hostname();
@ -344,10 +344,10 @@ int main(int argc, char **argv)
/* Tests are generally arranged from least to most complexity... */ /* Tests are generally arranged from least to most complexity... */
AddTest("mpiodup", test_fapl_mpio_dup, NULL, AddTest("mpiodup", test_fapl_mpio_dup, NULL,
"fapl_mpio duplicate", NULL); "fapl_mpio duplicate", NULL);
AddTest("split", test_split_comm_access, NULL, AddTest("split", test_split_comm_access, NULL,
"dataset using split communicators", PARATESTFILE); "dataset using split communicators", PARATESTFILE);
#ifdef PB_OUT /* temporary: disable page buffering when parallel */ #ifdef PB_OUT /* temporary: disable page buffering when parallel */
AddTest("page_buffer", test_page_buffer_access, NULL, AddTest("page_buffer", test_page_buffer_access, NULL,
@ -355,64 +355,64 @@ int main(int argc, char **argv)
#endif #endif
AddTest("props", test_file_properties, NULL, AddTest("props", test_file_properties, NULL,
"Coll Metadata file property settings", PARATESTFILE); "Coll Metadata file property settings", PARATESTFILE);
AddTest("idsetw", dataset_writeInd, NULL, AddTest("idsetw", dataset_writeInd, NULL,
"dataset independent write", PARATESTFILE); "dataset independent write", PARATESTFILE);
AddTest("idsetr", dataset_readInd, NULL, AddTest("idsetr", dataset_readInd, NULL,
"dataset independent read", PARATESTFILE); "dataset independent read", PARATESTFILE);
AddTest("cdsetw", dataset_writeAll, NULL, AddTest("cdsetw", dataset_writeAll, NULL,
"dataset collective write", PARATESTFILE); "dataset collective write", PARATESTFILE);
AddTest("cdsetr", dataset_readAll, NULL, AddTest("cdsetr", dataset_readAll, NULL,
"dataset collective read", PARATESTFILE); "dataset collective read", PARATESTFILE);
AddTest("eidsetw", extend_writeInd, NULL, AddTest("eidsetw", extend_writeInd, NULL,
"extendible dataset independent write", PARATESTFILE); "extendible dataset independent write", PARATESTFILE);
AddTest("eidsetr", extend_readInd, NULL, AddTest("eidsetr", extend_readInd, NULL,
"extendible dataset independent read", PARATESTFILE); "extendible dataset independent read", PARATESTFILE);
AddTest("ecdsetw", extend_writeAll, NULL, AddTest("ecdsetw", extend_writeAll, NULL,
"extendible dataset collective write", PARATESTFILE); "extendible dataset collective write", PARATESTFILE);
AddTest("ecdsetr", extend_readAll, NULL, AddTest("ecdsetr", extend_readAll, NULL,
"extendible dataset collective read", PARATESTFILE); "extendible dataset collective read", PARATESTFILE);
AddTest("eidsetw2", extend_writeInd2, NULL, AddTest("eidsetw2", extend_writeInd2, NULL,
"extendible dataset independent write #2", PARATESTFILE); "extendible dataset independent write #2", PARATESTFILE);
AddTest("selnone", none_selection_chunk, NULL, AddTest("selnone", none_selection_chunk, NULL,
"chunked dataset with none-selection", PARATESTFILE); "chunked dataset with none-selection", PARATESTFILE);
AddTest("calloc", test_chunk_alloc, NULL, AddTest("calloc", test_chunk_alloc, NULL,
"parallel extend Chunked allocation on serial file", PARATESTFILE); "parallel extend Chunked allocation on serial file", PARATESTFILE);
AddTest("fltread", test_filter_read, NULL, AddTest("fltread", test_filter_read, NULL,
"parallel read of dataset written serially with filters", PARATESTFILE); "parallel read of dataset written serially with filters", PARATESTFILE);
#ifdef H5_HAVE_FILTER_DEFLATE #ifdef H5_HAVE_FILTER_DEFLATE
AddTest("cmpdsetr", compress_readAll, NULL, AddTest("cmpdsetr", compress_readAll, NULL,
"compressed dataset collective read", PARATESTFILE); "compressed dataset collective read", PARATESTFILE);
#endif /* H5_HAVE_FILTER_DEFLATE */ #endif /* H5_HAVE_FILTER_DEFLATE */
AddTest("zerodsetr", zero_dim_dset, NULL, AddTest("zerodsetr", zero_dim_dset, NULL,
"zero dim dset", PARATESTFILE); "zero dim dset", PARATESTFILE);
ndsets_params.name = PARATESTFILE; ndsets_params.name = PARATESTFILE;
ndsets_params.count = ndatasets; ndsets_params.count = ndatasets;
AddTest("ndsetw", multiple_dset_write, NULL, AddTest("ndsetw", multiple_dset_write, NULL,
"multiple datasets write", &ndsets_params); "multiple datasets write", &ndsets_params);
ngroups_params.name = PARATESTFILE; ngroups_params.name = PARATESTFILE;
ngroups_params.count = ngroups; ngroups_params.count = ngroups;
AddTest("ngrpw", multiple_group_write, NULL, AddTest("ngrpw", multiple_group_write, NULL,
"multiple groups write", &ngroups_params); "multiple groups write", &ngroups_params);
AddTest("ngrpr", multiple_group_read, NULL, AddTest("ngrpr", multiple_group_read, NULL,
"multiple groups read", &ngroups_params); "multiple groups read", &ngroups_params);
AddTest("compact", compact_dataset, NULL, AddTest("compact", compact_dataset, NULL,
"compact dataset test", PARATESTFILE); "compact dataset test", PARATESTFILE);
collngroups_params.name = PARATESTFILE; collngroups_params.name = PARATESTFILE;
collngroups_params.count = ngroups; collngroups_params.count = ngroups;
AddTest("cngrpw", collective_group_write, NULL, AddTest("cngrpw", collective_group_write, NULL,
"collective group and dataset write", &collngroups_params); "collective group and dataset write", &collngroups_params);
AddTest("ingrpr", independent_group_read, NULL, AddTest("ingrpr", independent_group_read, NULL,
"independent group and dataset read", &collngroups_params); "independent group and dataset read", &collngroups_params);
#ifndef H5_HAVE_WIN32_API #ifndef H5_HAVE_WIN32_API
AddTest("bigdset", big_dataset, NULL, AddTest("bigdset", big_dataset, NULL,
"big dataset test", PARATESTFILE); "big dataset test", PARATESTFILE);
@ -420,71 +420,71 @@ int main(int argc, char **argv)
printf("big dataset test will be skipped on Windows (JIRA HDDFV-8064)\n"); printf("big dataset test will be skipped on Windows (JIRA HDDFV-8064)\n");
#endif #endif
AddTest("fill", dataset_fillvalue, NULL, AddTest("fill", dataset_fillvalue, NULL,
"dataset fill value", PARATESTFILE); "dataset fill value", PARATESTFILE);
AddTest("cchunk1", AddTest("cchunk1",
coll_chunk1,NULL, "simple collective chunk io",PARATESTFILE); coll_chunk1,NULL, "simple collective chunk io",PARATESTFILE);
AddTest("cchunk2", AddTest("cchunk2",
coll_chunk2,NULL, "noncontiguous collective chunk io",PARATESTFILE); coll_chunk2,NULL, "noncontiguous collective chunk io",PARATESTFILE);
AddTest("cchunk3", AddTest("cchunk3",
coll_chunk3,NULL, "multi-chunk collective chunk io",PARATESTFILE); coll_chunk3,NULL, "multi-chunk collective chunk io",PARATESTFILE);
AddTest("cchunk4", AddTest("cchunk4",
coll_chunk4,NULL, "collective chunk io with partial non-selection ",PARATESTFILE); coll_chunk4,NULL, "collective chunk io with partial non-selection ",PARATESTFILE);
if((mpi_size < 3)&& MAINPROCESS ) { if((mpi_size < 3)&& MAINPROCESS ) {
printf("Collective chunk IO optimization APIs "); printf("Collective chunk IO optimization APIs ");
printf("needs at least 3 processes to participate\n"); printf("needs at least 3 processes to participate\n");
printf("Collective chunk IO API tests will be skipped \n"); printf("Collective chunk IO API tests will be skipped \n");
} }
AddTest((mpi_size <3)? "-cchunk5":"cchunk5" , AddTest((mpi_size <3)? "-cchunk5":"cchunk5" ,
coll_chunk5,NULL, coll_chunk5,NULL,
"linked chunk collective IO without optimization",PARATESTFILE); "linked chunk collective IO without optimization",PARATESTFILE);
AddTest((mpi_size < 3)? "-cchunk6" : "cchunk6", AddTest((mpi_size < 3)? "-cchunk6" : "cchunk6",
coll_chunk6,NULL, coll_chunk6,NULL,
"multi-chunk collective IO with direct request",PARATESTFILE); "multi-chunk collective IO with direct request",PARATESTFILE);
AddTest((mpi_size < 3)? "-cchunk7" : "cchunk7", AddTest((mpi_size < 3)? "-cchunk7" : "cchunk7",
coll_chunk7,NULL, coll_chunk7,NULL,
"linked chunk collective IO with optimization",PARATESTFILE); "linked chunk collective IO with optimization",PARATESTFILE);
AddTest((mpi_size < 3)? "-cchunk8" : "cchunk8", AddTest((mpi_size < 3)? "-cchunk8" : "cchunk8",
coll_chunk8,NULL, coll_chunk8,NULL,
"linked chunk collective IO transferring to multi-chunk",PARATESTFILE); "linked chunk collective IO transferring to multi-chunk",PARATESTFILE);
AddTest((mpi_size < 3)? "-cchunk9" : "cchunk9", AddTest((mpi_size < 3)? "-cchunk9" : "cchunk9",
coll_chunk9,NULL, coll_chunk9,NULL,
"multiple chunk collective IO with optimization",PARATESTFILE); "multiple chunk collective IO with optimization",PARATESTFILE);
AddTest((mpi_size < 3)? "-cchunk10" : "cchunk10", AddTest((mpi_size < 3)? "-cchunk10" : "cchunk10",
coll_chunk10,NULL, coll_chunk10,NULL,
"multiple chunk collective IO transferring to independent IO",PARATESTFILE); "multiple chunk collective IO transferring to independent IO",PARATESTFILE);
/* irregular collective IO tests*/ /* irregular collective IO tests*/
AddTest("ccontw", AddTest("ccontw",
coll_irregular_cont_write,NULL, coll_irregular_cont_write,NULL,
"collective irregular contiguous write",PARATESTFILE); "collective irregular contiguous write",PARATESTFILE);
AddTest("ccontr", AddTest("ccontr",
coll_irregular_cont_read,NULL, coll_irregular_cont_read,NULL,
"collective irregular contiguous read",PARATESTFILE); "collective irregular contiguous read",PARATESTFILE);
AddTest("cschunkw", AddTest("cschunkw",
coll_irregular_simple_chunk_write,NULL, coll_irregular_simple_chunk_write,NULL,
"collective irregular simple chunk write",PARATESTFILE); "collective irregular simple chunk write",PARATESTFILE);
AddTest("cschunkr", AddTest("cschunkr",
coll_irregular_simple_chunk_read,NULL, coll_irregular_simple_chunk_read,NULL,
"collective irregular simple chunk read",PARATESTFILE); "collective irregular simple chunk read",PARATESTFILE);
AddTest("ccchunkw", AddTest("ccchunkw",
coll_irregular_complex_chunk_write,NULL, coll_irregular_complex_chunk_write,NULL,
"collective irregular complex chunk write",PARATESTFILE); "collective irregular complex chunk write",PARATESTFILE);
AddTest("ccchunkr", AddTest("ccchunkr",
coll_irregular_complex_chunk_read,NULL, coll_irregular_complex_chunk_read,NULL,
"collective irregular complex chunk read",PARATESTFILE); "collective irregular complex chunk read",PARATESTFILE);
AddTest("null", null_dataset, NULL, AddTest("null", null_dataset, NULL,
"null dataset test", PARATESTFILE); "null dataset test", PARATESTFILE);
io_mode_confusion_params.name = PARATESTFILE; io_mode_confusion_params.name = PARATESTFILE;
io_mode_confusion_params.count = 0; /* value not used */ io_mode_confusion_params.count = 0; /* value not used */
AddTest("I/Omodeconf", io_mode_confusion, NULL, AddTest("I/Omodeconf", io_mode_confusion, NULL,
"I/O mode confusion test -- hangs quickly on failure", "I/O mode confusion test -- hangs quickly on failure",
&io_mode_confusion_params); &io_mode_confusion_params);
if((mpi_size < 3) && MAINPROCESS) { if((mpi_size < 3) && MAINPROCESS) {
@ -506,12 +506,12 @@ int main(int argc, char **argv)
AddTest("tldsc", AddTest("tldsc",
lower_dim_size_comp_test, NULL, lower_dim_size_comp_test, NULL,
"test lower dim size comp in span tree to mpi derived type", "test lower dim size comp in span tree to mpi derived type",
PARATESTFILE); PARATESTFILE);
AddTest("lccio", AddTest("lccio",
link_chunk_collective_io_test, NULL, link_chunk_collective_io_test, NULL,
"test mpi derived type management", "test mpi derived type management",
PARATESTFILE); PARATESTFILE);
AddTest("actualio", actual_io_mode_tests, NULL, AddTest("actualio", actual_io_mode_tests, NULL,
@ -523,7 +523,7 @@ int main(int argc, char **argv)
PARATESTFILE); PARATESTFILE);
AddTest("edpl", test_plist_ed, NULL, AddTest("edpl", test_plist_ed, NULL,
"encode/decode Property Lists", NULL); "encode/decode Property Lists", NULL);
if((mpi_size < 2) && MAINPROCESS) { if((mpi_size < 2) && MAINPROCESS) {
printf("File Image Ops daisy chain test needs at least 2 processes.\n"); printf("File Image Ops daisy chain test needs at least 2 processes.\n");
@ -533,11 +533,11 @@ int main(int argc, char **argv)
"file image ops daisy chain", NULL); "file image ops daisy chain", NULL);
if((mpi_size < 2)&& MAINPROCESS ) { if((mpi_size < 2)&& MAINPROCESS ) {
printf("Atomicity tests need at least 2 processes to participate\n"); printf("Atomicity tests need at least 2 processes to participate\n");
printf("8 is more recommended.. Atomicity tests will be skipped \n"); printf("8 is more recommended.. Atomicity tests will be skipped \n");
} }
else if (facc_type != FACC_MPIO && MAINPROCESS) { else if (facc_type != FACC_MPIO && MAINPROCESS) {
printf("Atomicity tests will not work with a non MPIO VFD\n"); printf("Atomicity tests will not work with a non MPIO VFD\n");
} }
else if(mpi_size >= 2 && facc_type == FACC_MPIO){ else if(mpi_size >= 2 && facc_type == FACC_MPIO){
AddTest("atomicity", dataset_atomicity, NULL, AddTest("atomicity", dataset_atomicity, NULL,
@ -545,13 +545,13 @@ int main(int argc, char **argv)
} }
AddTest("denseattr", test_dense_attr, NULL, AddTest("denseattr", test_dense_attr, NULL,
"Store Dense Attributes", PARATESTFILE); "Store Dense Attributes", PARATESTFILE);
AddTest("noselcollmdread", test_partial_no_selection_coll_md_read, NULL, AddTest("noselcollmdread", test_partial_no_selection_coll_md_read, NULL,
"Collective Metadata read with some ranks having no selection", PARATESTFILE); "Collective Metadata read with some ranks having no selection", PARATESTFILE);
AddTest("MC coll MD read", test_multi_chunk_io_addrmap_issue, NULL, AddTest("MC_coll_MD_read", test_multi_chunk_io_addrmap_issue, NULL,
"Collective MD read with multi chunk I/O (H5D__chunk_addrmap)", PARATESTFILE); "Collective MD read with multi chunk I/O (H5D__chunk_addrmap)", PARATESTFILE);
AddTest("LC coll MD read", test_link_chunk_io_sort_chunk_issue, NULL, AddTest("LC_coll_MD_read", test_link_chunk_io_sort_chunk_issue, NULL,
"Collective MD read with link chunk I/O (H5D__sort_chunk)", PARATESTFILE); "Collective MD read with link chunk I/O (H5D__sort_chunk)", PARATESTFILE);
/* Display testing information */ /* Display testing information */
@ -565,9 +565,9 @@ int main(int argc, char **argv)
TestParseCmdLine(argc, argv); TestParseCmdLine(argc, argv);
if (dxfer_coll_type == DXFER_INDEPENDENT_IO && MAINPROCESS){ if (dxfer_coll_type == DXFER_INDEPENDENT_IO && MAINPROCESS){
printf("===================================\n" printf("===================================\n"
" Using Independent I/O with file set view to replace collective I/O \n" " Using Independent I/O with file set view to replace collective I/O \n"
"===================================\n"); "===================================\n");
} }
@ -592,16 +592,16 @@ int main(int argc, char **argv)
{ {
int temp; int temp;
MPI_Allreduce(&nerrors, &temp, 1, MPI_INT, MPI_MAX, MPI_COMM_WORLD); MPI_Allreduce(&nerrors, &temp, 1, MPI_INT, MPI_MAX, MPI_COMM_WORLD);
nerrors=temp; nerrors=temp;
} }
if (MAINPROCESS){ /* only process 0 reports */ if (MAINPROCESS){ /* only process 0 reports */
printf("===================================\n"); printf("===================================\n");
if (nerrors) if (nerrors)
printf("***PHDF5 tests detected %d errors***\n", nerrors); printf("***PHDF5 tests detected %d errors***\n", nerrors);
else else
printf("PHDF5 tests finished with no errors\n"); printf("PHDF5 tests finished with no errors\n");
printf("===================================\n"); printf("===================================\n");
} }
/* close HDF5 library */ /* close HDF5 library */