[svn-r9149] Purpose:

Fix of bug/feature which caused testphdf5 to fail when run with more than
32 processes.  This fix was originally applied to the 1.6 branch, and is
now ported to the 1.7 branch.


Description:

32 process limit was a hard coded constant.


Solution:

Modified most of the routines in t_mdset.c to adapt dynamically to
the current number of processes.  In passing, I also tidied up a
few memory leaks.

Note that one new routine had been added to the 1.7 version of
t_mdset.c since the 1.6/1.7 split.  I applied changes to this
routine as well.


Platforms tested:

h5committested

Tested on eirene with 4 and 8 processes.  Couldn't go higher.

I would have like to repeat my 32 - 64 process tests on copper,
but was unable to do so as I don't have access to cu12t at
present.  Perhaps I will be able to manage this in the next
few days.  However, Albert wanted these changes checked in to
the 1.7 branch so he could work with them.


Misc. update:

1 files changed, 282 insertions, 90 deletions

diff --git a/testpar/t_mdset.c b/testpar/t_mdset.c
index 3ed6ef4..d6d9907 100644
--- a/testpar/t_mdset.c
+++ b/testpar/t_mdset.c
@@ -22,6 +22,8 @@
 #define GROUP_DEPTH 128
 enum obj_type { is_group, is_dset };
  
+
+int get_size(void);
 void write_dataset(hid_t, hid_t, hid_t);
 int  read_dataset(hid_t, hid_t, hid_t);
 void create_group_recursive(hid_t, hid_t, hid_t, int);
@@ -29,23 +31,68 @@ void recursive_read_group(hid_t, hid_t, hid_t, int);
 void group_dataset_read(hid_t fid, int mpi_rank, int m);
 void write_attribute(hid_t, int, int);
 int  read_attribute(hid_t, int, int);
-int  check_value(DATATYPE *, DATATYPE *);
-void get_slab(hssize_t[], hsize_t[], hsize_t[], hsize_t[]);
+int  check_value(DATATYPE *, DATATYPE *, int);
+void get_slab(hssize_t[], hsize_t[], hsize_t[], hsize_t[], int);
+
+
+/*
+ * The size value computed by this function is used extensively in 
+ * configuring tests for the current number of processes.  
+ *
+ * This function was created as part of an effort to allow the 
+ * test functions in this file to run on an arbitrary number of
+ * processors.
+ *                                       JRM - 8/11/04
+ */
+
+int get_size(void)
+{
+    int mpi_rank;
+    int mpi_size;
+    int size = SIZE;
+  
+    MPI_Comm_rank (MPI_COMM_WORLD, &mpi_rank); /* needed for VRFY */
+    MPI_Comm_size (MPI_COMM_WORLD, &mpi_size);
+
+    if ( mpi_size > size ) {
+
+        if ( (mpi_size % 2) == 0 ) {
+
+            size = mpi_size;
+
+        } else {
+
+            size = mpi_size + 1;
+        }
+    }
+
+    VRFY((mpi_size <= size), "mpi_size <= size");
+    VRFY(((size % 2) == 0), "size isn't even");
+
+    return(size);
+
+} /* get_size() */
 
 /*
  * Example of using PHDF5 to create ndatasets datasets.  Each process write
  * a slab of array to the file.
+ *
+ * Changes:	Updated function to use a dynamically calculated size,
+ *		instead of the old SIZE #define.  This should allow it
+ *		to function with an arbitrary number of processors.
+ *
+ *						JRM - 8/11/04
  */
 void multiple_dset_write(void)
 {
-    int i, j, n, mpi_size, mpi_rank;
+    int i, j, n, mpi_size, mpi_rank, size;
     hid_t iof, plist, dataset, memspace, filespace;
     hid_t dcpl;                         /* Dataset creation property list */
     hbool_t use_gpfs = FALSE;           /* Use GPFS hints */
     hssize_t chunk_origin [DIM];
     hsize_t chunk_dims [DIM], file_dims [DIM];
     hsize_t count[DIM]={1,1};
-    double outme [SIZE][SIZE];
+    double * outme = NULL;
     double fill=1.0;                    /* Fill value */
     char dname [100];
     herr_t ret;
@@ -57,10 +104,13 @@ void multiple_dset_write(void)
     filename = pt->name;
     ndatasets = pt->count;
 
+    size = get_size();
+
     MPI_Comm_rank (MPI_COMM_WORLD, &mpi_rank);
     MPI_Comm_size (MPI_COMM_WORLD, &mpi_size);
 
-    VRFY((mpi_size <= SIZE), "mpi_size <= SIZE");
+    outme = HDmalloc((size_t)(size * size * sizeof(double)));
+    VRFY((outme != NULL), "HDmalloc succeeded for outme");
 
     plist = create_faccess_plist(MPI_COMM_WORLD, MPI_INFO_NULL, facc_type, use_gpfs);
     VRFY((plist>=0), "create_faccess_plist succeeded");
@@ -70,7 +120,7 @@ void multiple_dset_write(void)
     VRFY((ret>=0), "H5Pclose succeeded");
 
     /* decide the hyperslab according to process number. */
-    get_slab(chunk_origin, chunk_dims, count, file_dims);  
+    get_slab(chunk_origin, chunk_dims, count, file_dims, size);  
 
     memspace = H5Screate_simple (DIM, chunk_dims, NULL);
     filespace = H5Screate_simple (DIM, file_dims, NULL);
@@ -90,9 +140,9 @@ void multiple_dset_write(void)
 	VRFY((dataset > 0), dname); 
 
 	/* calculate data to write */
-	for (i = 0; i < SIZE; i++)
-	    for (j = 0; j < SIZE; j++)
-	        outme [i][j] = n*1000 + mpi_rank;
+	for (i = 0; i < size; i++)
+	    for (j = 0; j < size; j++)
+                outme [(i * size) + j] = n*1000 + mpi_rank;
 
 	H5Dwrite (dataset, H5T_NATIVE_DOUBLE, memspace, filespace, H5P_DEFAULT, outme);
 
@@ -109,27 +159,49 @@ void multiple_dset_write(void)
     H5Sclose (memspace);
     H5Pclose (dcpl);
     H5Fclose (iof);
+
+    HDfree(outme);
 }
 
