[svn-r24000] Adding compactor_tests in the write location

19 files changed, 3180 insertions, 0 deletions

diff --git a/testff/compactor_tests/Makefile b/testff/compactor_tests/Makefile
new file mode 100644
index 0000000..8c75a6d
--- /dev/null
+++ b/testff/compactor_tests/Makefile
@@ -0,0 +1,34 @@
+all:	writes natives reads server
+
+writes:
+		h5pcc -o multiple-writes-test1 multiple-writes-test1.c
+		h5pcc -o multiple-writes-test2 multiple-writes-test2.c
+		h5pcc -o multiple-writes-test3 multiple-writes-test3.c
+		h5pcc -o multiple-writes-test4 multiple-writes-test4.c
+		h5pcc -o multiple-writes-test5 multiple-writes-test5.c
+		h5pcc -o parallel_write parallel_write.c
+
+server:		
+		h5pcc -o server  test_server.c
+
+natives:
+		h5pcc -o native-write-basic native_write_basic.c
+		h5pcc -o native-write-test1 native_write_test1.c
+		h5pcc -o native-write-test2 native_write_test2.c
+		h5pcc -o native-write-test3 native_write_test3.c	
+		h5pcc -o native-parallel-write native-parallel-write.c
+reads:
+		h5pcc -o read_test_1 read_test_1.c
+		h5pcc -o read_test_2 read_test_2.c
+		h5pcc -o read_test_3 read_test_3.c
+		h5pcc -o native_read_1 native_read_1.c
+		h5pcc -o native_read_2 native_read_2.c
+
+clean:
+	rm -rf multiple-writes-test1 multiple-writes-test2 read_test_1
+	rm -rf multiple-writes-test3 multiple-writes-test4 multiple-writes-test5
+	rm -rf server *.o *~ 
+	rm -rf parallel_write native-write-basic *.cfg
+	rm -rf native-write-test1 native-write-test2
+	rm -rf native-write-basic native-write-test3 native-parallel-write
+	rm -rf read_test_1 read_test_2 read_test_3 native_read_1 native_read_2
diff --git a/testff/compactor_tests/multiple-writes-test1.c b/testff/compactor_tests/multiple-writes-test1.c
new file mode 100644
index 0000000..754de5b
--- /dev/null
+++ b/testff/compactor_tests/multiple-writes-test1.c
@@ -0,0 +1,171 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include "mpi.h"
+#include "hdf5.h"
+
+#define NX     16                      /* dataset dimensions */
+#define NY     8
+#define RANK   2
+
+/*Entire write gets replaced
+write buffer values start with 10's and increases and writes increase*/
+
+
+int main (int argc, char **argv){
+  
+  const char filename[] = "eff_file.h5";
+  hid_t file_id;
+  hid_t dataspaceID, dataspace2;
+  hid_t dataspace3, dataspace4;
+  hid_t dataspace5, dataspace6;
+  hid_t dset_id;
+  hid_t fapl_id, dxpl_id;
+  
+  const unsigned int nelem = 60;
+  int *data = NULL, *data1 = NULL;
+  unsigned int i = 0;
+  hsize_t dimsf[2];
+  hsize_t count[2], offset[2];
+  hsize_t s[2], b[2];
+  int my_rank, my_size, ret;
+  int provided;
+  hid_t event_q, int_id;
+  int num_requests = 0;  
+  H5_status_t *status = NULL;
+
+  MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);
+  if(MPI_THREAD_MULTIPLE != provided) {
+    fprintf(stderr, "MPI does not have MPI_THREAD_MULTIPLE support\n");
+    exit(1);
+  }
+
+
+  EFF_init (MPI_COMM_WORLD, MPI_INFO_NULL);
+
+  MPI_Comm_rank (MPI_COMM_WORLD, &my_rank);
+  MPI_Comm_size (MPI_COMM_WORLD, &my_size);
+
+
+  if (my_size > 1){
+    fprintf(stderr, "APP processes = %d cannot be greater than 1 \n", my_size);
+    EFF_finalize();
+    MPI_Finalize();
+  }
+
+
+  fapl_id = H5Pcreate (H5P_FILE_ACCESS);
+  H5Pset_fapl_iod(fapl_id, MPI_COMM_WORLD, MPI_INFO_NULL);
+
+  event_q = H5EQcreate(fapl_id);
+  assert(event_q);
+
+  file_id = H5Fcreate_ff(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl_id, event_q);
+  assert(file_id);
+
+
+  dimsf[0] = NX;
+  dimsf[1] = NY;
+
+
+  dataspaceID = H5Screate_simple(RANK, dimsf, NULL); 
+  dataspace4 = H5Screate_simple(RANK, dimsf, NULL); 
+
+  dset_id = H5Dcreate_ff(file_id, "D1" , H5T_NATIVE_INT, dataspaceID,
+			 H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT, 0, event_q);
+  assert(dset_id);
+
+  count[0] = 8;
+  count[1] = 8;
+  offset[0] = 0;
+  offset[1] = 0;
+
+  fprintf (stderr, "%d: count[0]:%lli, count[1]:%lli, offset[0]: %lli, offset[1]: %lli\n",
+	   my_rank,
+	   count[0], count[1], offset[0], offset[1]);
+
+  dataspace2 = H5Screate_simple(RANK, count, NULL);
+
+  H5Sselect_hyperslab(dataspaceID, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+  
+  data = (int *) malloc(sizeof(int)*count[0]*count[1]);
+  for (i=0; i < count[0]*count[1]; i++) {
+    data[i] = my_rank + 10;
+  }
+ 
+  ret = H5Dwrite_ff(dset_id, 
+		    H5T_NATIVE_INT,
+		    dataspace2, 
+		    dataspaceID,
+		    H5P_DEFAULT,
+		    data,
+		    0,
+		    event_q);
+  assert(ret == 0);
+  
+  count[0] = 8;
+  count[1] = 8;
+  offset[0] = 0;
+  offset[1] = 0;
+
+
+  fprintf (stderr, "%d: count[0]:%lli, count[1]:%lli, offset[0]: %lli, offset[1]: %lli\n",
+	   my_rank,
+	   count[0], count[1], offset[0], offset[1]);
+
+  dataspace3 = H5Screate_simple(RANK, count, NULL);
+
+
+  H5Sselect_hyperslab(dataspace4, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+
+
+  data1 = (int *) malloc(sizeof(int)*count[0]*count[1]);
+  for (i=0; i < count[0]*count[1]; i++) {
+    data1[i] = my_rank + 12;
+
+  }
+
+
+  ret = H5Dwrite_ff(dset_id, 
+		    H5T_NATIVE_INT,
+		    dataspace3, 
+		    dataspace4,
+		    H5P_DEFAULT,
+		    data1,
+		    0,
+		    event_q);
+  assert(ret == 0);
+
+  /*  assert(H5Tclose_ff(int_id, event_q) == 0);*/
+  assert(H5Dclose_ff(dset_id, event_q) == 0);
+  H5Sclose(dataspaceID);
+  H5Sclose(dataspace2);
+  H5Sclose(dataspace3);
+  H5Sclose(dataspace4);
+  H5Pclose(fapl_id);
+  assert(H5Fclose_ff(file_id, event_q) == 0);
+  H5EQwait(event_q, &num_requests, &status);
+  free(status);
+  H5EQclose (event_q);
+
+  free(data);
+  free(data1);
+  fprintf(stderr, "\n*****************************************************************************************************************\n");
+  fprintf(stderr, "Finalize EFF stack\n");
+  fprintf(stderr, "*****************************************************************************************************************\n");
+  EFF_finalize();
+  MPI_Finalize();
+  
+  return 0;
+}
diff --git a/testff/compactor_tests/multiple-writes-test2.c b/testff/compactor_tests/multiple-writes-test2.c
new file mode 100644
index 0000000..d18795e
--- /dev/null
+++ b/testff/compactor_tests/multiple-writes-test2.c
@@ -0,0 +1,168 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include "mpi.h"
+#include "hdf5.h"
+
+#define NX     16                      /* dataset dimensions */
+#define NY     8
+#define RANK   2
+
+/*Second write -- writes more than first write but overlaps*/
+
+int main (int argc, char **argv){
+  
+  const char filename[] = "eff_file.h5";
+  hid_t file_id;
+  hid_t dataspaceID, dataspace2;
+  hid_t dataspace3, dataspace4;
+  hid_t dataspace5, dataspace6;
+  hid_t dset_id;
+  hid_t fapl_id, dxpl_id;
+  
+  const unsigned int nelem = 60;
+  int *data = NULL, *data1 = NULL;
+  unsigned int i = 0;
+  hsize_t dimsf[2];
+  hsize_t count[2], offset[2];
+  hsize_t s[2], b[2];
+  int my_rank, my_size, ret;
+  int provided;
+  hid_t event_q, int_id;
+  int num_requests = 0;  
+  H5_status_t *status = NULL;
+
+  MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);
+  if(MPI_THREAD_MULTIPLE != provided) {
+    fprintf(stderr, "MPI does not have MPI_THREAD_MULTIPLE support\n");
+    exit(1);
+  }
+
+
+  EFF_init (MPI_COMM_WORLD, MPI_INFO_NULL);
+
+  MPI_Comm_rank (MPI_COMM_WORLD, &my_rank);
+  MPI_Comm_size (MPI_COMM_WORLD, &my_size);
+
+
+  if (my_size > 1){
+    fprintf(stderr, "APP processes = %d cannot be greater than 1 \n", my_size);
+    MPI_Finalize();
+  }
+
+
+  fapl_id = H5Pcreate (H5P_FILE_ACCESS);
+  H5Pset_fapl_iod(fapl_id, MPI_COMM_WORLD, MPI_INFO_NULL);
+
+  event_q = H5EQcreate(fapl_id);
+  assert(event_q);
+
+  file_id = H5Fcreate_ff(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl_id, event_q);
+  assert(file_id);
+
+
+  dimsf[0] = NX;
+  dimsf[1] = NY;
+
+
+  dataspaceID = H5Screate_simple(RANK, dimsf, NULL); 
+  dataspace4 = H5Screate_simple(RANK, dimsf, NULL); 
+
+  dset_id = H5Dcreate_ff(file_id, "D1" , H5T_NATIVE_INT, dataspaceID,
+			 H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT, 0, event_q);
+  assert(dset_id);
+
+  count[0] = 4;
+  count[1] = 8;
+  offset[0] = 0;
+  offset[1] = 0;
+
+  fprintf (stderr, "%d: count[0]:%lli, count[1]:%lli, offset[0]: %lli, offset[1]: %lli\n",
+	   my_rank,
+	   count[0], count[1], offset[0], offset[1]);
+
+  dataspace2 = H5Screate_simple(RANK, count, NULL);
+
+  H5Sselect_hyperslab(dataspaceID, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+  
+  data = (int *) malloc(sizeof(int)*count[0]*count[1]);
+  for (i=0; i < count[0]*count[1]; i++) {
+    data[i] = my_rank + 10;
+  }
+ 
+  ret = H5Dwrite_ff(dset_id, 
+		    H5T_NATIVE_INT,
+		    dataspace2, 
+		    dataspaceID,
+		    H5P_DEFAULT,
+		    data,
+		    0,
+		    event_q);
+  assert(ret == 0);
+  
+  count[0] = 8;
+  count[1] = 8;
+  offset[0] = 2;
+  offset[1] = 0;
+
+
+  fprintf (stderr, "%d: count[0]:%lli, count[1]:%lli, offset[0]: %lli, offset[1]: %lli\n",
+	   my_rank,
+	   count[0], count[1], offset[0], offset[1]);
+
+  dataspace3 = H5Screate_simple(RANK, count, NULL);
+
+
+  H5Sselect_hyperslab(dataspace4, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+
+
+  data1 = (int *) malloc(sizeof(int)*count[0]*count[1]);
+  for (i=0; i < count[0]*count[1]; i++) {
+    data1[i] = my_rank + 12;
+
+  }
+
+
+  ret = H5Dwrite_ff(dset_id, 
+		    H5T_NATIVE_INT,
+		    dataspace3, 
+		    dataspace4,
+		    H5P_DEFAULT,
+		    data1,
+		    0,
+		    event_q);
+  assert(ret == 0);
+
+  /*  assert(H5Tclose_ff(int_id, event_q) == 0);*/
+  assert(H5Dclose_ff(dset_id, event_q) == 0);
+  H5Sclose(dataspaceID);
+  H5Sclose(dataspace2);
+  H5Sclose(dataspace3);
+  H5Sclose(dataspace4);
+  H5Pclose(fapl_id);
+  assert(H5Fclose_ff(file_id, event_q) == 0);
+  H5EQwait(event_q, &num_requests, &status);
+  free(status);
+  H5EQclose (event_q);
+
+  free(data);
+  free(data1);
+  fprintf(stderr, "\n*****************************************************************************************************************\n");
+  fprintf(stderr, "Finalize EFF stack\n");
+  fprintf(stderr, "*****************************************************************************************************************\n");
+  EFF_finalize();
+  MPI_Finalize();
+  
+  return 0;
+}
diff --git a/testff/compactor_tests/multiple-writes-test3.c b/testff/compactor_tests/multiple-writes-test3.c
new file mode 100644
index 0000000..9fa7170
--- /dev/null
+++ b/testff/compactor_tests/multiple-writes-test3.c
@@ -0,0 +1,254 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include "mpi.h"
+#include "hdf5.h"
+
+#define NX     16                      /* dataset dimensions */
+#define NY     8
+#define RANK   2
+
+
+
+int main (int argc, char **argv){
+  
+  const char filename[] = "eff_file.h5";
+  hid_t file_id;
+  hid_t dataspaceID, dataspace2;
+  hid_t dataspace3, dataspace4;
+  hid_t dataspace5, dataspace6;
+  hid_t dataspace7, dataspace8;
+  hid_t dset_id;
+  hid_t fapl_id, dxpl_id;
+  
+  const unsigned int nelem = 60;
+  int *data = NULL, *data1 = NULL;
+  int *data2 =  NULL, *data3 = NULL;
+  unsigned int i = 0;
+  hsize_t dimsf[2];
+  hsize_t count[2], offset[2];
+  hsize_t s[2], b[2];
+  int my_rank, my_size, ret;
+  int provided;
+  hid_t event_q, int_id;
+  int num_requests = 0;  
+  H5_status_t *status = NULL;
+
+  MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);
+  if(MPI_THREAD_MULTIPLE != provided) {
+    fprintf(stderr, "MPI does not have MPI_THREAD_MULTIPLE support\n");
+    exit(1);
+  }
+
+
+  EFF_init (MPI_COMM_WORLD, MPI_INFO_NULL);
+
+  MPI_Comm_rank (MPI_COMM_WORLD, &my_rank);
+  MPI_Comm_size (MPI_COMM_WORLD, &my_size);
+
+
+  if (my_size > 1){
+    fprintf(stderr, "APP processes = %d cannot be greater than 1 \n", my_size);
+    MPI_Finalize();
+  }
+
+
+  fapl_id = H5Pcreate (H5P_FILE_ACCESS);
+  H5Pset_fapl_iod(fapl_id, MPI_COMM_WORLD, MPI_INFO_NULL);
+
+  event_q = H5EQcreate(fapl_id);
+  assert(event_q);
+
+  file_id = H5Fcreate_ff(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl_id, event_q);
+  assert(file_id);
+
+
+  dimsf[0] = NX;
+  dimsf[1] = NY;
+
+
+  dataspaceID = H5Screate_simple(RANK, dimsf, NULL); 
+  dataspace4 = H5Screate_simple(RANK, dimsf, NULL); 
+  dataspace5 = H5Screate_simple(RANK, dimsf, NULL); 
+  dataspace7 = H5Screate_simple(RANK, dimsf, NULL); 
+
+  dset_id = H5Dcreate_ff(file_id, "D1" , H5T_NATIVE_INT, dataspaceID,
+			 H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT, 0, event_q);
+  assert(dset_id);
+
+  count[0] = 4;
+  count[1] = 8;
+  offset[0] = 0;
+  offset[1] = 0;
+
+  fprintf (stderr, "%d: count[0]:%lli, count[1]:%lli, offset[0]: %lli, offset[1]: %lli\n",
+	   my_rank,
+	   count[0], count[1], offset[0], offset[1]);
+
+  dataspace2 = H5Screate_simple(RANK, count, NULL);
+
+  H5Sselect_hyperslab(dataspaceID, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+  
+  data = (int *) malloc(sizeof(int)*count[0]*count[1]);
+  for (i=0; i < count[0]*count[1]; i++) {
+    data[i] = my_rank + 10;
+  }
+ 
+  ret = H5Dwrite_ff(dset_id, 
+		    H5T_NATIVE_INT,
+		    dataspace2, 
+		    dataspaceID,
+		    H5P_DEFAULT,
+		    data,
+		    0,
+		    event_q);
+  assert(ret == 0);
+  
+  count[0] = 2;
+  count[1] = 8;
+  offset[0] = 2;
+  offset[1] = 0;
+
+
+  fprintf (stderr, "%d: count[0]:%lli, count[1]:%lli, offset[0]: %lli, offset[1]: %lli\n",
+	   my_rank,
+	   count[0], count[1], offset[0], offset[1]);
+
+  dataspace3 = H5Screate_simple(RANK, count, NULL);
+
+
+  H5Sselect_hyperslab(dataspace4, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+
+
+  data1 = (int *) malloc(sizeof(int)*count[0]*count[1]);
+  for (i=0; i < count[0]*count[1]; i++) {
+    data1[i] = my_rank + 12;
+  }
+
+
+  ret = H5Dwrite_ff(dset_id, 
+		    H5T_NATIVE_INT,
+		    dataspace3, 
+		    dataspace4,
+		    H5P_DEFAULT,
+		    data1,
+		    0,
+		    event_q);
+  assert(ret == 0);
+
+
+  count[0] = 2;
+  count[1] = 8;
+  offset[0] = 6;
+  offset[1] = 0;
+
+
+  data2 = (int *) malloc(sizeof(int)*count[0]*count[1]);
+  for (i=0; i < count[0]*count[1]; i++) {
+    data2[i] = my_rank + 13;
+  }
+
+
+  
+  fprintf (stderr, "%d: count[0]:%lli, count[1]:%lli, offset[0]: %lli, offset[1]: %lli\n",
+	   my_rank,
+	   count[0], count[1], offset[0], offset[1]);
+  
+  dataspace6 = H5Screate_simple(RANK, count, NULL);
+
+  H5Sselect_hyperslab(dataspace5, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+  
+  
+
+  ret = H5Dwrite_ff(dset_id, 
+		    H5T_NATIVE_INT,
+		    dataspace6, 
+		    dataspace5,
+		    H5P_DEFAULT,
+		    data2,
+		    0,
+		    event_q);
+  assert(ret == 0);
+
+
+  count[0] = 4;
+  count[1] = 8;
+  offset[0] = 3;
+  offset[1] = 0;
+
+
+  data3 = (int *) malloc(sizeof(int)*count[0]*count[1]);
+  for (i=0; i < count[0]*count[1]; i++) {
+    data3[i] = my_rank + 14;
+  }
+
+
+  
+  fprintf (stderr, "%d: count[0]:%lli, count[1]:%lli, offset[0]: %lli, offset[1]: %lli\n",
+	   my_rank,
+	   count[0], count[1], offset[0], offset[1]);
+  
+  dataspace8 = H5Screate_simple(RANK, count, NULL);
+
+  H5Sselect_hyperslab(dataspace7, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+  
+  
+
+  ret = H5Dwrite_ff(dset_id, 
+		    H5T_NATIVE_INT,
+		    dataspace8, 
+		    dataspace7,
+		    H5P_DEFAULT,
+		    data3,
+		    0,
+		    event_q);
+  assert(ret == 0);
+
+
+  
+  
+
+  assert(H5Dclose_ff(dset_id, event_q) == 0);
+  H5Sclose(dataspaceID);
+  H5Sclose(dataspace2);
+  H5Sclose(dataspace3);
+  H5Sclose(dataspace4);
+  H5Sclose(dataspace5);
+  H5Sclose(dataspace6);
+  H5Pclose(fapl_id);
+  assert(H5Fclose_ff(file_id, event_q) == 0);
+  H5EQwait(event_q, &num_requests, &status);
+  free(status);
+  H5EQclose (event_q);
+
+  free(data);
+  free(data1);
+  fprintf(stderr, "\n*****************************************************************************************************************\n");
+  fprintf(stderr, "Finalize EFF stack\n");
+  fprintf(stderr, "*****************************************************************************************************************\n");
+  EFF_finalize();
+  MPI_Finalize();
+  
+  return 0;
+}
diff --git a/testff/compactor_tests/multiple-writes-test4.c b/testff/compactor_tests/multiple-writes-test4.c
new file mode 100644
index 0000000..0f32697
--- /dev/null
+++ b/testff/compactor_tests/multiple-writes-test4.c
@@ -0,0 +1,254 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include "mpi.h"
+#include "hdf5.h"
+
+#define NX     16                      /* dataset dimensions */
+#define NY     8
+#define RANK   2
+
+
+
+int main (int argc, char **argv){
+  
+  const char filename[] = "eff_file.h5";
+  hid_t file_id;
+  hid_t dataspaceID, dataspace2;
+  hid_t dataspace3, dataspace4;
+  hid_t dataspace5, dataspace6;
+  hid_t dataspace7, dataspace8;
+  hid_t dset_id;
+  hid_t fapl_id, dxpl_id;
+  
+  const unsigned int nelem = 60;
+  int *data = NULL, *data1 = NULL;
+  int *data2 =  NULL, *data3 = NULL;
+  unsigned int i = 0;
+  hsize_t dimsf[2];
+  hsize_t count[2], offset[2];
+  hsize_t s[2], b[2];
+  int my_rank, my_size, ret;
+  int provided;
+  hid_t event_q, int_id;
+  int num_requests = 0;  
+  H5_status_t *status = NULL;
+
+  MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);
+  if(MPI_THREAD_MULTIPLE != provided) {
+    fprintf(stderr, "MPI does not have MPI_THREAD_MULTIPLE support\n");
+    exit(1);
+  }
+
+
+  EFF_init (MPI_COMM_WORLD, MPI_INFO_NULL);
+
+  MPI_Comm_rank (MPI_COMM_WORLD, &my_rank);
+  MPI_Comm_size (MPI_COMM_WORLD, &my_size);
+
+
+  if (my_size > 1){
+    fprintf(stderr, "APP processes = %d cannot be greater than 1 \n", my_size);
+    MPI_Finalize();
+  }
+
+
+  fapl_id = H5Pcreate (H5P_FILE_ACCESS);
+  H5Pset_fapl_iod(fapl_id, MPI_COMM_WORLD, MPI_INFO_NULL);
+
+  event_q = H5EQcreate(fapl_id);
+  assert(event_q);
+
+  file_id = H5Fcreate_ff(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl_id, event_q);
+  assert(file_id);
+
+
+  dimsf[0] = NX;
+  dimsf[1] = NY;
+
+
+  dataspaceID = H5Screate_simple(RANK, dimsf, NULL); 
+  dataspace4 = H5Screate_simple(RANK, dimsf, NULL); 
+  dataspace5 = H5Screate_simple(RANK, dimsf, NULL); 
+  dataspace7 = H5Screate_simple(RANK, dimsf, NULL); 
+
+  dset_id = H5Dcreate_ff(file_id, "D1" , H5T_NATIVE_INT, dataspaceID,
+			 H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT, 0, event_q);
+  assert(dset_id);
+
+  count[0] = 4;
+  count[1] = 8;
+  offset[0] = 0;
+  offset[1] = 0;
+
+  fprintf (stderr, "%d: count[0]:%lli, count[1]:%lli, offset[0]: %lli, offset[1]: %lli\n",
+	   my_rank,
+	   count[0], count[1], offset[0], offset[1]);
+
+  dataspace2 = H5Screate_simple(RANK, count, NULL);
+
+  H5Sselect_hyperslab(dataspaceID, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+  
+  data = (int *) malloc(sizeof(int)*count[0]*count[1]);
+  for (i=0; i < count[0]*count[1]; i++) {
+    data[i] = my_rank + 10;
+  }
+ 
+  ret = H5Dwrite_ff(dset_id, 
+		    H5T_NATIVE_INT,
+		    dataspace2, 
+		    dataspaceID,
+		    H5P_DEFAULT,
+		    data,
+		    0,
+		    event_q);
+  assert(ret == 0);
+  
+  count[0] = 2;
+  count[1] = 8;
+  offset[0] = 2;
+  offset[1] = 0;
+
+
+  fprintf (stderr, "%d: count[0]:%lli, count[1]:%lli, offset[0]: %lli, offset[1]: %lli\n",
+	   my_rank,
+	   count[0], count[1], offset[0], offset[1]);
+
+  dataspace3 = H5Screate_simple(RANK, count, NULL);
+
+
+  H5Sselect_hyperslab(dataspace4, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+
+
+  data1 = (int *) malloc(sizeof(int)*count[0]*count[1]);
+  for (i=0; i < count[0]*count[1]; i++) {
+    data1[i] = my_rank + 12;
+  }
+
+
+  ret = H5Dwrite_ff(dset_id, 
+		    H5T_NATIVE_INT,
+		    dataspace3, 
+		    dataspace4,
+		    H5P_DEFAULT,
+		    data1,
+		    0,
+		    event_q);
+  assert(ret == 0);
+
+
+  count[0] = 2;
+  count[1] = 8;
+  offset[0] = 6;
+  offset[1] = 0;
+
+
+  data2 = (int *) malloc(sizeof(int)*count[0]*count[1]);
+  for (i=0; i < count[0]*count[1]; i++) {
+    data2[i] = my_rank + 13;
+  }
+
+
+  
+  fprintf (stderr, "%d: count[0]:%lli, count[1]:%lli, offset[0]: %lli, offset[1]: %lli\n",
+	   my_rank,
+	   count[0], count[1], offset[0], offset[1]);
+  
+  dataspace6 = H5Screate_simple(RANK, count, NULL);
+
+  H5Sselect_hyperslab(dataspace5, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+  
+  
+
+  ret = H5Dwrite_ff(dset_id, 
+		    H5T_NATIVE_INT,
+		    dataspace6, 
+		    dataspace5,
+		    H5P_DEFAULT,
+		    data2,
+		    0,
+		    event_q);
+  assert(ret == 0);
+
+
+  count[0] = 8;
+  count[1] = 8;
+  offset[0] = 2;
+  offset[1] = 0;
+
+
+  data3 = (int *) malloc(sizeof(int)*count[0]*count[1]);
+  for (i=0; i < count[0]*count[1]; i++) {
+    data3[i] = my_rank + 14;
+  }
+
+
+  
+  fprintf (stderr, "%d: count[0]:%lli, count[1]:%lli, offset[0]: %lli, offset[1]: %lli\n",
+	   my_rank,
+	   count[0], count[1], offset[0], offset[1]);
+  
+  dataspace8 = H5Screate_simple(RANK, count, NULL);
+
+  H5Sselect_hyperslab(dataspace7, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+  
+  
+
+  ret = H5Dwrite_ff(dset_id, 
+		    H5T_NATIVE_INT,
+		    dataspace8, 
+		    dataspace7,
+		    H5P_DEFAULT,
+		    data3,
+		    0,
+		    event_q);
+  assert(ret == 0);
+
+
+  
+  
+
+  assert(H5Dclose_ff(dset_id, event_q) == 0);
+  H5Sclose(dataspaceID);
+  H5Sclose(dataspace2);
+  H5Sclose(dataspace3);
+  H5Sclose(dataspace4);
+  H5Sclose(dataspace5);
+  H5Sclose(dataspace6);
+  H5Pclose(fapl_id);
+  assert(H5Fclose_ff(file_id, event_q) == 0);
+  H5EQwait(event_q, &num_requests, &status);
+  free(status);
+  H5EQclose (event_q);
+
+  free(data);
+  free(data1);
+  fprintf(stderr, "\n*****************************************************************************************************************\n");
+  fprintf(stderr, "Finalize EFF stack\n");
+  fprintf(stderr, "*****************************************************************************************************************\n");
+  EFF_finalize();
+  MPI_Finalize();
+  
+  return 0;
+}
diff --git a/testff/compactor_tests/multiple-writes-test5.c b/testff/compactor_tests/multiple-writes-test5.c
new file mode 100644
index 0000000..2cea44b
--- /dev/null
+++ b/testff/compactor_tests/multiple-writes-test5.c
@@ -0,0 +1,254 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include "mpi.h"
+#include "hdf5.h"
+
+#define NX     16                      /* dataset dimensions */
+#define NY     8
+#define RANK   2
+
+
+
+int main (int argc, char **argv){
+  
+  const char filename[] = "eff_file.h5";
+  hid_t file_id;
+  hid_t dataspaceID, dataspace2;
+  hid_t dataspace3, dataspace4;
+  hid_t dataspace5, dataspace6;
+  hid_t dataspace7, dataspace8;
+  hid_t dset_id;
+  hid_t fapl_id, dxpl_id;
+  
+  const unsigned int nelem = 60;
+  int *data = NULL, *data1 = NULL;
+  int *data2 =  NULL, *data3 = NULL;
+  unsigned int i = 0;
+  hsize_t dimsf[2];
+  hsize_t count[2], offset[2];
+  hsize_t s[2], b[2];
+  int my_rank, my_size, ret;
+  int provided;
+  hid_t event_q, int_id;
+  int num_requests = 0;  
+  H5_status_t *status = NULL;
+
+  MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);
+  if(MPI_THREAD_MULTIPLE != provided) {
+    fprintf(stderr, "MPI does not have MPI_THREAD_MULTIPLE support\n");
+    exit(1);
+  }
+
+
+  EFF_init (MPI_COMM_WORLD, MPI_INFO_NULL);
+
+  MPI_Comm_rank (MPI_COMM_WORLD, &my_rank);
+  MPI_Comm_size (MPI_COMM_WORLD, &my_size);
+
+
+  if (my_size > 1){
+    fprintf(stderr, "APP processes = %d cannot be greater than 1 \n", my_size);
+    MPI_Finalize();
+  }
+
+
+  fapl_id = H5Pcreate (H5P_FILE_ACCESS);
+  H5Pset_fapl_iod(fapl_id, MPI_COMM_WORLD, MPI_INFO_NULL);
+
+  event_q = H5EQcreate(fapl_id);
+  assert(event_q);
+
+  file_id = H5Fcreate_ff(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl_id, event_q);
+  assert(file_id);
+
+
+  dimsf[0] = NX;
+  dimsf[1] = NY;
+
+
+  dataspaceID = H5Screate_simple(RANK, dimsf, NULL); 
+  dataspace4 = H5Screate_simple(RANK, dimsf, NULL); 
+  dataspace5 = H5Screate_simple(RANK, dimsf, NULL); 
+  dataspace7 = H5Screate_simple(RANK, dimsf, NULL); 
+
+  dset_id = H5Dcreate_ff(file_id, "D1" , H5T_NATIVE_INT, dataspaceID,
+			 H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT, 0, event_q);
+  assert(dset_id);
+
+  count[0] = 4;
+  count[1] = 4;
+  offset[0] = 0;
+  offset[1] = 0;
+
+  fprintf (stderr, "%d: count[0]:%lli, count[1]:%lli, offset[0]: %lli, offset[1]: %lli\n",
+	   my_rank,
+	   count[0], count[1], offset[0], offset[1]);
+
+  dataspace2 = H5Screate_simple(RANK, count, NULL);
+
+  H5Sselect_hyperslab(dataspaceID, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+  
+  data = (int *) malloc(sizeof(int)*count[0]*count[1]);
+  for (i=0; i < count[0]*count[1]; i++) {
+    data[i] = my_rank + 10;
+  }
+ 
+  ret = H5Dwrite_ff(dset_id, 
+		    H5T_NATIVE_INT,
+		    dataspace2, 
+		    dataspaceID,
+		    H5P_DEFAULT,
+		    data,
+		    0,
+		    event_q);
+  assert(ret == 0);
+  
+  count[0] = 4;
+  count[1] = 4;
+  offset[0] = 6;
+  offset[1] = 0;
+
+
+  fprintf (stderr, "%d: count[0]:%lli, count[1]:%lli, offset[0]: %lli, offset[1]: %lli\n",
+	   my_rank,
+	   count[0], count[1], offset[0], offset[1]);
+
+  dataspace3 = H5Screate_simple(RANK, count, NULL);
+
+
+  H5Sselect_hyperslab(dataspace4, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+
+
+  data1 = (int *) malloc(sizeof(int)*count[0]*count[1]);
+  for (i=0; i < count[0]*count[1]; i++) {
+    data1[i] = my_rank + 12;
+  }
+
+
+  ret = H5Dwrite_ff(dset_id, 
+		    H5T_NATIVE_INT,
+		    dataspace3, 
+		    dataspace4,
+		    H5P_DEFAULT,
+		    data1,
+		    0,
+		    event_q);
+  assert(ret == 0);
+
+
+  count[0] = 4;
+  count[1] = 4;
+  offset[0] = 3;
+  offset[1] = 0;
+
+
+  data2 = (int *) malloc(sizeof(int)*count[0]*count[1]);
+  for (i=0; i < count[0]*count[1]; i++) {
+    data2[i] = my_rank + 13;
+  }
+
+
+  
+  fprintf (stderr, "%d: count[0]:%lli, count[1]:%lli, offset[0]: %lli, offset[1]: %lli\n",
+	   my_rank,
+	   count[0], count[1], offset[0], offset[1]);
+  
+  dataspace6 = H5Screate_simple(RANK, count, NULL);
+
+  H5Sselect_hyperslab(dataspace5, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+  
+  
+
+  ret = H5Dwrite_ff(dset_id, 
+		    H5T_NATIVE_INT,
+		    dataspace6, 
+		    dataspace5,
+		    H5P_DEFAULT,
+		    data2,
+		    0,
+		    event_q);
+  assert(ret == 0);
+
+
+  count[0] = 8;
+  count[1] = 5;
+  offset[0] = 0;
+  offset[1] = 3;
+
+
+  data3 = (int *) malloc(sizeof(int)*count[0]*count[1]);
+  for (i=0; i < count[0]*count[1]; i++) {
+    data3[i] = my_rank + 14;
+  }
+
+
+  
+  fprintf (stderr, "%d: count[0]:%lli, count[1]:%lli, offset[0]: %lli, offset[1]: %lli\n",
+	   my_rank,
+	   count[0], count[1], offset[0], offset[1]);
+  
+  dataspace8 = H5Screate_simple(RANK, count, NULL);
+
+  H5Sselect_hyperslab(dataspace7, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+  
+  
+
+  ret = H5Dwrite_ff(dset_id, 
+		    H5T_NATIVE_INT,
+		    dataspace8, 
+		    dataspace7,
+		    H5P_DEFAULT,
+		    data3,
+		    0,
+		    event_q);
+  assert(ret == 0);
+
+
+  
+  
+
+  assert(H5Dclose_ff(dset_id, event_q) == 0);
+  H5Sclose(dataspaceID);
+  H5Sclose(dataspace2);
+  H5Sclose(dataspace3);
+  H5Sclose(dataspace4);
+  H5Sclose(dataspace5);
+  H5Sclose(dataspace6);
+  H5Pclose(fapl_id);
+  assert(H5Fclose_ff(file_id, event_q) == 0);
+  H5EQwait(event_q, &num_requests, &status);
+  free(status);
+  H5EQclose (event_q);
+
+  free(data);
+  free(data1);
+  fprintf(stderr, "\n*****************************************************************************************************************\n");
+  fprintf(stderr, "Finalize EFF stack\n");
+  fprintf(stderr, "*****************************************************************************************************************\n");
+  EFF_finalize();
+  MPI_Finalize();
+  
+  return 0;
+}
diff --git a/testff/compactor_tests/native-parallel-write-large.c b/testff/compactor_tests/native-parallel-write-large.c
new file mode 100644
index 0000000..d0a9b55
--- /dev/null
+++ b/testff/compactor_tests/native-parallel-write-large.c
@@ -0,0 +1,144 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include "mpi.h"
+#include "hdf5.h"
+
+#define NX     8                      /* dataset dimensions */
+#define NY     8 
+#define RANK   2
+
+
+
+int main (int argc, char **argv){
+  
+  const char filename[] = "eff_file.h5";
+  hid_t file_id, file_id_new;
+  hid_t dataspaceID, dataspace2;
+  hid_t dset_id, dset_id_new;
+  hid_t fapl_id, dxpl_id, fapl_self_id;
+  
+  const unsigned int nelem = 60;
+  int *data = NULL;
+  unsigned int i = 0;
+  hsize_t dimsf[2];
+  hsize_t count[2], offset[2];
+
+  int my_rank, my_size, ret;
+  int provided;
+  hid_t event_q, int_id;
+  
+  int num_requests = 0;  
+  H5_status_t *status = NULL;
+
+  MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);
+  if(MPI_THREAD_MULTIPLE != provided) {
+    fprintf(stderr, "MPI does not have MPI_THREAD_MULTIPLE support\n");
+    exit(1);
+  }
+
+  EFF_init (MPI_COMM_WORLD, MPI_INFO_NULL);
+
+  MPI_Comm_rank (MPI_COMM_WORLD, &my_rank);
+  MPI_Comm_size (MPI_COMM_WORLD, &my_size);
+
+  if (my_size > 8){
+    fprintf (stderr, "Max only 8 processes in this code!\n");
+    EFF_finalize();
+    MPI_Finalize();
+  }
+  fprintf(stderr, "APP processes = %d, my rank is %d\n", my_size, my_rank);
+
+  fapl_id = H5Pcreate (H5P_FILE_ACCESS);
+  H5Pset_fapl_iod(fapl_id, MPI_COMM_WORLD, MPI_INFO_NULL);
+
+
+  event_q = H5EQcreate(fapl_id);
+  assert(event_q);
+  dimsf[0] = NX;
+  dimsf[1] = NY;
+  dataspaceID = H5Screate_simple(RANK, dimsf, NULL); 
+
+  if (!my_rank){
+
+    fapl_self_id = H5Pcreate (H5P_FILE_ACCESS);
+    H5Pset_fapl_iod(fapl_self_id, MPI_COMM_SELF, MPI_INFO_NULL);
+  
+    fprintf(stderr,"Rank %d creating a File\n", my_rank);
+    file_id = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl_self_id);
+    fprintf(stderr,"Rank %d completed creating a file\n", my_rank);
+    fprintf(stderr,"Rank %d creating a dataset\n", my_rank);
+    dset_id = H5Dcreate(file_id, "D1" , H5T_NATIVE_INT, dataspaceID,
+		      H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+    fprintf(stderr,"completed creating a dataset\n", my_rank);
+    H5Pclose(fapl_self_id);
+    H5Dclose(dset_id);
+    H5Fclose(file_id);
+  }
+  
+  MPI_Barrier(MPI_COMM_WORLD);
+  
+  file_id_new = H5Fopen(filename, H5F_ACC_RDWR, fapl_id );
+  dset_id_new = H5Dopen(file_id_new, "D1", H5P_DEFAULT);
+
+  fprintf (stderr, "%d : file_id : %d, dset_id: %d\n",
+	   my_rank,
+	   file_id_new, dset_id);
+  
+  count[0] = NY/my_size;
+  count[1] = 8;
+  offset[0] = my_rank * count[0];
+  offset[1] = 0;
+
+  dataspace2 = H5Screate_simple(RANK, count, NULL);
+
+  H5Sselect_hyperslab(dataspaceID, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+
+  
+  data = (int *) malloc(sizeof(int)*count[0]*count[1]);
+  for (i=0; i < count[0]*count[1]; i++) {
+    data[i] = my_rank + 10;
+  }
+  
+ 
+  ret = H5Dwrite_ff(dset_id_new, 
+		    H5T_NATIVE_INT,
+		    dataspace2, 
+		    dataspaceID,
+		    H5P_DEFAULT,
+		    data,
+		    0,
+		    event_q);
+  assert(ret == 0);
+  
+
+
+
+
+  H5EQwait(event_q, &num_requests, &status);
+  free(status);
+
+  H5Sclose(dataspaceID);
+  H5Sclose(dataspace2);
+  H5Pclose(fapl_id);
+  H5Dclose(dset_id_new);
+
+  H5Fclose(file_id_new);
+
+  H5EQclose (event_q);
+
+  free(data);
+  fprintf(stderr, "\n*****************************************************************************************************************\n");
+  fprintf(stderr, "Finalize EFF stack\n");
+  fprintf(stderr, "*****************************************************************************************************************\n");
+  EFF_finalize();
+  MPI_Finalize();
+  
+  return 0;
+}
diff --git a/testff/compactor_tests/native-parallel-write.c b/testff/compactor_tests/native-parallel-write.c
new file mode 100644
index 0000000..66d7cc2
--- /dev/null
+++ b/testff/compactor_tests/native-parallel-write.c
@@ -0,0 +1,144 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include "mpi.h"
+#include "hdf5.h"
+
+#define NX     1024                     /* dataset dimensions */
+#define NY     1024
+#define RANK   2
+
+
+
+int main (int argc, char **argv){
+  
+  const char filename[] = "eff_file.h5";
+  hid_t file_id, file_id_new;
+  hid_t dataspaceID, dataspace2;
+  hid_t dset_id, dset_id_new;
+  hid_t fapl_id, dxpl_id, fapl_self_id;
+  
+  const unsigned int nelem = 60;
+  int *data = NULL;
+  unsigned int i = 0;
+  hsize_t dimsf[2];
+  hsize_t count[2], offset[2];
+
+  int my_rank, my_size, ret;
+  int provided;
+  hid_t event_q, int_id;
+  
+  int num_requests = 0;  
+  H5_status_t *status = NULL;
+
+  MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);
+  if(MPI_THREAD_MULTIPLE != provided) {
+    fprintf(stderr, "MPI does not have MPI_THREAD_MULTIPLE support\n");
+    exit(1);
+  }
+
+  EFF_init (MPI_COMM_WORLD, MPI_INFO_NULL);
+
+  MPI_Comm_rank (MPI_COMM_WORLD, &my_rank);
+  MPI_Comm_size (MPI_COMM_WORLD, &my_size);
+
+  if (my_size > 8){
+    fprintf (stderr, "Max only 8 processes in this code!\n");
+    EFF_finalize();
+    MPI_Finalize();
+  }
+  fprintf(stderr, "APP processes = %d, my rank is %d\n", my_size, my_rank);
+
+  fapl_id = H5Pcreate (H5P_FILE_ACCESS);
+  H5Pset_fapl_iod(fapl_id, MPI_COMM_WORLD, MPI_INFO_NULL);
+
+
+  event_q = H5EQcreate(fapl_id);
+  assert(event_q);
+  dimsf[0] = NX;
+  dimsf[1] = NY;
+  dataspaceID = H5Screate_simple(RANK, dimsf, NULL); 
+
+  if (!my_rank){
+
+    fapl_self_id = H5Pcreate (H5P_FILE_ACCESS);
+    H5Pset_fapl_iod(fapl_self_id, MPI_COMM_SELF, MPI_INFO_NULL);
+  
+    fprintf(stderr,"Rank %d creating a File\n", my_rank);
+    file_id = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl_self_id);
+    fprintf(stderr,"Rank %d completed creating a file\n", my_rank);
+    fprintf(stderr,"Rank %d creating a dataset\n", my_rank);
+    dset_id = H5Dcreate(file_id, "D1" , H5T_NATIVE_INT, dataspaceID,
+		      H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+    fprintf(stderr,"completed creating a dataset\n", my_rank);
+    H5Pclose(fapl_self_id);
+    H5Dclose(dset_id);
+    H5Fclose(file_id);
+  }
+  
+  MPI_Barrier(MPI_COMM_WORLD);
+  
+  file_id_new = H5Fopen(filename, H5F_ACC_RDWR, fapl_id );
+  dset_id_new = H5Dopen(file_id_new, "D1", H5P_DEFAULT);
+
+  fprintf (stderr, "%d : file_id : %d, dset_id: %d\n",
+	   my_rank,
+	   file_id_new, dset_id);
+  
+  count[0] = NY/my_size;
+  count[1] = NY;
+  offset[0] = my_rank * count[0];
+  offset[1] = 0;
+
+  dataspace2 = H5Screate_simple(RANK, count, NULL);
+
+  H5Sselect_hyperslab(dataspaceID, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+
+  
+  data = (int *) malloc(sizeof(int)*count[0]*count[1]);
+  for (i=0; i < count[0]*count[1]; i++) {
+    data[i] = my_rank + 10;
+  }
+  
+ 
+  ret = H5Dwrite_ff(dset_id_new, 
+		    H5T_NATIVE_INT,
+		    dataspace2, 
+		    dataspaceID,
+		    H5P_DEFAULT,
+		    data,
+		    0,
+		    event_q);
+  assert(ret == 0);
+  
+
+
+
+
+  H5EQwait(event_q, &num_requests, &status);
+  free(status);
+
+  H5Sclose(dataspaceID);
+  H5Sclose(dataspace2);
+  H5Pclose(fapl_id);
+  H5Dclose(dset_id_new);
+
+  H5Fclose(file_id_new);
+
+  H5EQclose (event_q);
+
+  free(data);
+  fprintf(stderr, "\n*****************************************************************************************************************\n");
+  fprintf(stderr, "Finalize EFF stack\n");
+  fprintf(stderr, "*****************************************************************************************************************\n");
+  EFF_finalize();
+  MPI_Finalize();
+  
+  return 0;
+}
diff --git a/testff/compactor_tests/native_read_1.c b/testff/compactor_tests/native_read_1.c
new file mode 100644
index 0000000..cf4ed0b
--- /dev/null
+++ b/testff/compactor_tests/native_read_1.c
@@ -0,0 +1,160 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include "mpi.h"
+#include "hdf5.h"
+
+#define NX     16                   
+#define NY     8
+#define RANK   2
+
+
+
+int main (int argc, char **argv){
+
+  const char filename[] = "eff_file.h5";
+  hid_t file_id;
+  hid_t dataspace3, dataspace4;
+  hid_t dataspace7, dataspace8;
+  
+  hid_t dset_id;
+  hid_t fapl_id, dxpl_id;
+  
+  const unsigned int nelem = 60;
+  int *data2 = NULL, *data3 = NULL;
+  unsigned int i = 0;
+  hsize_t dimsf[2];
+  hsize_t count[2], offset[2];
+  int my_rank, my_size, ret;
+  int provided;
+  hid_t event_q, int_id;
+  int num_requests = 0;
+  H5_status_t *status = NULL;
+  MPI_Comm comm;
+  MPI_Info info;
+
+  
+  MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);
+  if(MPI_THREAD_MULTIPLE != provided) {
+    fprintf(stderr, "MPI does not have MPI_THREAD_MULTIPLE support\n");
+    exit(1);
+  }
+
+  comm = MPI_COMM_WORLD;
+  info = MPI_INFO_NULL;
+  
+  EFF_init (comm, info);
+  MPI_Comm_rank (comm, &my_rank);
+  MPI_Comm_size (comm, &my_size);
+
+  if (my_size > 1){
+    fprintf(stderr, "APP processes = %d cannot be greater than 1 \n", my_size);
+    EFF_finalize();
+    MPI_Finalize();
+  }
+
+  fapl_id = H5Pcreate (H5P_FILE_ACCESS);
+  H5Pset_fapl_iod(fapl_id, comm, info);
+
+  event_q = H5EQcreate(fapl_id);
+  assert(event_q);
+
+  file_id = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl_id);
+  
+  dimsf[0] = NX;
+  dimsf[1] = NY;
+
+
+  dataspace3 = H5Screate_simple(RANK, dimsf, NULL);
+  dataspace7 = H5Screate_simple(RANK, dimsf, NULL);
+ 
+  dset_id  = H5Dcreate (file_id, "D1", H5T_NATIVE_INT, dataspace3, 
+			H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+  assert(dset_id);
+  
+
+
+  count[0] = 8;
+  count[1] = 8;
+  offset[0] = 0;
+  offset[1] = 0;
+  H5Sselect_hyperslab(dataspace7, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+
+  data3 = (int *) malloc (sizeof(int)*count[0]*count[1]);
+  for (i = 0; i < count[0]*count[1]; i++){
+    data3[i] = 1024;
+  }
+  
+  dataspace8 = H5Screate_simple(RANK, count, NULL);
+
+
+  ret = H5Dwrite_ff(dset_id,
+		    H5T_NATIVE_INT,
+		    dataspace8,
+		    dataspace7,
+		    H5P_DEFAULT,
+		    data3,
+		    0,
+		    event_q);
+  assert(ret == 0);
+  
+  count[0] = 8;
+  count[1] = 1;
+  offset[0] = 0;
+  offset[1] = 0;
+
+
+  dataspace4 = H5Screate_simple(RANK, count, NULL);
+
+  H5Sselect_hyperslab(dataspace3, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+
+
+
+  data2 = (int *) malloc(sizeof(int)*count[0]*count[1]);
+
+  ret = H5Dread_ff(dset_id, 
+		   H5T_NATIVE_INT,
+		   dataspace4, 
+		   dataspace3,
+		   H5P_DEFAULT,
+		   data2,
+		   0,
+		   event_q);
+  assert(ret == 0);
+
+  H5Dclose(dset_id);
+  H5Sclose(dataspace3); H5Sclose(dataspace4);
+  H5Sclose(dataspace7); H5Sclose(dataspace8);
+  H5Pclose(fapl_id);
+  H5Fclose(file_id);
+  H5EQwait(event_q, &num_requests, &status);
+  free(status);
+  H5EQclose (event_q);
+
+  for (i = 0; i < 8; i++){
+    fprintf (stderr,"data2[%d]: %d\n",
+	     i, data2[i]);
+  }
+
+  free(data2);
+  free(data3);
+  fprintf(stderr, "\n*****************************************************************************************************************\n");
+  fprintf(stderr, "Finalize EFF stack\n");
+  fprintf(stderr, "*****************************************************************************************************************\n");
+  
+  EFF_finalize();
+  MPI_Finalize();
+  
+  return 0;
+}
diff --git a/testff/compactor_tests/native_read_2.c b/testff/compactor_tests/native_read_2.c
new file mode 100644
index 0000000..fa4ae6e
--- /dev/null
+++ b/testff/compactor_tests/native_read_2.c
@@ -0,0 +1,233 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include "mpi.h"
+#include "hdf5.h"
+
+#define NX     16                   
+#define NY     8
+#define RANK   2
+
+
+
+int main (int argc, char **argv){
+
+  const char filename[] = "eff_file.h5";
+  hid_t file_id;
+  hid_t dataspace1, dataspace2;
+  hid_t dataspace3, dataspace4;
+  hid_t dataspace5, dataspace6;
+  hid_t dataspace7, dataspace8;
+  
+  hid_t dset_id;
+  hid_t fapl_id, dxpl_id;
+  
+  const unsigned int nelem = 60;
+  int *data = NULL, *data1 = NULL;
+  int *data2 = NULL, *data3 = NULL;
+  unsigned int i = 0;
+  hsize_t dimsf[2];
+  hsize_t count[2], offset[2];
+  int my_rank, my_size, ret;
+  int provided;
+  hid_t event_q, int_id;
+  int num_requests = 0;
+  H5_status_t *status = NULL;
+  MPI_Comm comm;
+  MPI_Info info;
+
+  
+  MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);
+  if(MPI_THREAD_MULTIPLE != provided) {
+    fprintf(stderr, "MPI does not have MPI_THREAD_MULTIPLE support\n");
+    exit(1);
+  }
+
+  comm = MPI_COMM_WORLD;
+  info = MPI_INFO_NULL;
+  
+  EFF_init (comm, info);
+  MPI_Comm_rank (comm, &my_rank);
+  MPI_Comm_size (comm, &my_size);
+
+  if (my_size > 1){
+    fprintf(stderr, "APP processes = %d cannot be greater than 1 \n", my_size);
+    EFF_finalize();
+    MPI_Finalize();
+  }
+
+  fapl_id = H5Pcreate (H5P_FILE_ACCESS);
+  H5Pset_fapl_iod(fapl_id, comm, info);
+
+  event_q = H5EQcreate(fapl_id);
+  assert(event_q);
+
+  file_id = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl_id);
+  
+  dimsf[0] = NX;
+  dimsf[1] = NY;
+
+  dataspace1 = H5Screate_simple(RANK, dimsf, NULL);
+  dataspace3 = H5Screate_simple(RANK, dimsf, NULL);
+  dataspace5 = H5Screate_simple(RANK, dimsf, NULL);
+  dataspace7 = H5Screate_simple(RANK, dimsf, NULL);
+ 
+  dset_id  = H5Dcreate (file_id, "D1", H5T_NATIVE_INT, dataspace1, 
+			H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+  assert(dset_id);
+  
+
+
+  count[0] = 8;
+  count[1] = 8;
+  offset[0] = 0;
+  offset[1] = 0;
+  H5Sselect_hyperslab(dataspace7, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+
+  data3 = (int *) malloc (sizeof(int)*count[0]*count[1]);
+  for (i = 0; i < count[0]*count[1]; i++){
+    data3[i] = 1024;
+  }
+  
+  dataspace8 = H5Screate_simple(RANK, count, NULL);
+
+
+  ret = H5Dwrite_ff(dset_id,
+		    H5T_NATIVE_INT,
+		    dataspace8,
+		    dataspace7,
+		    H5P_DEFAULT,
+		    data3,
+		    0,
+		    event_q);
+  assert(ret == 0);
+
+  /*Make sure the above write completes for testing 
+    partial read!*/
+  H5EQwait(event_q, &num_requests, &status);
+  
+  count[0] = 1;
+  count[1] = 8;
+  offset[0] = 0;
+  offset[1] = 0;
+
+  dataspace2 = H5Screate_simple(RANK, count, NULL);
+  	
+  H5Sselect_hyperslab(dataspace1, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+
+  data = (int *) malloc (sizeof(int)*count[0]*count[1]);
+  for (i = 0; i < count[0]*count[1]; i++){
+    data[i] = 10;
+  }
+  
+  ret = H5Dwrite_ff(dset_id,
+		    H5T_NATIVE_INT,
+		    dataspace2,
+		    dataspace1,
+		    H5P_DEFAULT,
+		    data,
+		    0,
+		    event_q);
+  assert(ret == 0);
+
+  count[0] = 8;
+  count[1] = 1;
+  offset[0] = 0;
+  offset[1] = 0;
+
+
+  dataspace4 = H5Screate_simple(RANK, count, NULL);
+
+  H5Sselect_hyperslab(dataspace3, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+
+
+
+  data2 = (int *) malloc(sizeof(int)*count[0]*count[1]);
+
+  ret = H5Dread_ff(dset_id, 
+		   H5T_NATIVE_INT,
+		   dataspace4, 
+		   dataspace3,
+		   H5P_DEFAULT,
+		   data2,
+		   0,
+		   event_q);
+  assert(ret == 0);
+
+  count[0] = 4;
+  count[1] = 4;
+  offset[0] = 2;
+  offset[1] = 0;
+
+
+  H5Sselect_hyperslab(dataspace5, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+
+  dataspace6 = H5Screate_simple(RANK, count, NULL);
+ 
+  data3 = (int *) malloc(sizeof(int)*count[0]*count[1]);
+  for (i = 0; i < count[0]*count[1]; i++){
+    data3[i] = 11;
+  }
+  
+  ret = H5Dwrite_ff(dset_id,
+		    H5T_NATIVE_INT,
+		    dataspace6,
+		    dataspace5,
+		    H5P_DEFAULT,
+		    data3,
+		    0,
+		    event_q);
+  assert(ret == 0);
+  
+
+
+  H5Dclose(dset_id);
+  H5Sclose(dataspace1); H5Sclose(dataspace2);
+  H5Sclose(dataspace3); H5Sclose(dataspace4);
+  H5Sclose(dataspace5); H5Sclose(dataspace6);
+  H5Sclose(dataspace7); H5Sclose(dataspace8);
+  H5Pclose(fapl_id);
+  H5Fclose(file_id);
+  H5EQwait(event_q, &num_requests, &status);
+  free(status);
+  H5EQclose (event_q);
+
+  for (i = 0; i < 8; i++){
+    fprintf (stderr,"data2[%d]: %d\n",
+	     i, data2[i]);
+  }
+
+  free(data);
+  free(data1);
+  free(data2);
+  free(data3);
+  fprintf(stderr, "\n*****************************************************************************************************************\n");
+  fprintf(stderr, "Finalize EFF stack\n");
+  fprintf(stderr, "*****************************************************************************************************************\n");
+  
+  EFF_finalize();
+  MPI_Finalize();
+  
+  return 0;
+}
diff --git a/testff/compactor_tests/native_write_basic.c b/testff/compactor_tests/native_write_basic.c
new file mode 100644
index 0000000..6cc1710
--- /dev/null
+++ b/testff/compactor_tests/native_write_basic.c
@@ -0,0 +1,127 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include "mpi.h"
+#include "hdf5.h"
+
+#define NX     16                      /* dataset dimensions */
+#define NY     8
+#define RANK   2
+
+/*Entire write gets replaced
+write buffer values start with 10's and increases and writes increase*/
+
+
+int main (int argc, char **argv){
+  
+  const char filename[] = "eff_file.h5";
+  hid_t file_id;
+  hid_t dataspaceID, dataspace2;
+  hid_t dset_id;
+  hid_t fapl_id, dxpl_id;
+  
+  const unsigned int nelem = 60;
+  int *data = NULL, *data1 = NULL;
+  unsigned int i = 0;
+  hsize_t dimsf[2];
+  hsize_t count[2], offset[2];
+  hsize_t s[2], b[2];
+  int my_rank, my_size, ret;
+  int provided;
+  hid_t event_q, int_id;
+  int num_requests = 0;  
+  H5_status_t *status = NULL;
+
+  MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);
+  if(MPI_THREAD_MULTIPLE != provided) {
+    fprintf(stderr, "MPI does not have MPI_THREAD_MULTIPLE support\n");
+    exit(1);
+  }
+
+
+  EFF_init (MPI_COMM_WORLD, MPI_INFO_NULL);
+
+  MPI_Comm_rank (MPI_COMM_WORLD, &my_rank);
+  MPI_Comm_size (MPI_COMM_WORLD, &my_size);
+
+
+  if (my_size > 1){
+    fprintf(stderr, "APP processes = %d cannot be greater than 1 \n", my_size);
+    MPI_Finalize();
+  }
+
+
+  fapl_id = H5Pcreate (H5P_FILE_ACCESS);
+  H5Pset_fapl_iod(fapl_id, MPI_COMM_WORLD, MPI_INFO_NULL);
+
+  event_q = H5EQcreate(fapl_id);
+  assert(event_q);
+
+  file_id =  H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl_id);
+
+  dimsf[0] = NX;
+  dimsf[1] = NY;
+
+
+  dataspaceID = H5Screate_simple(RANK, dimsf, NULL); 
+
+
+  
+  dset_id = H5Dcreate(file_id, "D1", H5T_NATIVE_INT,dataspaceID, 
+		      H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+
+  count[0] = 8;
+  count[1] = 8;
+  offset[0] = 0;
+  offset[1] = 0;
+
+  fprintf (stderr, "%d: count[0]:%lli, count[1]:%lli, offset[0]: %lli, offset[1]: %lli\n",
+	   my_rank,
+	   count[0], count[1], offset[0], offset[1]);
+
+  dataspace2 = H5Screate_simple(RANK, count, NULL);
+
+  H5Sselect_hyperslab(dataspaceID, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+  
+  data = (int *) malloc(sizeof(int)*count[0]*count[1]);
+  for (i=0; i < count[0]*count[1]; i++) {
+    data[i] = my_rank + 10;
+  }
+ 
+  ret = H5Dwrite_ff(dset_id, 
+		    H5T_NATIVE_INT,
+		    dataspace2, 
+		    dataspaceID,
+		    H5P_DEFAULT,
+		    data,
+		    0,
+		    event_q);
+  assert(ret == 0);
+  
+  H5Dclose(dset_id);
+  H5Sclose(dataspaceID);
+  H5Sclose(dataspace2);
+  H5Pclose(fapl_id);
+  H5Fclose(file_id);
+  H5EQwait(event_q, &num_requests, &status);
+  free(status);
+  H5EQclose (event_q);
+  free(data);
+  free(data1);
+
+  fprintf(stderr, "\n*****************************************************************************************************************\n");
+  fprintf(stderr, "Finalize EFF stack\n");
+  fprintf(stderr, "*****************************************************************************************************************\n");
+
+
+  EFF_finalize();
+  MPI_Finalize();
+  
+  return 0;
+}
diff --git a/testff/compactor_tests/native_write_test1.c b/testff/compactor_tests/native_write_test1.c
new file mode 100644
index 0000000..02c8554
--- /dev/null
+++ b/testff/compactor_tests/native_write_test1.c
@@ -0,0 +1,143 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include "mpi.h"
+#include "hdf5.h"
+
+#define NX     16                      /* dataset dimensions */
+#define NY     16
+#define RANK   2
+
+/*Entire write gets replaced
+write buffer values start with 10's and increases and writes increase*/
+
+
+int main (int argc, char **argv){
+  
+  const char filename[] = "eff_file.h5";
+  hid_t file_id;
+  hid_t dataspaceID, dataspace2;
+  hid_t dset_id;
+  hid_t fapl_id, dxpl_id;
+  
+  const unsigned int nelem = 60;
+  int *data = NULL, *data1 = NULL;
+  unsigned int i = 0;
+  hsize_t dimsf[2];
+  hsize_t count[2], offset[2];
+  hsize_t s[2], b[2];
+  int my_rank, my_size, ret;
+  int provided;
+  hid_t event_q, int_id;
+  int num_requests = 0;  
+  H5_status_t *status = NULL;
+
+  MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);
+  if(MPI_THREAD_MULTIPLE != provided) {
+    fprintf(stderr, "MPI does not have MPI_THREAD_MULTIPLE support\n");
+    exit(1);
+  }
+
+
+  EFF_init (MPI_COMM_WORLD, MPI_INFO_NULL);
+
+  MPI_Comm_rank (MPI_COMM_WORLD, &my_rank);
+  MPI_Comm_size (MPI_COMM_WORLD, &my_size);
+
+
+  if (my_size > 1){
+    fprintf(stderr, "APP processes = %d cannot be greater than 1 \n", my_size);
+    MPI_Finalize();
+  }
+
+
+  fapl_id = H5Pcreate (H5P_FILE_ACCESS);
+  H5Pset_fapl_iod(fapl_id, MPI_COMM_WORLD, MPI_INFO_NULL);
+
+  event_q = H5EQcreate(fapl_id);
+  assert(event_q);
+
+  file_id =  H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl_id);
+
+  dimsf[0] = NX;
+  dimsf[1] = NY;
+
+
+  dataspaceID = H5Screate_simple(RANK, dimsf, NULL); 
+
+
+  
+  dset_id = H5Dcreate(file_id, "D1", H5T_NATIVE_INT,dataspaceID, 
+		      H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+
+  count[0] = NX;
+  count[1] = NY;
+  offset[0] = 0;
+  offset[1] = 0;
+
+  fprintf (stderr, "%d: count[0]:%lli, count[1]:%lli, offset[0]: %lli, offset[1]: %lli\n",
+	   my_rank,
+	   count[0], count[1], offset[0], offset[1]);
+
+  dataspace2 = H5Screate_simple(RANK, count, NULL);
+
+  H5Sselect_hyperslab(dataspaceID, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+  
+  data = (int *) malloc(sizeof(int)*count[0]*count[1]);
+  for (i=0; i < count[0]*count[1]; i++) {
+    data[i] = my_rank + 10;
+  }
+ 
+  ret = H5Dwrite_ff(dset_id, 
+		    H5T_NATIVE_INT,
+		    dataspace2, 
+		    dataspaceID,
+		    H5P_DEFAULT,
+		    data,
+		    0,
+		    event_q);
+  assert(ret == 0);
+
+  data1 = (int *) malloc(sizeof(int)*count[0]*count[1]);
+  for (i=0; i < count[0]*count[1]; i++) {
+    data1[i] = my_rank + 11;
+  }
+  ret = H5Dwrite_ff(dset_id, 
+		    H5T_NATIVE_INT,
+		    dataspace2, 
+		    dataspaceID,
+		    H5P_DEFAULT,
+		    data1,
+		    0,
+		    event_q);
+  assert(ret == 0);
+ 
+
+  
+  H5Dclose(dset_id);
+  H5Sclose(dataspaceID);
+  H5Sclose(dataspace2);
+  H5Pclose(fapl_id);
+  H5Fclose(file_id);
+  H5EQwait(event_q, &num_requests, &status);
+  free(status);
+  H5EQclose (event_q);
+  free(data);
+  free(data1);
+
+  fprintf(stderr, "\n*****************************************************************************************************************\n");
+  fprintf(stderr, "Finalize EFF stack\n");
+  fprintf(stderr, "*****************************************************************************************************************\n");
+
+
+  EFF_finalize();
+  MPI_Finalize();
+  
+  return 0;
+}
diff --git a/testff/compactor_tests/native_write_test2.c b/testff/compactor_tests/native_write_test2.c
new file mode 100644
index 0000000..df5a100
--- /dev/null
+++ b/testff/compactor_tests/native_write_test2.c
@@ -0,0 +1,165 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include "mpi.h"
+#include "hdf5.h"
+
+#define NX     16                      /* dataset dimensions */
+#define NY     8
+#define RANK   2
+
+/*Entire write gets replaced
+write buffer values start with 10's and increases and writes increase*/
+
+
+int main (int argc, char **argv){
+  
+  const char filename[] = "eff_file.h5";
+  hid_t file_id;
+  hid_t dataspaceID, dataspace2;
+  hid_t dataspace3, dataspace4;
+  hid_t dset_id;
+  hid_t fapl_id, dxpl_id;
+  
+  const unsigned int nelem = 60;
+  int *data = NULL, *data1 = NULL;
+  unsigned int i = 0;
+  hsize_t dimsf[2];
+  hsize_t count[2], offset[2];
+  hsize_t s[2], b[2];
+  int my_rank, my_size, ret;
+  int provided;
+  hid_t event_q, int_id;
+  int num_requests = 0;  
+  H5_status_t *status = NULL;
+
+  MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);
+  if(MPI_THREAD_MULTIPLE != provided) {
+    fprintf(stderr, "MPI does not have MPI_THREAD_MULTIPLE support\n");
+    exit(1);
+  }
+
+
+  EFF_init (MPI_COMM_WORLD, MPI_INFO_NULL);
+
+  MPI_Comm_rank (MPI_COMM_WORLD, &my_rank);
+  MPI_Comm_size (MPI_COMM_WORLD, &my_size);
+
+
+  if (my_size > 1){
+    fprintf(stderr, "APP processes = %d cannot be greater than 1 \n", my_size);
+    MPI_Finalize();
+  }
+
+
+  fapl_id = H5Pcreate (H5P_FILE_ACCESS);
+  H5Pset_fapl_iod(fapl_id, MPI_COMM_WORLD, MPI_INFO_NULL);
+
+  event_q = H5EQcreate(fapl_id);
+  assert(event_q);
+
+  file_id =  H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl_id);
+
+  dimsf[0] = NX;
+  dimsf[1] = NY;
+
+
+  dataspaceID = H5Screate_simple(RANK, dimsf, NULL);
+  dataspace4 = H5Screate_simple(RANK, dimsf, NULL); 
+
+
+  
+  dset_id = H5Dcreate(file_id, "D1", H5T_NATIVE_INT,dataspaceID, 
+		      H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+
+  count[0] = 8;
+  count[1] = 8;
+  offset[0] = 0;
+  offset[1] = 0;
+
+  fprintf (stderr, "%d: count[0]:%lli, count[1]:%lli, offset[0]: %lli, offset[1]: %lli\n",
+	   my_rank,
+	   count[0], count[1], offset[0], offset[1]);
+
+  dataspace2 = H5Screate_simple(RANK, count, NULL);
+
+  H5Sselect_hyperslab(dataspaceID, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+  
+  data = (int *) malloc(sizeof(int)*count[0]*count[1]);
+  for (i=0; i < count[0]*count[1]; i++) {
+    data[i] = my_rank + 10;
+  }
+ 
+  ret = H5Dwrite_ff(dset_id, 
+		    H5T_NATIVE_INT,
+		    dataspace2, 
+		    dataspaceID,
+		    H5P_DEFAULT,
+		    data,
+		    0,
+		    event_q);
+  assert(ret == 0);
+
+  count[0] = 8;
+  count[1] = 8;
+  offset[0] = 4;
+  offset[1] = 0;
+
+  
+  fprintf (stderr, "%d: count[0]:%lli, count[1]:%lli, offset[0]: %lli, offset[1]: %lli\n",
+	   my_rank,
+	   count[0], count[1], offset[0], offset[1]);
+
+  dataspace3 = H5Screate_simple(RANK, count, NULL);
+  H5Sselect_hyperslab(dataspace4, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+
+  data1 = (int *) malloc(sizeof(int)*count[0]*count[1]);
+  for (i=0; i < count[0]*count[1]; i++) {
+    data1[i] = my_rank + 11;
+  }
+ 
+
+  ret = H5Dwrite_ff(dset_id, 
+		    H5T_NATIVE_INT,
+		    dataspace3, 
+		    dataspace4,
+		    H5P_DEFAULT,
+		    data1,
+		    0,
+		    event_q);
+  assert(ret == 0);
+
+  
+
+  H5Dclose(dset_id);
+  H5Sclose(dataspaceID);
+  H5Sclose(dataspace2);
+  H5Pclose(fapl_id);
+  H5Fclose(file_id);
+  H5EQwait(event_q, &num_requests, &status);
+  free(status);
+  H5EQclose (event_q);
+  free(data);
+  free(data1);
+
+  fprintf(stderr, "\n*****************************************************************************************************************\n");
+  fprintf(stderr, "Finalize EFF stack\n");
+  fprintf(stderr, "*****************************************************************************************************************\n");
+
+
+  EFF_finalize();
+  MPI_Finalize();
+  
+  return 0;
+}
diff --git a/testff/compactor_tests/native_write_test3.c b/testff/compactor_tests/native_write_test3.c
new file mode 100644
index 0000000..2dafe73
--- /dev/null
+++ b/testff/compactor_tests/native_write_test3.c
@@ -0,0 +1,253 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include "mpi.h"
+#include "hdf5.h"
+
+#define NX     256                      /* dataset dimensions */
+#define NY     256
+#define RANK   2
+
+
+
+int main (int argc, char **argv){
+  
+  const char filename[] = "eff_file.h5";
+  hid_t file_id;
+  hid_t dataspaceID, dataspace2;
+  hid_t dataspace3, dataspace4;
+  hid_t dataspace5, dataspace6;
+  hid_t dataspace7, dataspace8;
+  hid_t dset_id;
+  hid_t fapl_id, dxpl_id;
+  
+  const unsigned int nelem = 60;
+  int *data = NULL, *data1 = NULL;
+  int *data2 =  NULL, *data3 = NULL;
+  unsigned int i = 0;
+  hsize_t dimsf[2];
+  hsize_t count[2], offset[2];
+  hsize_t s[2], b[2];
+  int my_rank, my_size, ret;
+  int provided;
+  hid_t event_q, int_id;
+  int num_requests = 0;  
+  H5_status_t *status = NULL;
+
+  MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);
+  if(MPI_THREAD_MULTIPLE != provided) {
+    fprintf(stderr, "MPI does not have MPI_THREAD_MULTIPLE support\n");
+    exit(1);
+  }
+
+
+  EFF_init (MPI_COMM_WORLD, MPI_INFO_NULL);
+
+  MPI_Comm_rank (MPI_COMM_WORLD, &my_rank);
+  MPI_Comm_size (MPI_COMM_WORLD, &my_size);
+
+
+  if (my_size > 1){
+    fprintf(stderr, "APP processes = %d cannot be greater than 1 \n", my_size);
+    MPI_Finalize();
+  }
+
+
+  fapl_id = H5Pcreate (H5P_FILE_ACCESS);
+  H5Pset_fapl_iod(fapl_id, MPI_COMM_WORLD, MPI_INFO_NULL);
+
+  event_q = H5EQcreate(fapl_id);
+  assert(event_q);
+
+  file_id = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl_id);
+
+
+
+  dimsf[0] = NX;
+  dimsf[1] = NY;
+
+
+  dataspaceID = H5Screate_simple(RANK, dimsf, NULL); 
+  dataspace4 = H5Screate_simple(RANK, dimsf, NULL); 
+  dataspace5 = H5Screate_simple(RANK, dimsf, NULL); 
+  dataspace7 = H5Screate_simple(RANK, dimsf, NULL); 
+
+  dset_id = H5Dcreate(file_id, "D1", H5T_NATIVE_INT,dataspaceID, 
+		      H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+  count[0] = 256;
+  count[1] = 256;
+  offset[0] = 0;
+  offset[1] = 0;
+
+  fprintf (stderr, "%d: count[0]:%lli, count[1]:%lli, offset[0]: %lli, offset[1]: %lli\n",
+	   my_rank,
+	   count[0], count[1], offset[0], offset[1]);
+
+  dataspace2 = H5Screate_simple(RANK, count, NULL);
+
+  H5Sselect_hyperslab(dataspaceID, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+  
+  data = (int *) malloc(sizeof(int)*count[0]*count[1]);
+  for (i=0; i < count[0]*count[1]; i++) {
+    data[i] = my_rank + 10;
+  }
+ 
+  ret = H5Dwrite_ff(dset_id, 
+		    H5T_NATIVE_INT,
+		    dataspace2, 
+		    dataspaceID,
+		    H5P_DEFAULT,
+		    data,
+		    0,
+		    event_q);
+  assert(ret == 0);
+  
+  count[0] = 8;
+  count[1] = 8;
+  offset[0] = 6;
+  offset[1] = 0;
+
+
+  fprintf (stderr, "%d: count[0]:%lli, count[1]:%lli, offset[0]: %lli, offset[1]: %lli\n",
+	   my_rank,
+	   count[0], count[1], offset[0], offset[1]);
+
+  dataspace3 = H5Screate_simple(RANK, count, NULL);
+
+
+  H5Sselect_hyperslab(dataspace4, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+
+
+  data1 = (int *) malloc(sizeof(int)*count[0]*count[1]);
+  for (i=0; i < count[0]*count[1]; i++) {
+    data1[i] = my_rank + 12;
+  }
+
+
+  ret = H5Dwrite_ff(dset_id, 
+		    H5T_NATIVE_INT,
+		    dataspace3, 
+		    dataspace4,
+		    H5P_DEFAULT,
+		    data1,
+		    0,
+		    event_q);
+  assert(ret == 0);
+
+
+  count[0] = 8;
+  count[1] = 8;
+  offset[0] = 3;
+  offset[1] = 0;
+
+
+  data2 = (int *) malloc(sizeof(int)*count[0]*count[1]);
+  for (i=0; i < count[0]*count[1]; i++) {
+    data2[i] = my_rank + 13;
+  }
+
+
+  
+  fprintf (stderr, "%d: count[0]:%lli, count[1]:%lli, offset[0]: %lli, offset[1]: %lli\n",
+	   my_rank,
+	   count[0], count[1], offset[0], offset[1]);
+  
+  dataspace6 = H5Screate_simple(RANK, count, NULL);
+
+  H5Sselect_hyperslab(dataspace5, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+  
+  
+
+  ret = H5Dwrite_ff(dset_id, 
+		    H5T_NATIVE_INT,
+		    dataspace6, 
+		    dataspace5,
+		    H5P_DEFAULT,
+		    data2,
+		    0,
+		    event_q);
+  assert(ret == 0);
+
+
+  count[0] = 8;
+  count[1] = 5;
+  offset[0] = 0;
+  offset[1] = 3;
+
+
+  data3 = (int *) malloc(sizeof(int)*count[0]*count[1]);
+  for (i=0; i < count[0]*count[1]; i++) {
+    data3[i] = my_rank + 14;
+  }
+
+
+  
+  fprintf (stderr, "%d: count[0]:%lli, count[1]:%lli, offset[0]: %lli, offset[1]: %lli\n",
+	   my_rank,
+	   count[0], count[1], offset[0], offset[1]);
+  
+  dataspace8 = H5Screate_simple(RANK, count, NULL);
+
+  H5Sselect_hyperslab(dataspace7, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+  
+  
+
+  ret = H5Dwrite_ff(dset_id, 
+		    H5T_NATIVE_INT,
+		    dataspace8, 
+		    dataspace7,
+		    H5P_DEFAULT,
+		    data3,
+		    0,
+		    event_q);
+  assert(ret == 0);
+
+
+  
+  
+  H5Dclose(dset_id);
+  H5Sclose(dataspaceID);
+  H5Sclose(dataspace2);
+  H5Sclose(dataspace3);
+  H5Sclose(dataspace4);
+  H5Sclose(dataspace5);
+  H5Sclose(dataspace6);
+  H5Pclose(fapl_id);
+  H5Fclose(file_id);
+  H5EQwait(event_q, &num_requests, &status);
+  free(status);
+  H5EQclose (event_q);
+
+  free(data);
+  free(data1);
+  free(data2);
+  free(data3);
+  fprintf(stderr, "\n*****************************************************************************************************************\n");
+  fprintf(stderr, "Finalize EFF stack\n");
+  fprintf(stderr, "*****************************************************************************************************************\n");
+  EFF_finalize();
+  MPI_Finalize();
+  
+  return 0;
+}
diff --git a/testff/compactor_tests/parallel_write.c b/testff/compactor_tests/parallel_write.c
new file mode 100644
index 0000000..e996388
--- /dev/null
+++ b/testff/compactor_tests/parallel_write.c
@@ -0,0 +1,126 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include "mpi.h"
+#include "hdf5.h"
+
+#define NX     8                      /* dataset dimensions */
+#define NY     8 
+#define RANK   2
+
+
+
+int main (int argc, char **argv){
+  
+  const char filename[] = "eff_file.h5";
+  hid_t file_id;
+  hid_t dataspaceID, dataspace2;
+  hid_t dset_id;
+  hid_t fapl_id, dxpl_id;
+  
+  const unsigned int nelem = 60;
+  int *data = NULL;
+  unsigned int i = 0;
+  hsize_t dimsf[2];
+  hsize_t count[2], offset[2];
+
+  int my_rank, my_size, ret;
+  int provided;
+  hid_t event_q, int_id;
+  
+  int num_requests = 0;  
+  H5_status_t *status = NULL;
+
+  MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);
+  if(MPI_THREAD_MULTIPLE != provided) {
+    fprintf(stderr, "MPI does not have MPI_THREAD_MULTIPLE support\n");
+    exit(1);
+  }
+
+  EFF_init (MPI_COMM_WORLD, MPI_INFO_NULL);
+
+  MPI_Comm_rank (MPI_COMM_WORLD, &my_rank);
+  MPI_Comm_size (MPI_COMM_WORLD, &my_size);
+
+  fprintf(stderr, "APP processes = %d, my rank is %d\n", my_size, my_rank);
+
+  fapl_id = H5Pcreate (H5P_FILE_ACCESS);
+  H5Pset_fapl_iod(fapl_id, MPI_COMM_WORLD, MPI_INFO_NULL);
+
+  event_q = H5EQcreate(fapl_id);
+  assert(event_q);
+
+  file_id = H5Fcreate_ff(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl_id, event_q);
+  assert(file_id);
+
+
+  dimsf[0] = NX;
+  dimsf[1] = NY;
+
+  /*  int_id = H5Tcopy(H5T_STD_I32LE);
+  ret = H5Tcommit_ff(file_id, "int", int_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT, 
+		     0, event_q);
+    
+		     assert(ret == 0);*/
+
+  dataspaceID = H5Screate_simple(RANK, dimsf, NULL); 
+
+  dset_id = H5Dcreate_ff(file_id, "D1" , H5T_NATIVE_INT, dataspaceID,
+			 H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT, 0, event_q);
+  assert(dset_id);
+
+
+
+  count[0] = NY/my_size;
+  count[1] = 8;
+  offset[0] = my_rank * count[0];
+  offset[1] = 0;
+
+  dataspace2 = H5Screate_simple(RANK, count, NULL);
+  
+
+  H5Sselect_hyperslab(dataspaceID, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+
+  
+  data = (int *) malloc(sizeof(int)*count[0]*count[1]);
+  for (i=0; i < count[0]*count[1]; i++) {
+    data[i] = my_rank + 10;
+  }
+  
+ 
+  ret = H5Dwrite_ff(dset_id, 
+		    H5T_NATIVE_INT,
+		    dataspace2, 
+		    dataspaceID,
+		    H5P_DEFAULT,
+		    data,
+		    0,
+		    event_q);
+  assert(ret == 0);
+  
+
+
+  assert(H5Dclose_ff(dset_id, event_q) == 0);
+  H5Sclose(dataspaceID);
+  H5Sclose(dataspace2);
+  H5Pclose(fapl_id);
+  assert(H5Fclose_ff(file_id, event_q) == 0);
+  H5EQwait(event_q, &num_requests, &status);
+  free(status);
+  H5EQclose (event_q);
+
+  free(data);
+  fprintf(stderr, "\n*****************************************************************************************************************\n");
+  fprintf(stderr, "Finalize EFF stack\n");
+  fprintf(stderr, "*****************************************************************************************************************\n");
+  EFF_finalize();
+  MPI_Finalize();
+  
+  return 0;
+}
diff --git a/testff/compactor_tests/read_test_1.c b/testff/compactor_tests/read_test_1.c
new file mode 100644
index 0000000..0ef3edc
--- /dev/null
+++ b/testff/compactor_tests/read_test_1.c
@@ -0,0 +1,139 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include "mpi.h"
+#include "hdf5.h"
+
+#define NX     16                   
+#define NY     8
+#define RANK   2
+
+
+
+int main (int argc, char **argv){
+
+  const char filename[] = "eff_file.h5";
+  hid_t file_id;
+  hid_t dataspace1, dataspace2;
+  hid_t dset_id;
+  hid_t fapl_id, dxpl_id;
+  
+  const unsigned int nelem = 60;
+  int *data = NULL, *data1 = NULL;
+  unsigned int i = 0;
+  hsize_t dimsf[2];
+  hsize_t count[2], offset[2];
+  int my_rank, my_size, ret;
+  int provided;
+  hid_t event_q, int_id;
+  int num_requests = 0;
+  H5_status_t *status = NULL;
+  MPI_Comm comm;
+  MPI_Info info;
+
+  
+  MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);
+  if(MPI_THREAD_MULTIPLE != provided) {
+    fprintf(stderr, "MPI does not have MPI_THREAD_MULTIPLE support\n");
+    exit(1);
+  }
+
+  comm = MPI_COMM_WORLD;
+  info = MPI_INFO_NULL;
+  
+  EFF_init (comm, info);
+  MPI_Comm_rank (comm, &my_rank);
+  MPI_Comm_size (comm, &my_size);
+
+  if (my_size > 1){
+    fprintf(stderr, "APP processes = %d cannot be greater than 1 \n", my_size);
+    EFF_finalize();
+    MPI_Finalize();
+  }
+
+  fapl_id = H5Pcreate (H5P_FILE_ACCESS);
+  H5Pset_fapl_iod(fapl_id, comm, info);
+
+  event_q = H5EQcreate(fapl_id);
+  assert(event_q);
+
+  file_id = H5Fcreate_ff(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl_id, event_q);
+  assert(file_id);
+  
+  dimsf[0] = NX;
+  dimsf[1] = NY;
+
+  dataspace1 = H5Screate_simple(RANK, dimsf, NULL);
+  
+  
+  dset_id  = H5Dcreate_ff (file_id, "D1", H5T_NATIVE_INT, dataspace1, 
+			   H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT, 0, event_q);
+  assert(dset_id);
+  
+  count[0] = 8;
+  count[1] = 8;
+  offset[0] = 0;
+  offset[1] = 0;
+
+  dataspace2 = H5Screate_simple(RANK, count, NULL);
+  
+  H5Sselect_hyperslab(dataspace1, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+  data = (int *) malloc (sizeof(int)*count[0]*count[1]);
+
+  for (i = 0; i < count[0]*count[1]; i++){
+    data[i] = 10;
+  }
+  ret = H5Dwrite_ff(dset_id,
+		    H5T_NATIVE_INT,
+		    dataspace2,
+		    dataspace1,
+		    H5P_DEFAULT,
+		    data,
+		    0,
+		    event_q);
+  assert(ret == 0);
+
+  data1 = (int *) malloc(sizeof(int)*count[0]*count[1]);
+  ret = H5Dread_ff(dset_id, 
+		   H5T_NATIVE_INT,
+		   dataspace2, 
+		   dataspace1,
+		   H5P_DEFAULT,
+		   data1,
+		   0,
+		   event_q);
+  assert(ret == 0);
+
+
+
+  assert(H5Dclose_ff(dset_id, event_q) == 0);
+  H5Sclose(dataspace1);
+  H5Sclose(dataspace2);
+  H5Pclose(fapl_id);
+  assert(H5Fclose_ff(file_id, event_q)== 0);
+  H5EQwait(event_q, &num_requests, &status);
+  free(status);
+  H5EQclose (event_q);
+
+  for (i = 0; i < (count[0] * count[1]); i++){
+    fprintf (stderr,"data1[%d]: %d\n",
+	     i, data1[i]);
+  }
+
+  free(data);
+  
+  fprintf(stderr, "\n*****************************************************************************************************************\n");
+  fprintf(stderr, "Finalize EFF stack\n");
+  fprintf(stderr, "*****************************************************************************************************************\n");
+  
+  EFF_finalize();
+  MPI_Finalize();
+  
+  return 0;
+}
diff --git a/testff/compactor_tests/read_test_2.c b/testff/compactor_tests/read_test_2.c
new file mode 100644
index 0000000..4c0f75c
--- /dev/null
+++ b/testff/compactor_tests/read_test_2.c
@@ -0,0 +1,164 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include "mpi.h"
+#include "hdf5.h"
+
+#define NX     16                   
+#define NY     8
+#define RANK   2
+
+
+
+int main (int argc, char **argv){
+
+  const char filename[] = "eff_file.h5";
+  hid_t file_id;
+  hid_t dataspace1, dataspace2;
+  hid_t dataspace3, dataspace4;
+  hid_t dset_id;
+  hid_t fapl_id, dxpl_id;
+  
+  const unsigned int nelem = 60;
+  int *data = NULL, *data1 = NULL;
+  int *data2 = NULL, *data3 = NULL;
+  unsigned int i = 0;
+  hsize_t dimsf[2];
+  hsize_t count[2], offset[2];
+  int my_rank, my_size, ret;
+  int provided;
+  hid_t event_q, int_id;
+  int num_requests = 0;
+  H5_status_t *status = NULL;
+  MPI_Comm comm;
+  MPI_Info info;
+
+  
+  MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);
+  if(MPI_THREAD_MULTIPLE != provided) {
+    fprintf(stderr, "MPI does not have MPI_THREAD_MULTIPLE support\n");
+    exit(1);
+  }
+
+  comm = MPI_COMM_WORLD;
+  info = MPI_INFO_NULL;
+  
+  EFF_init (comm, info);
+  MPI_Comm_rank (comm, &my_rank);
+  MPI_Comm_size (comm, &my_size);
+
+  if (my_size > 1){
+    fprintf(stderr, "APP processes = %d cannot be greater than 1 \n", my_size);
+    EFF_finalize();
+    MPI_Finalize();
+  }
+
+  fapl_id = H5Pcreate (H5P_FILE_ACCESS);
+  H5Pset_fapl_iod(fapl_id, comm, info);
+
+  event_q = H5EQcreate(fapl_id);
+  assert(event_q);
+
+  file_id = H5Fcreate_ff(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl_id, event_q);
+  assert(file_id);
+  
+  dimsf[0] = NX;
+  dimsf[1] = NY;
+
+  dataspace1 = H5Screate_simple(RANK, dimsf, NULL);
+  dataspace3 = H5Screate_simple(RANK, dimsf, NULL);
+
+  dset_id  = H5Dcreate_ff (file_id, "D1", H5T_NATIVE_INT, dataspace1, 
+			   H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT, 0, event_q);
+  assert(dset_id);
+  
+  count[0] = 4;
+  count[1] = 8;
+  offset[0] = 0;
+  offset[1] = 0;
+
+  dataspace2 = H5Screate_simple(RANK, count, NULL);
+  	
+  H5Sselect_hyperslab(dataspace1, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+
+  data = (int *) malloc (sizeof(int)*count[0]*count[1]);
+
+  for (i = 0; i < count[0]*count[1]; i++){
+    data[i] = 10;
+  }
+  
+  ret = H5Dwrite_ff(dset_id,
+		    H5T_NATIVE_INT,
+		    dataspace2,
+		    dataspace1,
+		    H5P_DEFAULT,
+		    data,
+		    0,
+		    event_q);
+  assert(ret == 0);
+
+  count[0] = 8;
+  count[1] = 1;
+  offset[0] = 0;
+  offset[1] = 0;
+
+
+  dataspace4 = H5Screate_simple(RANK, count, NULL);
+
+  H5Sselect_hyperslab(dataspace3, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+
+
+
+  data2 = (int *) malloc(sizeof(int)*count[0]*count[1]);
+
+  ret = H5Dread_ff(dset_id, 
+		   H5T_NATIVE_INT,
+		   dataspace4, 
+		   dataspace3,
+		   H5P_DEFAULT,
+		   data2,
+		   0,
+		   event_q);
+  assert(ret == 0);
+
+
+
+
+  assert(H5Dclose_ff(dset_id, event_q) == 0);
+  H5Sclose(dataspace1); H5Sclose(dataspace2);
+  H5Sclose(dataspace3); H5Sclose(dataspace4);
+  H5Pclose(fapl_id);
+  assert(H5Fclose_ff(file_id, event_q)== 0);
+  H5EQwait(event_q, &num_requests, &status);
+  free(status);
+  H5EQclose (event_q);
+
+  for (i = 0; i < (count[0] * count[1]); i++){
+    fprintf (stderr,"data2[%d]: %d\n",
+	     i, data2[i]);
+  }
+
+  free(data);
+  free(data1);
+  free(data2);
+  free(data3);
+  fprintf(stderr, "\n*****************************************************************************************************************\n");
+  fprintf(stderr, "Finalize EFF stack\n");
+  fprintf(stderr, "*****************************************************************************************************************\n");
+  
+  EFF_finalize();
+  MPI_Finalize();
+  
+  return 0;
+}
diff --git a/testff/compactor_tests/read_test_3.c b/testff/compactor_tests/read_test_3.c
new file mode 100644
index 0000000..220bff6
--- /dev/null
+++ b/testff/compactor_tests/read_test_3.c
@@ -0,0 +1,197 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include "mpi.h"
+#include "hdf5.h"
+
+#define NX     16                   
+#define NY     8
+#define RANK   2
+
+
+
+int main (int argc, char **argv){
+
+  const char filename[] = "eff_file.h5";
+  hid_t file_id;
+  hid_t dataspace1, dataspace2;
+  hid_t dataspace3, dataspace4;
+  hid_t dataspace5, dataspace6;
+  
+  hid_t dset_id;
+  hid_t fapl_id, dxpl_id;
+  
+  const unsigned int nelem = 60;
+  int *data = NULL, *data1 = NULL;
+  int *data2 = NULL, *data3 = NULL;
+  unsigned int i = 0;
+  hsize_t dimsf[2];
+  hsize_t count[2], offset[2];
+  int my_rank, my_size, ret;
+  int provided;
+  hid_t event_q, int_id;
+  int num_requests = 0;
+  H5_status_t *status = NULL;
+  MPI_Comm comm;
+  MPI_Info info;
+
+  
+  MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);
+  if(MPI_THREAD_MULTIPLE != provided) {
+    fprintf(stderr, "MPI does not have MPI_THREAD_MULTIPLE support\n");
+    exit(1);
+  }
+
+  comm = MPI_COMM_WORLD;
+  info = MPI_INFO_NULL;
+  
+  EFF_init (comm, info);
+  MPI_Comm_rank (comm, &my_rank);
+  MPI_Comm_size (comm, &my_size);
+
+  if (my_size > 1){
+    fprintf(stderr, "APP processes = %d cannot be greater than 1 \n", my_size);
+    EFF_finalize();
+    MPI_Finalize();
+  }
+
+  fapl_id = H5Pcreate (H5P_FILE_ACCESS);
+  H5Pset_fapl_iod(fapl_id, comm, info);
+
+  event_q = H5EQcreate(fapl_id);
+  assert(event_q);
+
+  file_id = H5Fcreate_ff(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl_id, event_q);
+  assert(file_id);
+  
+  dimsf[0] = NX;
+  dimsf[1] = NY;
+
+  dataspace1 = H5Screate_simple(RANK, dimsf, NULL);
+  dataspace3 = H5Screate_simple(RANK, dimsf, NULL);
+  dataspace5 = H5Screate_simple(RANK, dimsf, NULL);
+
+  dset_id  = H5Dcreate_ff (file_id, "D1", H5T_NATIVE_INT, dataspace1, 
+			   H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT, 0, event_q);
+  assert(dset_id);
+  
+  count[0] = 1;
+  count[1] = 8;
+  offset[0] = 0;
+  offset[1] = 0;
+
+  dataspace2 = H5Screate_simple(RANK, count, NULL);
+  	
+  H5Sselect_hyperslab(dataspace1, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+
+  data = (int *) malloc (sizeof(int)*count[0]*count[1]);
+
+  for (i = 0; i < count[0]*count[1]; i++){
+    data[i] = 10;
+  }
+  
+  ret = H5Dwrite_ff(dset_id,
+		    H5T_NATIVE_INT,
+		    dataspace2,
+		    dataspace1,
+		    H5P_DEFAULT,
+		    data,
+		    0,
+		    event_q);
+  assert(ret == 0);
+
+  count[0] = 8;
+  count[1] = 1;
+  offset[0] = 0;
+  offset[1] = 0;
+
+
+  dataspace4 = H5Screate_simple(RANK, count, NULL);
+
+  H5Sselect_hyperslab(dataspace3, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+
+
+
+  data2 = (int *) malloc(sizeof(int)*count[0]*count[1]);
+
+  ret = H5Dread_ff(dset_id, 
+		   H5T_NATIVE_INT,
+		   dataspace4, 
+		   dataspace3,
+		   H5P_DEFAULT,
+		   data2,
+		   0,
+		   event_q);
+  assert(ret == 0);
+
+  count[0] = 4;
+  count[1] = 4;
+  offset[0] = 2;
+  offset[1] = 0;
+
+
+  H5Sselect_hyperslab(dataspace5, 
+		      H5S_SELECT_SET,
+		      offset,
+		      NULL,
+		      count,
+		      NULL);
+
+  dataspace6 = H5Screate_simple(RANK, count, NULL);
+ 
+  data3 = (int *) malloc(sizeof(int)*count[0]*count[1]);
+  for (i = 0; i < count[0]*count[1]; i++){
+    data3[i] = 11;
+  }
+  
+  ret = H5Dwrite_ff(dset_id,
+		    H5T_NATIVE_INT,
+		    dataspace6,
+		    dataspace5,
+		    H5P_DEFAULT,
+		    data3,
+		    0,
+		    event_q);
+  assert(ret == 0);
+  
+
+
+  assert(H5Dclose_ff(dset_id, event_q) == 0);
+  H5Sclose(dataspace1); H5Sclose(dataspace2);
+  H5Sclose(dataspace3); H5Sclose(dataspace4);
+  H5Sclose(dataspace5); H5Sclose(dataspace6);
+  H5Pclose(fapl_id);
+  assert(H5Fclose_ff(file_id, event_q)== 0);
+  H5EQwait(event_q, &num_requests, &status);
+  free(status);
+  H5EQclose (event_q);
+
+  for (i = 0; i < 8; i++){
+    fprintf (stderr,"data2[%d]: %d\n",
+	     i, data2[i]);
+  }
+
+  free(data);
+  free(data1);
+  free(data2);
+  free(data3);
+  fprintf(stderr, "\n*****************************************************************************************************************\n");
+  fprintf(stderr, "Finalize EFF stack\n");
+  fprintf(stderr, "*****************************************************************************************************************\n");
+  
+  EFF_finalize();
+  MPI_Finalize();
+  
+  return 0;
+}
diff --git a/testff/compactor_tests/test_server.c b/testff/compactor_tests/test_server.c
new file mode 100644
index 0000000..ee28de4
--- /dev/null
+++ b/testff/compactor_tests/test_server.c
@@ -0,0 +1,50 @@
+/* 

+ * test_server.c: Server side of Milestone 3.3 Asynchronous I/O and initial

+ * IOD VOL plugin demonstration.

+ */

+

+#include <stdio.h>

+#include <stdlib.h>

+#include <assert.h>

+#include <string.h>

+#include "mpi.h"

+#include "hdf5.h"

+

+int main(int argc, char **argv) {

+    int my_size, my_rank;

+    int provided;

+

+    MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);

+    if(MPI_THREAD_MULTIPLE != provided) {

+        printf("MPI does not have MPI_THREAD_MULTIPLE support\n");

+        exit(1);

+    }

+

+    MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);

+    MPI_Comm_size(MPI_COMM_WORLD, &my_size);

+    printf("Number of server processes = %d, my rank is %d\n", my_size, my_rank);

+

+    H5open();

+    /* This call initiliazes the FS for the server processes (create metadata and

+       bulk data handles). It also registers with the Function shipper the 

+       HDF5 VOL server routines that will be executed when the clients ship the VOL 

+       routines. Then it executes a loop to receive requests from clients that map 

+       to one of the registered callbacks. 

+

+       Whenever a request is received, the corresponding callback is called which 

+       inserts the operation into the AXE (the Asynchronous eXecution Engine) and 

+       returns to receive another request. The AXE schedules that operation to 

+       execute by assigning a thread to it. After the operation is complete, the 

+       result is returned to the client through the function shipper complete call.

+

+       Finally, when all clients send a terminate call, the function shipper interface

+       is finalized the operation returns. */

+    H5VLiod_start_handler(MPI_COMM_WORLD, MPI_INFO_NULL);

+    H5close();

+    fflush(stderr);

+    MPI_Finalize();

+    fflush(stderr);

+

+    return 0;

+}

+