-/* 
- * Example of using PHDF5 to create, write, and read compact dataset.  
+
+/* Example of using PHDF5 to create, write, and read compact dataset.  
+ *
+ * Changes:	Updated function to use a dynamically calculated size,
+ *		instead of the old SIZE #define.  This should allow it
+ *		to function with an arbitrary number of processors.
+ *
+ *						JRM - 8/11/04
  */
 void compact_dataset(void)
 {
-    int i, j, mpi_size, mpi_rank, err_num=0;
+    int i, j, mpi_size, mpi_rank, size, err_num=0;
     hbool_t use_gpfs = FALSE;
     hid_t iof, plist, dcpl, dxpl, dataset, filespace;
-    hsize_t file_dims [DIM]={SIZE,SIZE};
-    double outme [SIZE][SIZE], inme[SIZE][SIZE];
+    hsize_t file_dims [DIM];
+    double * outme;
+    double * inme;
     char dname[]="dataset";
     herr_t ret;
     char *filename;
+
+    size = get_size();
+
+    for ( i = 0; i < DIM; i++ )
+    {
+        file_dims[i] = size;
+    }
                                 
     MPI_Comm_rank (MPI_COMM_WORLD, &mpi_rank);
     MPI_Comm_size (MPI_COMM_WORLD, &mpi_size);
 
+    outme = HDmalloc((size_t)(size * size * sizeof(double)));
+    VRFY((outme != NULL), "HDmalloc succeeded for outme");
+
+    inme = HDmalloc((size_t)(size * size * sizeof(double)));
+    VRFY((outme != NULL), "HDmalloc succeeded for inme");
+
     filename = (char *) GetTestParameters();
-    VRFY((mpi_size <= SIZE), "mpi_size <= SIZE");
+    VRFY((mpi_size <= size), "mpi_size <= size");
 
     plist = create_faccess_plist(MPI_COMM_WORLD, MPI_INFO_NULL, facc_type, use_gpfs);
     iof = H5Fcreate (filename, H5F_ACC_TRUNC, H5P_DEFAULT, plist);
@@ -155,9 +227,9 @@ void compact_dataset(void)
     VRFY((ret >= 0), "H5Pcreate xfer succeeded");
 
     /* Recalculate data to write.  Each process writes the same data. */
-    for (i = 0; i < SIZE; i++)
-         for (j = 0; j < SIZE; j++)
-              outme [i][j] = (i+j)*1000;
+    for (i = 0; i < size; i++)
+         for (j = 0; j < size; j++)
+              outme[(i * size) + j] = (i+j)*1000;
 
     ret=H5Dwrite (dataset, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, dxpl, outme);
     VRFY((ret >= 0), "H5Dwrite succeeded");
@@ -186,20 +258,31 @@ void compact_dataset(void)
     VRFY((ret >= 0), "H5Dread succeeded");
 
     /* Verify data value */
-    for (i = 0; i < SIZE; i++)
-        for (j = 0; j < SIZE; j++)
-            if(inme[i][j] != outme[i][j])
+    for (i = 0; i < size; i++)
+        for (j = 0; j < size; j++)
+            if ( inme[(i * size) + j] != outme[(i * size) + j])
                 if(err_num++ < MAX_ERR_REPORT || VERBOSE_MED)
-                    printf("Dataset Verify failed at [%d][%d]: expect %f, got %f\n", i, j, outme[i][j], inme[i][j]); 
+                    printf("Dataset Verify failed at [%d][%d]: expect %f, got %f\n", i, j, outme[(i * size) + j], inme[(i * size) + j]); 
                                                             
     H5Pclose(plist);
     H5Pclose(dxpl);
     H5Dclose(dataset);
     H5Fclose(iof);
+    HDfree(inme);
+    HDfree(outme);
 }
 
-/* 
- * Example of using PHDF5 to create, write, and read dataset and attribute of Null dataspace.  
+/*
+ * Example of using PHDF5 to create, write, and read dataset and attribute 
+ * of Null dataspace.
+ *
+ * Changes:	Removed the assert that mpi_size <= the SIZE #define.
+ *		As best I can tell, this assert isn't needed here,
+ *		and in any case, the SIZE #define is being removed 
+ *		in an update of the functions in this file to run
+ *		with an arbitrary number of processes.
+ *
+ *                                         JRM - 8/24/04
  */
 void null_dataset(void)
 {
@@ -213,26 +296,26 @@ void null_dataset(void)
     char attr_name[]="attribute";
     herr_t ret;
     char *filename;
-                                
+
     MPI_Comm_rank (MPI_COMM_WORLD, &mpi_rank);
     MPI_Comm_size (MPI_COMM_WORLD, &mpi_size);
 
     filename = (char *) GetTestParameters();
-    VRFY((mpi_size <= SIZE), "mpi_size <= SIZE");
 
-    plist = create_faccess_plist(MPI_COMM_WORLD, MPI_INFO_NULL, facc_type, use_gpfs);
+    plist = create_faccess_plist(MPI_COMM_WORLD, MPI_INFO_NULL, 
+                                 facc_type, use_gpfs);
     iof = H5Fcreate (filename, H5F_ACC_TRUNC, H5P_DEFAULT, plist);
 
     /* Define data space */
     sid = H5Screate(H5S_NULL);
-    
+
     /* Check that the null dataspace actually has 0 elements */
     nelem = H5Sget_simple_extent_npoints(sid);
     VRFY((nelem== 0), "H5Sget_simple_extent_npoints");
 
     /* Create a compact dataset */
     dataset = H5Dcreate (iof, dname, H5T_NATIVE_UINT, sid, H5P_DEFAULT);
-    VRFY((dataset >= 0), "H5Dcreate succeeded");        
+    VRFY((dataset >= 0), "H5Dcreate succeeded");
 
     /* set up the collective transfer properties list */
     dxpl = H5Pcreate (H5P_DATASET_XFER);
@@ -243,11 +326,11 @@ void null_dataset(void)
     /* Write "nothing" to the dataset (with type conversion) */
     ret=H5Dwrite (dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, dxpl, &uval);
     VRFY((ret >= 0), "H5Dwrite succeeded");
-    
+
     /* Create an attribute for the group */
     attr=H5Acreate(dataset,attr_name,H5T_NATIVE_UINT,sid,H5P_DEFAULT);
     VRFY((attr>=0), "H5Acreate");
-    
+
     /* Write "nothing" to the attribute (with type conversion) */
     ret = H5Awrite(attr, H5T_NATIVE_INT, &val);
     VRFY((ret>=0), "H5Awrite");
@@ -271,21 +354,20 @@ void null_dataset(void)
 
     dataset = H5Dopen(iof, dname);
     VRFY((dataset >= 0), "H5Dcreate succeeded");
-    
+
     /* Try reading from the dataset (make certain our buffer is unmodified) */
     ret = H5Dread(dataset, H5T_NATIVE_UINT, H5S_ALL, H5S_ALL, dxpl, &uval);
     VRFY((ret>=0), "H5Dread");
     VRFY((uval==2), "H5Dread");
-    
+
     /* Open the attribute for the dataset */
     attr=H5Aopen_name(dataset,attr_name);
     VRFY((attr>=0), "H5Aopen_name");
-    
-    /* Try reading from the attribute (make certain our buffer is unmodified) */
-    ret = H5Aread(attr, H5T_NATIVE_INT, &val);
+
+    /* Try reading from the attribute (make certain our buffer is unmodified) */    ret = H5Aread(attr, H5T_NATIVE_INT, &val);
     VRFY((ret>=0), "H5Aread");
     VRFY((val==1), "H5Aread");
-                                                          
+
     H5Pclose(plist);
     H5Pclose(dxpl);
     H5Aclose (attr);
@@ -297,6 +379,14 @@ void null_dataset(void)
  * Actual data is _not_ written to these datasets.  Dataspaces are exact
  * sizes (2GB, 4GB, etc.), but the metadata for the file pushes the file over
  * the boundary of interest.
+ *
+ * Changes:	Removed the assert that mpi_size <= the SIZE #define.
+ *		As best I can tell, this assert isn't needed here,
+ *		and in any case, the SIZE #define is being removed 
+ *		in an update of the functions in this file to run
+ *		with an arbitrary number of processes.
+ *
+ *                                         JRM - 8/11/04
  */
 void big_dataset(void)
 {
@@ -319,7 +409,6 @@ void big_dataset(void)
     VRFY((sizeof(MPI_Offset)>4), "sizeof(MPI_Offset)>4");
 
     filename = (char *) GetTestParameters();
-    VRFY((mpi_size <= SIZE), "mpi_size <= SIZE");
 
     fapl = create_faccess_plist(MPI_COMM_WORLD, MPI_INFO_NULL, facc_type, use_gpfs);
     VRFY((fapl >= 0), "create_faccess_plist succeeded");        
@@ -419,6 +508,16 @@ void big_dataset(void)
 /* Example of using PHDF5 to read a partial written dataset.   The dataset does
  * not have actual data written to the entire raw data area and relies on the
  * default fill value of zeros to work correctly.
+ *
+ * Changes:	Removed the assert that mpi_size <= the SIZE #define.
+ *		As best I can tell, this assert isn't needed here,
+ *		and in any case, the SIZE #define is being removed 
+ *		in an update of the functions in this file to run
+ *		with an arbitrary number of processes.
+ * 
+ *		Also added code to free dynamically allocated buffers.
+ *
+ *                                         JRM - 8/11/04
  */
 void dataset_fillvalue(void)
 {
@@ -446,7 +545,6 @@ void dataset_fillvalue(void)
     MPI_Comm_size (MPI_COMM_WORLD, &mpi_size);
 
     filename = (char *) GetTestParameters();
-    VRFY((mpi_size <= SIZE), "mpi_size <= SIZE");
 
     /* Set the dataset dimension to be one row more than number of processes */
     /* and calculate the actual dataset size. */
@@ -591,22 +689,32 @@ void dataset_fillvalue(void)
     /* Close fapl */
     ret=H5Pclose (fapl);
     VRFY((ret >= 0), "H5Pclose succeeded");
+
+    /* free the buffers */
+    HDfree(rdata);
+    HDfree(wdata);
 }
 
 /* Write multiple groups with a chunked dataset in each group collectively. 
  * These groups and datasets are for testing independent read later.
+ *
+ * Changes:     Updated function to use a dynamically calculated size,
+ *              instead of the old SIZE #define.  This should allow it
+ *              to function with an arbitrary number of processors.
+ *
+ *                                              JRM - 8/16/04
  */
 void collective_group_write(void)
 {
-    int mpi_rank, mpi_size;
+    int mpi_rank, mpi_size, size;
     int i, j, m;
     hbool_t use_gpfs = FALSE;
     char gname[64], dname[32];
     hid_t fid, gid, did, plist, dcpl, memspace, filespace;
-    DATATYPE outme[SIZE][SIZE];
+    DATATYPE * outme = NULL;
     hssize_t chunk_origin[DIM];
     hsize_t chunk_dims[DIM], file_dims[DIM], count[DIM];
-    const hsize_t chunk_size[2] = {SIZE/2, SIZE/2};  /* Chunk dimensions */
+    hsize_t chunk_size[2];  /* Chunk dimensions - computed shortly */
     herr_t ret1, ret2;
     H5Ptest_param_t *pt;
     char	*filename;
@@ -619,12 +727,20 @@ void collective_group_write(void)
     MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
     MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
 
+    size = get_size();
+
+    chunk_size[0] = (hsize_t)(size / 2);
+    chunk_size[1] = (hsize_t)(size / 2);
+
+    outme = HDmalloc((size_t)(size * size * sizeof(DATATYPE)));
+    VRFY((outme != NULL), "HDmalloc succeeded for outme");
+
     plist = create_faccess_plist(MPI_COMM_WORLD, MPI_INFO_NULL, facc_type, use_gpfs);
     fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, plist);
     H5Pclose(plist);
 
     /* decide the hyperslab according to process number. */
-    get_slab(chunk_origin, chunk_dims, count, file_dims);  
+    get_slab(chunk_origin, chunk_dims, count, file_dims, size);  
 
     /* select hyperslab in memory and file spaces.  These two operations are
      * identical since the datasets are the same. */
@@ -655,9 +771,9 @@ void collective_group_write(void)
         did = H5Dcreate(gid, dname, H5T_NATIVE_INT, filespace, dcpl);
         VRFY((did > 0), dname);
 
-        for(i=0; i < SIZE; i++)
-            for(j=0; j < SIZE; j++)
-     	        outme[i][j] = (i+j)*1000 + mpi_rank;
+        for(i=0; i < size; i++)
+            for(j=0; j < size; j++)
+                outme[(i * size) + j] = (i+j)*1000 + mpi_rank;
 
         H5Dwrite(did, H5T_NATIVE_INT, memspace, filespace, H5P_DEFAULT, 
                  outme);
@@ -677,6 +793,8 @@ void collective_group_write(void)
     H5Sclose(filespace);
     H5Sclose(memspace);
     H5Fclose(fid);
+
+    HDfree(outme);
 }
 
 /* Let two sets of processes open and read different groups and chunked 
@@ -715,16 +833,33 @@ void independent_group_read(void)
     H5Fclose(fid);
 }
 
-/* Open and read datasets and compare data */
+/* Open and read datasets and compare data
+ *
+ * Changes:     Updated function to use a dynamically calculated size,
+ *              instead of the old SIZE #define.  This should allow it
+ *              to function with an arbitrary number of processors.
+ *
+ *		Also added code to verify the results of dynamic memory
+ *		allocations, and to free dynamically allocated memeory
+ *		when we are done with it.
+ *
+ *                                              JRM - 8/16/04
+ */
 void group_dataset_read(hid_t fid, int mpi_rank, int m)
 {
-    int      ret, i, j;
+    int      ret, i, j, size;
     char     gname[64], dname[32];
     hid_t    gid, did;
-    DATATYPE *outdata, *indata;
+    DATATYPE *outdata = NULL;
+    DATATYPE *indata = NULL;
+
+    size = get_size();
 
-    indata = (DATATYPE*)malloc(SIZE*SIZE*sizeof(DATATYPE));
-    outdata = (DATATYPE*)malloc(SIZE*SIZE*sizeof(DATATYPE));
+    indata = (DATATYPE*)HDmalloc((size_t)(size * size * sizeof(DATATYPE)));
+    VRFY((indata != NULL), "HDmalloc succeeded for indata");
+
+    outdata = (DATATYPE*)HDmalloc((size_t)(size * size * sizeof(DATATYPE)));
+    VRFY((outdata != NULL), "HDmalloc succeeded for outdata");
     
     /* open every group under root group. */
     sprintf(gname, "group%d", m);
@@ -739,19 +874,20 @@ void group_dataset_read(hid_t fid, int mpi_rank, int m)
     H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, indata);
 
     /* this is the original value */
-    for(i=0; i<SIZE; i++)
-       for(j=0; j<SIZE; j++) { 
-           *outdata = (i+j)*1000 + mpi_rank;
-           outdata++;
+    for(i=0; i<size; i++)
+       for(j=0; j<size; j++) { 
+           outdata[(i * size) + j] = (i+j)*1000 + mpi_rank;
        }
-    outdata -= SIZE*SIZE;
 
     /* compare the original value(outdata) to the value in file(indata).*/
-    ret = check_value(indata, outdata);
+    ret = check_value(indata, outdata, size);
     VRFY((ret==0), "check the data");
 
     H5Dclose(did);
     H5Gclose(gid);
+
+    HDfree(indata);
+    HDfree(outdata);
 }
 
 /*
@@ -779,10 +915,16 @@ void group_dataset_read(hid_t fid, int mpi_rank, int m)
  *      * means the group has dataset(s).
  *      + means the group has attribute(s).
  *      ' means the datasets in the groups have attribute(s).
+ *
+ * Changes:     Updated function to use a dynamically calculated size,
+ *              instead of the old SIZE #define.  This should allow it
+ *              to function with an arbitrary number of processors.
+ *
+ *                                              JRM - 8/16/04
  */
 void multiple_group_write(void)
 {
-    int mpi_rank, mpi_size;
+    int mpi_rank, mpi_size, size;
     int m;
     hbool_t use_gpfs = FALSE;
     char gname[64];
@@ -801,12 +943,14 @@ void multiple_group_write(void)
     MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
     MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
 
+    size = get_size();
+
     plist = create_faccess_plist(MPI_COMM_WORLD, MPI_INFO_NULL, facc_type, use_gpfs);
     fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, plist);
     H5Pclose(plist);
 
     /* decide the hyperslab according to process number. */
-    get_slab(chunk_origin, chunk_dims, count, file_dims);  
+    get_slab(chunk_origin, chunk_dims, count, file_dims, size);  
 
     /* select hyperslab in memory and file spaces.  These two operations are
      * identical since the datasets are the same. */
@@ -862,28 +1006,38 @@ void multiple_group_write(void)
 /* 
  * In a group, creates NDATASETS datasets.  Each process writes a hyperslab
  * of a data array to the file.
+ *
+ * Changes:     Updated function to use a dynamically calculated size,
+ *              instead of the old SIZE #define.  This should allow it
+ *              to function with an arbitrary number of processors.
+ *
+ *                                              JRM - 8/16/04
  */ 
 void write_dataset(hid_t memspace, hid_t filespace, hid_t gid)
 {
-    int i, j, n;
+    int i, j, n, size;
     int mpi_rank, mpi_size;
     char dname[32];
-    DATATYPE outme[SIZE][SIZE];
+    DATATYPE * outme = NULL;
     hid_t did;
-
   
     MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
     MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
 
+    size = get_size();
+
+    outme = HDmalloc((size_t)(size * size * sizeof(double)));
+    VRFY((outme != NULL), "HDmalloc succeeded for outme");
+
     for(n=0; n < NDATASET; n++) {
          sprintf(dname, "dataset%d", n);
          did = H5Dcreate(gid, dname, H5T_NATIVE_INT, filespace, 
                          H5P_DEFAULT);
          VRFY((did > 0), dname);
 
-         for(i=0; i < SIZE; i++)
-             for(j=0; j < SIZE; j++)
-     	         outme[i][j] = n*1000 + mpi_rank;
+         for(i=0; i < size; i++)
+             for(j=0; j < size; j++)
+     	         outme[(i * size) + j] = n*1000 + mpi_rank;
 
          H5Dwrite(did, H5T_NATIVE_INT, memspace, filespace, H5P_DEFAULT, 
                   outme);
@@ -893,6 +1047,7 @@ void write_dataset(hid_t memspace, hid_t filespace, hid_t gid)
 	 
          H5Dclose(did);
     }
+    HDfree(outme);
 }
 
 /* 
@@ -931,10 +1086,16 @@ void create_group_recursive(hid_t memspace, hid_t filespace, hid_t gid,
 /* 
  * This function is to verify the data from multiple group testing.  It opens
  * every dataset in every group and check their correctness.  
+ *
+ * Changes:     Updated function to use a dynamically calculated size,
+ *              instead of the old SIZE #define.  This should allow it
+ *              to function with an arbitrary number of processors.
+ *
+ *                                              JRM - 8/11/04
  */
 void multiple_group_read(void)
 {
-    int      mpi_rank, mpi_size, error_num;
+    int      mpi_rank, mpi_size, error_num, size;
     int      m;
     hbool_t  use_gpfs = FALSE;
     char     gname[64];
@@ -952,12 +1113,14 @@ void multiple_group_read(void)
     MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
     MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
 
+    size = get_size();
+
     plist = create_faccess_plist(MPI_COMM_WORLD, MPI_INFO_NULL, facc_type, use_gpfs);
     fid = H5Fopen(filename, H5F_ACC_RDONLY, plist);
     H5Pclose(plist);
 
     /* decide hyperslab for each process */
-    get_slab(chunk_origin, chunk_dims, count, file_dims);
+    get_slab(chunk_origin, chunk_dims, count, file_dims, size);
 
     /* select hyperslab for memory and file space */
     memspace  = H5Screate_simple(DIM, file_dims, NULL);
@@ -1006,19 +1169,30 @@ void multiple_group_read(void)
 /* 
  * This function opens all the datasets in a certain, checks the data using 
  * dataset_vrfy function.
+ *
+ * Changes:     Updated function to use a dynamically calculated size,
+ *              instead of the old SIZE #define.  This should allow it
+ *              to function with an arbitrary number of processors.
+ *
+ *                                              JRM - 8/11/04
  */
 int read_dataset(hid_t memspace, hid_t filespace, hid_t gid)
 {
-    int i, j, n, mpi_rank, mpi_size, attr_errors=0, vrfy_errors=0;
+    int i, j, n, mpi_rank, mpi_size, size, attr_errors=0, vrfy_errors=0;
     char dname[32];
-    DATATYPE *outdata, *indata;
+    DATATYPE *outdata = NULL, *indata = NULL;
     hid_t did;
 
     MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
     MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
 
-    indata = (DATATYPE*)malloc(SIZE*SIZE*sizeof(DATATYPE));
-    outdata = (DATATYPE*)malloc(SIZE*SIZE*sizeof(DATATYPE));
+    size = get_size();
+
+    indata = (DATATYPE*)HDmalloc((size_t)(size * size * sizeof(DATATYPE)));
+    VRFY((indata != NULL), "HDmalloc succeeded for indata");
+
+    outdata = (DATATYPE*)HDmalloc((size_t)(size * size * sizeof(DATATYPE)));
+    VRFY((outdata != NULL), "HDmalloc succeeded for outdata");
 
     for(n=0; n<NDATASET; n++) {
         sprintf(dname, "dataset%d", n);
@@ -1029,15 +1203,15 @@ int read_dataset(hid_t memspace, hid_t filespace, hid_t gid)
                 indata);
 
         /* this is the original value */
-        for(i=0; i<SIZE; i++)
-	    for(j=0; j<SIZE; j++) { 
+        for(i=0; i<size; i++)
+	    for(j=0; j<size; j++) { 
 	         *outdata = n*1000 + mpi_rank;
                  outdata++;
 	    }
-        outdata -= SIZE*SIZE;
+        outdata -= size * size;
 
         /* compare the original value(outdata) to the value in file(indata).*/
-        vrfy_errors = check_value(indata, outdata);
+        vrfy_errors = check_value(indata, outdata, size);
 
         /* check attribute.*/  
         if( (attr_errors = read_attribute(did, is_dset, n))>0 )
@@ -1046,8 +1220,8 @@ int read_dataset(hid_t memspace, hid_t filespace, hid_t gid)
         H5Dclose(did);
     }
 
-    free(indata);
-    free(outdata);
+    HDfree(indata);
+    HDfree(outdata);
 
     return vrfy_errors;
 }
@@ -1151,8 +1325,15 @@ int read_attribute(hid_t obj_id, int this_type, int num)
 }
 
 /* This functions compares the original data with the read-in data for its 
- * hyperslab part only by process ID. */
-int check_value(DATATYPE *indata, DATATYPE *outdata) 
+ * hyperslab part only by process ID.
+ *
+ * Changes:	Modified function to use a passed in size parameter
+ *		instead of the old SIZE #define.  This should let us
+ *		run with an arbitrary number of processes.
+ *
+ *					JRM - 8/16/04
+ */
+int check_value(DATATYPE *indata, DATATYPE *outdata, int size) 
 {
     int mpi_rank, mpi_size, err_num=0;
     hsize_t i, j;
@@ -1161,11 +1342,11 @@ int check_value(DATATYPE *indata, DATATYPE *outdata)
 
     MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
     MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
-    
-    get_slab(chunk_origin, chunk_dims, count, NULL);
 
-    indata += chunk_origin[0]*SIZE;
-    outdata += chunk_origin[0]*SIZE;
+    get_slab(chunk_origin, chunk_dims, count, NULL, size);
+
+    indata += chunk_origin[0]*size;
+    outdata += chunk_origin[0]*size;
     for(i=chunk_origin[0]; i<(chunk_origin[0]+chunk_dims[0]); i++)
          for(j=chunk_origin[1]; j<(chunk_origin[1]+chunk_dims[1]); j++) {
               if( *indata != *outdata )
@@ -1179,9 +1360,20 @@ int check_value(DATATYPE *indata, DATATYPE *outdata)
     return err_num;
 }
 
-/* Decide the portion of data chunk in dataset by process ID. */
-void get_slab(hssize_t chunk_origin[], hsize_t chunk_dims[], hsize_t count[],
-              hsize_t file_dims[])
+/* Decide the portion of data chunk in dataset by process ID.
+ *
+ * Changes:	Modified function to use a passed in size parameter
+ *		instead of the old SIZE #define.  This should let us
+ *		run with an arbitrary number of processes.
+ *
+ *					JRM - 8/11/04
+ */
+
+void get_slab(hssize_t chunk_origin[], 
+              hsize_t chunk_dims[], 
+              hsize_t count[],
+              hsize_t file_dims[],
+              int size)
 {
     int mpi_rank, mpi_size;
     
@@ -1189,15 +1381,15 @@ void get_slab(hssize_t chunk_origin[], hsize_t chunk_dims[], hsize_t count[],
     MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
 
     if(chunk_origin != NULL) {
-        chunk_origin[0] = mpi_rank * (SIZE/mpi_size);
+        chunk_origin[0] = mpi_rank * (size/mpi_size);
         chunk_origin[1] = 0;
     }
     if(chunk_dims != NULL) {
-        chunk_dims[0]   = SIZE/mpi_size;
-        chunk_dims[1]   = SIZE;
+        chunk_dims[0]   = size/mpi_size;
+        chunk_dims[1]   = size;
     }
     if(file_dims != NULL) 
-        file_dims[0] = file_dims[1] = SIZE;
+        file_dims[0] = file_dims[1] = size;
     if(count != NULL) 
         count[0] = count[1] = 1;
 }