From 5a20b1b6918722bc54677ccf1c52e4b75a4a3c6e Mon Sep 17 00:00:00 2001
From: Mohamad Chaarawi <chaarawi@hdfgroup.org>
Date: Mon, 10 Jun 2013 10:03:20 -0500
Subject: [svn-r23743] add support for simple datatype conversion at the server

---
 examples/test_client.c | 194 ++++++++++++++++++++++------------
 src/H5VLiod.c          |  16 ++-
 src/H5VLiod_client.c   |   2 +-
 src/H5VLiod_common.h   |   1 +
 src/H5VLiod_server.c   | 277 +++++++++++++++++++++++++++++++++++++++++++++++--
 5 files changed, 407 insertions(+), 83 deletions(-)

diff --git a/examples/test_client.c b/examples/test_client.c
index 4a28730..9d018b3 100644
--- a/examples/test_client.c
+++ b/examples/test_client.c
@@ -20,7 +20,9 @@ int main(int argc, char **argv) {
     hid_t aid1, aid2, aid3;
     hid_t fapl_id, dxpl_id;
     const unsigned int nelem=60;
-    int *data = NULL, *r_data = NULL, *r2_data = NULL, *data2 = NULL, *data3 = NULL;
+    int *data = NULL, *r_data = NULL, *r2_data = NULL, *data2 = NULL;
+    int16_t *data3 = NULL;
+    int16_t *r3_data = NULL;
     int *a_data = NULL, *ra_data = NULL;
     unsigned int i = 0;
     hsize_t dims[1];
@@ -58,32 +60,41 @@ int main(int argc, char **argv) {
     fapl_id = H5Pcreate (H5P_FILE_ACCESS);
     H5Pset_fapl_iod(fapl_id, MPI_COMM_WORLD, MPI_INFO_NULL);
 
-    /* allocate and initialize 3 arrays for dataset writes, and 2 arrays 
-       for dataset reads. 
+    /* allocate and initialize arrays for dataset & attribute writes and reads. 
        The write arrays are intialized to contain 60 integers (0-59). 
        The read arrays are intialized to contain 60 integers all 0s. */
     data = malloc (sizeof(int)*nelem);
     data2 = malloc (sizeof(int)*nelem);
-    data3 = malloc (sizeof(int)*nelem);
+    data3 = malloc (sizeof(int16_t)*nelem);
     a_data = malloc (sizeof(int)*nelem);
     ra_data = malloc (sizeof(int)*nelem);
     r_data = malloc (sizeof(int)*nelem);
     r2_data = malloc (sizeof(int)*nelem);
+    r3_data = malloc (sizeof(int16_t)*nelem);
     for(i=0;i<nelem;++i) {
         r_data[i] = 0;
         ra_data[i] = 0;
         r2_data[i] = 0;
+        r3_data[i] = 0;
         data[i]=i;
         data2[i]=i;
         data3[i]=i;
         a_data[i]=i;
     }
 
-    /* create an event Queue for managing asynchronous requests */
+    /* create an event Queue for managing asynchronous requests.
+
+       Event Queues will releive the use from managing and completing
+       individual requests for every operation. Instead of passing a
+       request for every operation, the event queue is passed and
+       internally the HDF5 library creates a request and adds it to
+       the event queue.
+
+       Multiple Event queue can be created used by the application. */
     event_q = H5EQcreate(fapl_id);
     assert(event_q);
 
-    /* create the file. This is asynchronous. */
+    /* create the file. This is asynchronous, but the file_id can be used. */
     file_id = H5Fcreate_ff(file_name, H5F_ACC_TRUNC, H5P_DEFAULT, fapl_id, event_q);
 
     {
@@ -92,11 +103,12 @@ int main(int argc, char **argv) {
         fprintf(stderr, "File name %s   %s\n", temp_name, file_name);
     }
 
-    /* create a group G1 on the file. We creat it here synchronously just to
-       show that we can intermix the original HDF5 API with the new 
-       Async API.
-       Internally there is a built in wait on the file_id, which has already been
-       completed when we called H5AOwait on the file create request earlier*/
+    /* create 3 groups in the file. All calls are completely
+       asychronous. Even though they depend one each other here and
+       they also depend on the file, they will be shipped immdeiately
+       and asynchronously to the server and return to the user. At the
+       server, dependencies are noted in the AXE and functions execute
+       in the order they are supposed to execute. */
     gid1 = H5Gcreate_ff(file_id, "G1", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT, 0, event_q);
     H5Oset_comment_ff(gid1, "Testing Object Comment", 0, event_q);
     gid2 = H5Gcreate_ff(file_id, "G1/G2", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT, 0, event_q);
@@ -106,11 +118,14 @@ int main(int argc, char **argv) {
     assert(gid2);
     assert(gid3);
 
-    /* Create a datatype and commit it to the file. This is asynchronous. 
+    /* create a 32 bit integer LE datatype. This is a local operation
+       that does not touch the file */
+    int_id = H5Tcopy(H5T_STD_I32LE);
+
+    /* Commit the datatype to the file. This is asynchronous & immediate. 
      * Other Local H5T type operations can be issued before completing this call
      * because they do not depend on the committed state of the datatype.
      */
-    int_id = H5Tcopy(H5T_NATIVE_INT);
     H5Tcommit_ff(file_id, "int", int_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT, 
                  0, event_q);
 
@@ -119,18 +134,31 @@ int main(int argc, char **argv) {
     dims [0] = 60;
     dataspaceId = H5Screate_simple(1, dims, NULL);
 
-    /* create an attribute on group G1 */
+    /* create an attribute on group G1. This is asynchronous and
+       returns immediately, however at the server it won't start until
+       the group G1 creation op is completed */
     aid1 = H5Acreate_ff(gid1, "ATTR1", H5T_NATIVE_INT, dataspaceId, 
                         H5P_DEFAULT, H5P_DEFAULT, 0, event_q);
     assert(aid1);
 
-    /* close the attribute */
+    /* close the attribute right after the create. This is
+       asynchronous. The attribute id can not be used anymore, however
+       the creation operation will occur first at the server before
+       the close */
     H5Aclose_ff(aid1, event_q);
 
-    /* Check if the attribute on group G1 exists */
+    /* Check if the attribute on group G1 exists. This is
+       asynchronous, so the exists status is correct to examine after
+       the completion of the operation */
     assert(H5Aexists_by_name_ff(file_id,"G1","ATTR1", H5P_DEFAULT, &exists, 0, event_q) == 0);
+
+    /* Pop the request for the last operation from the event
+       queue. The Event queue does not manage it anymore and it is the
+       application's responsibilty to wait/test and ensure
+       completion */
     if(H5EQpop(event_q, &req1) < 0)
         exit(1);
+    /* wait synchronously on the operation */
     assert(H5AOwait(req1, &status1) == 0);
     assert (status1);
 
@@ -139,67 +167,65 @@ int main(int argc, char **argv) {
     else
         printf("Attribute ATTR1 does NOT exist. This must be the test without a native backend\n");
 
-    /* Delete the attribute just created */
+    /* Delete the attribute just created, this is asynchronous */
     assert(H5Adelete_by_name_ff(file_id, "G1", "ATTR1", H5P_DEFAULT, 0, event_q) == 0);
 
-    /* check if it exists now */
+    /* check if it exists now. This is asynchronous. Can't check the
+       exists status until the operation completes. */
     assert(0 == H5Aexists_ff(gid1, "ATTR1", &exists, 0, event_q));
 
-    /* create a Dataset D1 on the file, in group /G1/G2/G3. This is asynchronous. 
-       Internally to the IOD-VOL this call traverses the path G1/G2/G3. 
-       It realizes that group G1 has been created locally, but has no info about 
-       G2 and G3.
-       This enforces a wait for the previous H5Gcreate on G1 to complete 
-       at the client (which has already completed because the gcreate was done 
-       synchronously), then forwards the call asynchronously to the server, 
-       with the path G2/G3/D1 */
+    /* create a Dataset D1 on the file, in group /G1/G2/G3. This is
+       asynchronous.  Internally to the IOD-VOL this call traverses
+       the path G1/G2/G3.  it forwards the call asynchronously to the
+       server, with a dependency on Group G3 creation operation */
     did1 = H5Dcreate_ff(file_id,"G1/G2/G3/D1",int_id,dataspaceId,
                         H5P_DEFAULT,H5P_DEFAULT,H5P_DEFAULT, 0, event_q);
     assert(did1);
 
-    /* create an attribute on dataset D1. This is asynchronous, but waits internall for D1 to be created */
+    /* create an attribute on dataset D1. This is asynchronous, but
+       executes at the server after D1 is created */
     aid2 = H5Acreate_by_name_ff(file_id, "G1/G2/G3/D1", "ATTR2_tmp", H5T_NATIVE_INT, 
                                 dataspaceId, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT, 0, event_q);
     assert(aid2);
 
+    /* rename the attribute. This is asynchronous with a dependency on
+       the create at the server*/
     H5Arename_ff(did1, "ATTR2_tmp", "ATTR2", 0, event_q);
 
+    /* write data to the attribute. This is asynchronous but will wait
+       for the creation and rename calls at the server to complete */
     H5Awrite_ff(aid2, int_id, a_data, 0, event_q);
 
-    /* similar to the previous H5Dcreate. As soon as G1 is created, this can execute 
-       asynchronously and concurrently with the H5Dcreate for D1 
-       (i.e. no dependency)*/
+    /* similar to the previous H5Dcreate. */
     did2 = H5Dcreate_ff(file_id,"G1/G2/G3/D2",int_id,dataspaceId,
                         H5P_DEFAULT,H5P_DEFAULT,H5P_DEFAULT, 0, event_q);
     assert(did2);
 
-    /* similar to the previous H5Dcreate. As soon as G1 is created, this can execute 
-       asynchronously and concurrently with the H5Dcreate for D1 and D2 
-       (i.e. no dependency)*/
+    /* similar to the previous H5Dcreate. */
     did3 = H5Dcreate_ff(file_id,"G1/G2/G3/D3",int_id,dataspaceId,
                         H5P_DEFAULT,H5P_DEFAULT,H5P_DEFAULT, 0, event_q);
     assert(did3);
 
     /* Raw data write on D1. This is asynchronous, but it is delayed
-       internally at the IOD-VOL plugin client until the create for D1
+       internally at the server until the create for D1
        is completed.  Internal to the IOD-VOL plugin client we
        generate a checksum for data and ship it with the write bulk
        data function shipper handle to the server. */
     H5Dwrite_ff(did1, int_id, dataspaceId, dataspaceId, H5P_DEFAULT, data, 
                 0, event_q);
 
-    /* Raw data write on D2. This is asynchronous, but it is delayed
-       internally at the client until the create for D2 is
-       completed. Internally we generate a checksum for data2 and ship
-       it with the write call to the server.*/
+    /* Raw data write on D2. same as previous. */
     H5Dwrite_ff(did2, int_id, dataspaceId, dataspaceId, H5P_DEFAULT, data2, 
                 0, event_q);
 
-    /* Raw data write on D3. This is asynchronous, but it is delayed
-       internally at the client until the create for D3 is
-       completed. Internally we generate a checksum for data3 and ship
-       it with the write call to the server.*/
-    H5Dwrite_ff(did3, int_id, dataspaceId, dataspaceId, H5P_DEFAULT, data3, 
+    /* Raw data write on D3. Same as previous; however we specify that
+       the data in the buffer is in BE byte order and of smaller
+       extent than the datatype of the dataset. Type conversion will
+       happen at the server when we detect that the dataset type is of
+       LE order and the datatype here is in BE order and the
+       difference in size. The buffer is resized at the server also to
+       encompass the increase. */
+    H5Dwrite_ff(did3, H5T_STD_I16LE, dataspaceId, dataspaceId, H5P_DEFAULT, data3, 
                 0, event_q);
 
     /* NOTE: all raw data reads/writes execute concurrently at the
@@ -221,10 +247,7 @@ int main(int argc, char **argv) {
     assert(H5AOwait(req1, &status1) == 0);
     assert (status1);
 
-
-    /* Raw data read on D1. This is asynchronous, but it is delayed
-       internally at the client until the create for D1 is completed,
-       which it is since we waited on it in the previous H5Dwrite(D1).
+    /* Raw data read on D1. This is asynchronous.
 
        At the server side, since the IOD library is "skeletal" and no
        data exists, I am creating an array with the same size and
@@ -289,16 +312,11 @@ int main(int argc, char **argv) {
         assert(H5Dset_extent_ff(did1, &extent, event_q) == 0);
     }
 
-    /* closing did1 acts as a wait_some on all pending requests that are issued
-       on did1 (the H5Dwrite and 2 H5Dreads above). This is asynchronous. */
+    /* closing did1 acts as a barrier task at the server for all
+       operations dependeing on the dataset. This is asynchronous. */
     assert(H5Dclose_ff(did1, event_q) == 0);
 
-    /* closing did2 acts as a wait_some on all pending requests that are issued
-       on did2 (the H5Dwrite above). This is asynchronous. */
     assert(H5Dclose_ff(did2, event_q) == 0);
-
-    /* closing did3 acts as a wait_some on all pending requests that are issued
-       on did3 (the H5Dwrite above). This is asynchronous. */
     assert(H5Dclose_ff(did3, event_q) == 0);
     assert(H5Aclose_ff(aid2, event_q) == 0);
     assert(H5Tclose_ff(int_id, event_q) == 0);
@@ -307,12 +325,20 @@ int main(int argc, char **argv) {
     assert(H5Gclose_ff(gid3, event_q) == 0);
 
     /* Test Links */
+
+    /* create two new groups /G4 and /G4/G5 */
     gid1 = H5Gcreate_ff(file_id, "G4", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT, 0, event_q);
     gid2 = H5Gcreate_ff(file_id, "G4/G5", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT, 0, event_q);
 
+    /* create a hard link to D1 (created previosuly) so that it can be
+       accessed from G5/newD1. This is asynchronous; however all
+       operation that depend on G5 now will have this operation as a
+       parent at the AXE on the server. */
     H5Lcreate_hard_ff(file_id, "G1/G2/G3/D1", gid1, "G5/newD1", H5P_DEFAULT, H5P_DEFAULT, 0, event_q);
 
+    /* Try and open the dataset. This is asynchronous. */
     did1 = H5Dopen_ff(file_id,"G4/G5/newD1", H5P_DEFAULT, 0, event_q);
+
     H5Lcreate_soft_ff("/G1/G2/G3/D4", gid1, "G5/newD2", H5P_DEFAULT, H5P_DEFAULT, 0, event_q);
     H5Lmove_ff(file_id, "/G1/G2/G3/D3", file_id, "/G4/G5/D3moved", H5P_DEFAULT, H5P_DEFAULT, 0, event_q);
     H5Ldelete_ff(file_id, "/G1/G2/G3/D2", H5P_DEFAULT, 0, event_q);
@@ -321,7 +347,8 @@ int main(int argc, char **argv) {
     assert(H5Gclose_ff(gid1, event_q) == 0);
     assert(H5Gclose_ff(gid2, event_q) == 0);
 
-    /* flush all the contents of file to disk. This is asynchronous. */
+    /* flush all the contents of file to disk. This is a barrier task
+       at the server. This is asynchronous. */
     assert(H5Fflush_ff(file_id, H5F_SCOPE_GLOBAL, event_q) == 0);
 
     /* If the read request did no complete earlier when we tested it, Wait on it now.
@@ -337,13 +364,15 @@ int main(int argc, char **argv) {
        on the container. */
     assert(H5Fclose_ff(file_id, event_q) == 0);
 
+    /* wait on all requests and print completion status */
     H5EQwait(event_q, &num_requests, &status);
-    fprintf(stderr, "%d requests in event queue. Expecting 19. Completions: ", num_requests);
+    fprintf(stderr, "%d requests in event queue. Completions: ", num_requests);
     for(i=0 ; i<num_requests; i++)
         fprintf(stderr, "%d ",status[i]);
     fprintf(stderr, "\n");
     free(status);
 
+    /* wait again.. event queue should be empty now */
     H5EQwait(event_q, &num_requests, &status);
     fprintf(stderr, "%d requests in event queue. Expecting 0. Completions: ", num_requests);
     for(i=0 ; i<num_requests; i++)
@@ -351,6 +380,7 @@ int main(int argc, char **argv) {
     fprintf(stderr, "\n");
     free(status);
 
+    /* Now we can check operations that were issued previously */
     if(exists)
         printf("Attribute ATTR1 exists after being removed! Something is wrong!\n");
     else
@@ -385,21 +415,26 @@ int main(int argc, char **argv) {
     file_id = H5Fopen_ff(file_name, H5F_ACC_RDONLY, fapl_id, event_q);
     assert(file_id);
 
+    /* test object copy. This is asynchronous */
     assert(H5Ocopy_ff(file_id, "/G1/G2/G3/D1", file_id, "D1_copy", 
                       H5P_DEFAULT, H5P_DEFAULT, 0, event_q) == 0);
 
+    /* check if an object exists. This is asynchronous, so checking
+       the value should be done after the wait */
     H5Oexists_by_name_ff(file_id, "G1/G2/G3", &exists, H5P_DEFAULT, 0, event_q);
-    if(exists)
-        printf("Group G3 exists!\n");
-    else
-        printf("Group G3 does NOT exist. This must be the test without a native backend\n");
 
+    /* Open objects using the general H5O routines. This has an
+       asynchronous interface, but right now we implement it
+       synchronously, because we don't the object type to be able to
+       generate the ID. */
     gid1 = H5Oopen_ff(file_id, "G1", H5P_DEFAULT, 0, event_q);
     assert(gid1);
     int_id = H5Oopen_ff(file_id, "int", H5P_DEFAULT, 0, event_q);
     assert(int_id);
     did1 = H5Oopen_ff(file_id,"G1/G2/G3/D1", H5P_DEFAULT, 0, event_q);
     assert(did1);
+
+    /* open attribute by name. This is asynchronous. */
     aid2 = H5Aopen_by_name_ff(file_id, "G1/G2/G3/D1", "ATTR2", 
                               H5P_DEFAULT, H5P_DEFAULT, 0, event_q);
     assert(aid2);
@@ -409,11 +444,11 @@ int main(int argc, char **argv) {
     assert(H5Oclose_ff(int_id, event_q) == 0);
     assert(H5Oclose_ff(gid1, event_q) == 0);
 
-    /* Open a group G1 on the file. 
-       Internally there is a built in wait on the file_id.*/
+    /* Open a group G1 on the file. This is asynchronous */
     gid1 = H5Gopen_ff(file_id, "G1", H5P_DEFAULT, 0, event_q);
     assert(gid1);
 
+    /* get operations on the group */
     {
         ssize_t ret_size;
         char *comment = NULL;
@@ -442,14 +477,36 @@ int main(int argc, char **argv) {
     assert(int_id);
 
     /* Open a dataset D1 on the file in a group hierarchy. 
-       Internally there is a built in wait on group G1.*/
+       This is asynchronous */
     did1 = H5Dopen_ff(file_id,"G1/G2/G3/D1", H5P_DEFAULT, 0, event_q);
     assert(did1);
+
+    /* Raw data read on D1. This is asynchronous.  Note that the type
+       is different than the dataset type. The dataset was created in
+       int LE order with data written to it earlier in the same type
+       (0 - 60).
+
+       Reading this now will read those values, and convert them to BE
+       16 bit integers at the server and send them to the
+       client. Printing this data will result in 0 - 60 in 16 bit BE byte
+       order. */
+    H5Dread_ff(did1, H5T_STD_I32BE, dataspaceId, dataspaceId, H5P_DEFAULT, r_data, 
+               0, event_q);
+    if(H5EQpop(event_q, &req1) < 0)
+        exit(1);
+    assert(H5AOwait(req1, &status1) == 0);
+    assert (status1);
+    fprintf(stderr, "Printing Dataset value read in 16 bit BE order. This should be interesting: ");
+    for(i=0;i<nelem;++i)
+        fprintf(stderr, "%d ",r_data[i]);
+    fprintf(stderr, "\n");
     assert(H5Dclose(did1) == 0);
 
-    /* create an attribute on dataset D1. This is asynchronous, but waits internall for D1 to be created */
+    /* open attribute on dataset D1. This is asynchronous */
     aid2 = H5Aopen_by_name_ff(file_id, "G1/G2/G3/D1", "ATTR2", H5P_DEFAULT, H5P_DEFAULT, 0, event_q);
     assert(aid2);
+
+    /* read data from attribute. this is asynchronous */
     H5Aread_ff(aid2, int_id, ra_data, 0, event_q);
     assert(H5Aclose(aid2) == 0);
 
@@ -457,8 +514,9 @@ int main(int argc, char **argv) {
     assert(H5Gclose(gid1) == 0);
     assert(H5Fclose(file_id) == 0);
 
+    /* wait on all requests in event queue */
     H5EQwait(event_q, &num_requests, &status);
-    fprintf(stderr, "%d requests in event queue. Expecting 3. Completions: ", num_requests);
+    fprintf(stderr, "%d requests in event queue. Completions: ", num_requests);
     for(i=0 ; i<num_requests; i++)
         fprintf(stderr, "%d ",status[i]);
     fprintf(stderr, "\n");
@@ -469,6 +527,11 @@ int main(int argc, char **argv) {
         fprintf(stderr, "%d ",ra_data[i]);
     fprintf(stderr, "\n");
 
+    if(exists)
+        printf("Group G3 exists!\n");
+    else
+        printf("Group G3 does NOT exist. This must be the test without a native backend\n");
+
     H5EQclose(event_q);
     H5Pclose(fapl_id);
     H5Sclose(dataspaceId);
@@ -487,6 +550,7 @@ int main(int argc, char **argv) {
     free(a_data);
     free(data2);
     free(r2_data);
+    free(r3_data);
     free(data3);
 
     /* This finalizes the EFF stack. ships a terminate and IOD finalize to the server 
diff --git a/src/H5VLiod.c b/src/H5VLiod.c
index b748dc3..83d04b9 100644
--- a/src/H5VLiod.c
+++ b/src/H5VLiod.c
@@ -2149,10 +2149,6 @@ H5VL_iod_dataset_read(void *_dset, hid_t mem_type_id, hid_t mem_space_id,
     if(!buf && (NULL == file_space || H5S_GET_SELECT_NPOINTS(file_space) != 0))
 	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no output buffer");
 
-    /* If the buffer is nil, and 0 element is selected, make a fake buffer.
-     * This is for some MPI package like ChaMPIon on NCSA's tungsten which
-     * doesn't support this feature.
-     */
     if(!buf)
         buf = &fake_char;
 
@@ -2164,7 +2160,7 @@ H5VL_iod_dataset_read(void *_dset, hid_t mem_type_id, hid_t mem_space_id,
     }
 
     /* calculate the size of the buffer needed - MSC we are assuming everything is contiguous now */
-    size = H5Sget_simple_extent_npoints(mem_space_id) *  H5Tget_size(mem_type_id);
+    size = H5Sget_simple_extent_npoints(mem_space_id) * H5Tget_size(mem_type_id);
 
     /* allocate a bulk data transfer handle */
     if(NULL == (bulk_handle = (hg_bulk_t *)H5MM_malloc(sizeof(hg_bulk_t))))
@@ -2182,6 +2178,8 @@ H5VL_iod_dataset_read(void *_dset, hid_t mem_type_id, hid_t mem_space_id,
     input.checksum = 0;
     input.dxpl_id = dxpl_id;
     input.space_id = file_space_id;
+    input.dset_type_id = dset->remote_dset.type_id;
+    input.mem_type_id = mem_type_id;
     input.axe_id = axe_id ++;
 
     /* allocate structure to receive status of read operation (contains return value and checksum */
@@ -2263,7 +2261,7 @@ done:
  *		Failure:	-1, dataset not writed.
  *
  * Programmer:  Mohamad Chaarawi
- *              October, 2013
+ *              October, 2012
  *
  *-------------------------------------------------------------------------
  */
@@ -2323,10 +2321,6 @@ H5VL_iod_dataset_write(void *_dset, hid_t mem_type_id, hid_t mem_space_id,
     if(!buf && (NULL == file_space || H5S_GET_SELECT_NPOINTS(file_space) != 0))
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no output buffer");
 
-    /* If the buffer is nil, and 0 element is selected, make a fake buffer.
-     * This is for some MPI package like ChaMPIon on NCSA's tungsten which
-     * doesn't support this feature.
-     */
     if(!buf)
         buf = &fake_char;
 
@@ -2362,6 +2356,8 @@ H5VL_iod_dataset_write(void *_dset, hid_t mem_type_id, hid_t mem_space_id,
     input.checksum = cs;
     input.dxpl_id = dxpl_id;
     input.space_id = file_space_id;
+    input.dset_type_id = dset->remote_dset.type_id;
+    input.mem_type_id = mem_type_id;
     input.axe_id = axe_id ++;
 
     status = (int *)malloc(sizeof(int));
diff --git a/src/H5VLiod_client.c b/src/H5VLiod_client.c
index 73d1721..ef0806e 100644
--- a/src/H5VLiod_client.c
+++ b/src/H5VLiod_client.c
@@ -1006,7 +1006,7 @@ H5VL_iod_get_parent_info(H5VL_iod_object_t *obj, H5VL_loc_params_t loc_params,
         if(NULL == (next_obj = (H5VL_iod_object_t *)H5I_search_name(cur_name, H5I_GROUP))) {
             if(last_comp) {
                 if(NULL == (next_obj = (H5VL_iod_object_t *)H5I_search_name(cur_name, H5I_DATASET)))
-                   //&& NULL == (cur_obj = (H5VL_iod_object_t *)H5I_search_name(cur_name, H5I_DATATYPE)))
+                    //&& NULL == (cur_obj = (H5VL_iod_object_t *)H5I_search_name(cur_name, H5I_DATATYPE)))
                     break;
             }
             else {
diff --git a/src/H5VLiod_common.h b/src/H5VLiod_common.h
index 77bcf66..72a2607 100644
--- a/src/H5VLiod_common.h
+++ b/src/H5VLiod_common.h
@@ -139,6 +139,7 @@ MERCURY_GEN_PROC(dset_set_extent_in_t, ((iod_handle_t)(coh)) ((iod_handle_t)(iod
                  ((dims_t)(dims)) ((uint64_t)(axe_id)))
 MERCURY_GEN_PROC(dset_io_in_t, ((iod_handle_t)(coh)) ((iod_handle_t)(iod_oh)) 
                  ((iod_obj_id_t)(iod_id)) ((uint64_t)(parent_axe_id))
+                 ((hid_t)(dset_type_id)) ((hid_t)(mem_type_id))
                  ((hid_t)(space_id)) ((hid_t)(dxpl_id)) ((uint32_t)(checksum))
                  ((hg_bulk_t)(bulk_handle)) ((uint64_t)(axe_id)))
 MERCURY_GEN_PROC(dset_read_out_t, ((int32_t)(ret)) ((uint32_t)(cs)))
diff --git a/src/H5VLiod_server.c b/src/H5VLiod_server.c
index 04a4f52..aadc61e 100644
--- a/src/H5VLiod_server.c
+++ b/src/H5VLiod_server.c
@@ -14,9 +14,11 @@
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 #define H5G_PACKAGE		/*suppress error about including H5Gpkg   */
+#define H5D_PACKAGE		/*suppress error about including H5Dpkg	  */
 
 #include "H5private.h"		/* Generic Functions			*/
 #include "H5Apublic.h"		/* Attributes				*/
+#include "H5Dpkg.h"		/* Dataset functions			*/
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5Gpkg.h"		/* Groups		  		*/
 #include "H5Iprivate.h"		/* IDs			  		*/
@@ -49,11 +51,20 @@ static hbool_t shutdown = FALSE;
 
 #define EEXISTS 1
 
+H5FL_BLK_EXTERN(type_conv);
+
 static herr_t H5VL_iod_server_traverse(iod_handle_t coh, iod_obj_id_t loc_id, 
                                        iod_handle_t loc_handle, const char *path, 
                                        hbool_t create_interm_grps, char **last_comp, 
                                        iod_obj_id_t *iod_id, iod_handle_t *iod_oh);
 
+#if 0
+static herr_t H5VL_iod_typeinfo_init(hid_t dset_type_id, const H5D_dxpl_cache_t *dxpl_cache,
+                                     hid_t dxpl_id, hid_t mem_type_id, hbool_t do_write,
+                                     H5D_type_info_t *type_info);
+static herr_t H5VL_iod_typeinfo_term(const H5D_type_info_t *type_info);
+#endif
+
 static void H5VL_iod_server_file_create_cb(AXE_engine_t axe_engine, 
                                            size_t num_n_parents, AXE_task_t n_parents[], 
                                            size_t num_s_parents, AXE_task_t s_parents[], 
@@ -3287,13 +3298,16 @@ H5VL_iod_server_dset_read_cb(AXE_engine_t UNUSED axe_engine,
     hg_bulk_t bulk_handle = input->bulk_handle;
     hid_t space_id = input->space_id;
     hid_t dxpl_id = input->dxpl_id;
+    hid_t src_id = input->dset_type_id;
+    hid_t dst_id = input->mem_type_id;
     hg_bulk_block_t bulk_block_handle;
     hg_bulk_request_t bulk_request;
     iod_mem_desc_t mem_desc;
     iod_array_iodesc_t file_desc;
-    size_t size;
+    size_t size, buf_size, src_size, dst_size;
     void *buf;
     uint32_t cs = 0;
+    size_t nelmts;
     na_addr_t dest = HG_Handler_get_addr(op_data->hg_handle);
     herr_t ret_value = SUCCEED;
 
@@ -3311,7 +3325,23 @@ H5VL_iod_server_dset_read_cb(AXE_engine_t UNUSED axe_engine,
 
     size = HG_Bulk_handle_get_size(bulk_handle);
     fprintf(stderr, "Start dataset Read of size %d\n", size);
-    if(NULL == (buf = malloc(size)))
+
+    nelmts = (size_t)H5Sget_simple_extent_npoints(space_id);
+    src_size = H5Tget_size(src_id);
+    dst_size = H5Tget_size(dst_id);
+
+    /* adjust buffer size for datatype conversion */
+    if(src_size > dst_size) {
+        buf_size = src_size * nelmts;
+        fprintf(stderr, "Adjusted Buffer size because of datatype conversion from %d to %d: ", 
+                size, buf_size);        
+    }
+    else {
+        buf_size = dst_size * nelmts;
+        assert(buf_size == size);
+    }
+
+    if(NULL == (buf = malloc(buf_size)))
         HGOTO_ERROR(H5E_SYM, H5E_NOSPACE, FAIL, "can't allocate read buffer");
 
     mem_desc.nfrag = 1;
@@ -3326,11 +3356,11 @@ H5VL_iod_server_dset_read_cb(AXE_engine_t UNUSED axe_engine,
     
     {
         int i;
-        hbool_t flag;
+        hbool_t flag = FALSE;
         int *buf_ptr = (int *)buf;
 
 #if H5_DO_NATIVE
-    ret_value = H5Dread(iod_oh.cookie, H5T_NATIVE_INT, H5S_ALL, space_id, dxpl_id, buf);
+    ret_value = H5Dread(iod_oh.cookie, src_id, H5S_ALL, space_id, dxpl_id, buf);
 #else
     for(i=0;i<60;++i)
         buf_ptr[i] = i;
@@ -3345,6 +3375,9 @@ H5VL_iod_server_dset_read_cb(AXE_engine_t UNUSED axe_engine,
         fprintf(stderr, "Checksum Generated for data at server: %u\n", cs);
     }
 
+    if(H5Tconvert(src_id, dst_id, nelmts, buf, NULL, dxpl_id) < 0)
+        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "data type conversion failed")
+
     /* Create a new block handle to write the data */
     HG_Bulk_block_handle_create(buf, size, HG_BULK_READ_ONLY, &bulk_block_handle);
 
@@ -3402,13 +3435,15 @@ H5VL_iod_server_dset_write_cb(AXE_engine_t UNUSED axe_engine,
     hid_t space_id = input->space_id;
     hid_t dxpl_id = input->dxpl_id;
     uint32_t cs = input->checksum;
+    hid_t src_id = input->mem_type_id;
+    hid_t dst_id = input->dset_type_id;
     hg_bulk_block_t bulk_block_handle;
     hg_bulk_request_t bulk_request;
     iod_mem_desc_t mem_desc;
     iod_array_iodesc_t file_desc;
-    size_t size;
+    size_t size, buf_size, src_size, dst_size;
     void *buf;
-    ssize_t ret;
+    size_t nelmts;
     na_addr_t source = HG_Handler_get_addr(op_data->hg_handle);
     herr_t ret_value = SUCCEED;
 
@@ -3428,7 +3463,23 @@ H5VL_iod_server_dset_write_cb(AXE_engine_t UNUSED axe_engine,
 
     /* Read bulk data here and wait for the data to be here  */
     size = HG_Bulk_handle_get_size(bulk_handle);
-    if(NULL == (buf = malloc(size)))
+
+    nelmts = (size_t)H5Sget_simple_extent_npoints(space_id);
+    src_size = H5Tget_size(src_id);
+    dst_size = H5Tget_size(dst_id);
+
+    /* adjust buffer size for datatype conversion */
+    if(src_size < dst_size) {
+        buf_size = dst_size * nelmts;
+        fprintf(stderr, "Adjusted Buffer size because of datatype conversion from %d to %d: ", 
+                size, buf_size);        
+    }
+    else {
+        buf_size = src_size * nelmts;
+        assert(buf_size == size);
+    }
+
+    if(NULL == (buf = malloc(buf_size)))
         HGOTO_ERROR(H5E_SYM, H5E_NOSPACE, FAIL, "can't allocate read buffer");
 
     HG_Bulk_block_handle_create(buf, size, HG_BULK_READWRITE, &bulk_block_handle);
@@ -3444,6 +3495,24 @@ H5VL_iod_server_dset_write_cb(AXE_engine_t UNUSED axe_engine,
     if(HG_SUCCESS != HG_Bulk_block_handle_free(bulk_block_handle))
         HGOTO_ERROR(H5E_SYM, H5E_WRITEERROR, FAIL, "can't free bds block handle");
 
+#if 0
+    /* Fill the DXPL cache values for later use */
+    if(H5D__get_dxpl_cache(dxpl_id, &dxpl_cache) < 0)
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't fill dxpl cache")
+    /* Set up datatype info for operation */
+    if(H5VL_iod_typeinfo_init(input->dset_type_id, dxpl_cache, dxpl_id, 
+                              input->mem_type_id, TRUE, &type_info) < 0)
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to set up type info")
+    type_info_init = TRUE;
+
+    if(!type_info->is_xform_noop || !type_info->is_conv_noop) {
+        /* type conversion is needed */
+    }
+#endif
+
+    if(H5Tconvert(src_id, dst_id, nelmts, buf, NULL, dxpl_id) < 0)
+        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "data type conversion failed")
+
     { 
         int i;
         int *buf_ptr = (int *)buf;
@@ -3472,6 +3541,11 @@ done:
     fprintf(stderr, "Done with dset write, sending %d response to client\n", ret_value);
     if(HG_SUCCESS != HG_Handler_start_output(op_data->hg_handle, &ret_value))
         HDONE_ERROR(H5E_SYM, H5E_WRITEERROR, FAIL, "can't send result of write to client");
+#if 0
+    /* Shut down datatype info for operation */
+    if(type_info_init && H5VL_iod_typeinfo_term(&type_info) < 0)
+        HDONE_ERROR(H5E_DATASET, H5E_CANTCLOSEOBJ, FAIL, "unable to shut down type info")
+#endif
 
     input = (dset_io_in_t *)H5MM_xfree(input);
     op_data = (op_data_t *)H5MM_xfree(op_data);
@@ -5626,4 +5700,193 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 }
 
+#if 0
+
+/*-------------------------------------------------------------------------
+ * Function:	H5VL_iod_typeinfo_init
+ *
+ * Purpose:	Routine for determining correct datatype information for
+ *              each I/O action.
+ *
+ * Return:	Non-negative on success/Negative on failure
+ *
+ * Programmer:  Mohamad Chaarawi
+ *              June, 2013
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5VL_iod_typeinfo_init(hid_t dset_type_id, const H5D_dxpl_cache_t *dxpl_cache,
+                       hid_t dxpl_id, hid_t mem_type_id, hbool_t do_write,
+                       H5D_type_info_t *type_info)
+{
+    const H5T_t	*src_type;              /* Source datatype */
+    const H5T_t	*dst_type;              /* Destination datatype */
+    herr_t ret_value = SUCCEED;	        /* Return value	*/
+
+    FUNC_ENTER_NOAPI_NOINIT
+
+    /* check args */
+    HDassert(type_info);
+
+    /* Initialize type info safely */
+    HDmemset(type_info, 0, sizeof(*type_info));
+
+    /* Get the memory & dataset datatypes */
+    if(NULL == (type_info->mem_type = (const H5T_t *)H5I_object_verify(mem_type_id, H5I_DATATYPE)))
+	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a datatype")
+    if(NULL == (type_info->dset_type = (const H5T_t *)H5I_object_verify(dset_type_id, H5I_DATATYPE)))
+	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a datatype")
+
+    if(do_write) {
+        src_type = type_info->mem_type;
+        dst_type = type_info->dset_type;
+        type_info->src_type_id = mem_type_id;
+        type_info->dst_type_id = dset_type_id;
+    } /* end if */
+    else {
+        src_type = type_info->dset_type;
+        dst_type = type_info->mem_type;
+        type_info->src_type_id = dset_type_id;
+        type_info->dst_type_id = mem_type_id;
+    } /* end else */
+
+    /*
+     * Locate the type conversion function and data space conversion
+     * functions, and set up the element numbering information. If a data
+     * type conversion is necessary then register datatype atoms. Data type
+     * conversion is necessary if the user has set the `need_bkg' to a high
+     * enough value in xfer_parms since turning off datatype conversion also
+     * turns off background preservation.
+     */
+    if(NULL == (type_info->tpath = H5T_path_find(src_type, dst_type, NULL, NULL, dxpl_id, FALSE)))
+	HGOTO_ERROR(H5E_DATASET, H5E_UNSUPPORTED, FAIL, "unable to convert between src and dest datatype")
+
+    /* Precompute some useful information */
+    type_info->src_type_size = H5T_get_size(src_type);
+    type_info->dst_type_size = H5T_get_size(dst_type);
+    type_info->max_type_size = MAX(type_info->src_type_size, type_info->dst_type_size);
+    type_info->is_conv_noop = H5T_path_noop(type_info->tpath);
+    type_info->is_xform_noop = H5Z_xform_noop(dxpl_cache->data_xform_prop);
+    if(type_info->is_xform_noop && type_info->is_conv_noop) {
+        type_info->cmpd_subset = NULL;
+        type_info->need_bkg = H5T_BKG_NO;
+    } /* end if */
+    else {
+        size_t	target_size;		/* Desired buffer size	*/
+
+        /* Check if the datatypes are compound subsets of one another */
+        type_info->cmpd_subset = H5T_path_compound_subset(type_info->tpath);
+
+        /* Check if we need a background buffer */
+        if(do_write && H5T_detect_class(type_info->dset_type, H5T_VLEN, FALSE))
+            type_info->need_bkg = H5T_BKG_YES;
+        else {
+            H5T_bkg_t path_bkg;     /* Type conversion's background info */
+
+            if((path_bkg = H5T_path_bkg(type_info->tpath))) {
+                /* Retrieve the bkgr buffer property */
+                type_info->need_bkg = dxpl_cache->bkgr_buf_type;
+                type_info->need_bkg = MAX(path_bkg, type_info->need_bkg);
+            } /* end if */
+            else
+                type_info->need_bkg = H5T_BKG_NO; /*never needed even if app says yes*/
+        } /* end else */
+
+
+        /* Set up datatype conversion/background buffers */
+
+        /* Get buffer size from DXPL */
+        target_size = dxpl_cache->max_temp_buf;
+
+        /* If the buffer is too small to hold even one element, try to make it bigger */
+        if(target_size < type_info->max_type_size) {
+            hbool_t default_buffer_info;    /* Whether the buffer information are the defaults */
+
+            /* Detect if we have all default settings for buffers */
+            default_buffer_info = (hbool_t)((H5D_TEMP_BUF_SIZE == dxpl_cache->max_temp_buf)
+                    && (NULL == dxpl_cache->tconv_buf) && (NULL == dxpl_cache->bkgr_buf));
+
+            /* Check if we are using the default buffer info */
+            if(default_buffer_info)
+                /* OK to get bigger for library default settings */
+                target_size = type_info->max_type_size;
+            else
+                /* Don't get bigger than the application has requested */
+                HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "temporary buffer max size is too small")
+        } /* end if */
+
+        /* Compute the number of elements that will fit into buffer */
+        type_info->request_nelmts = target_size / type_info->max_type_size;
+
+        /* Sanity check elements in temporary buffer */
+        if(type_info->request_nelmts == 0)
+            HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "temporary buffer max size is too small")
+
+        /*
+         * Get a temporary buffer for type conversion unless the app has already
+         * supplied one through the xfer properties. Instead of allocating a
+         * buffer which is the exact size, we allocate the target size.  The
+         * malloc() is usually less resource-intensive if we allocate/free the
+         * same size over and over.
+         */
+        if(NULL == (type_info->tconv_buf = (uint8_t *)dxpl_cache->tconv_buf)) {
+            /* Allocate temporary buffer */
+            if(NULL == (type_info->tconv_buf = H5FL_BLK_MALLOC(type_conv, target_size)))
+                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for type conversion")
+            type_info->tconv_buf_allocated = TRUE;
+        } /* end if */
+        if(type_info->need_bkg && NULL == (type_info->bkg_buf = (uint8_t *)dxpl_cache->bkgr_buf)) {
+            size_t	bkg_size;		/* Desired background buffer size	*/
+
+            /* Compute the background buffer size */
+            /* (don't try to use buffers smaller than the default size) */
+            bkg_size = type_info->request_nelmts * type_info->dst_type_size;
+            if(bkg_size < dxpl_cache->max_temp_buf)
+                bkg_size = dxpl_cache->max_temp_buf;
+
+            /* Allocate background buffer */
+            /* (Need calloc()-like call since memory needs to be initialized) */
+            if(NULL == (type_info->bkg_buf = H5FL_BLK_CALLOC(type_conv, bkg_size)))
+                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for background conversion")
+            type_info->bkg_buf_allocated = TRUE;
+        } /* end if */
+    } /* end else */
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5VL_iod_typeinfo_init() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5VL_iod_typeinfo_term
+ *
+ * Purpose:	Common logic for terminating a type info object
+ *
+ * Return:	Non-negative on success/Negative on failure
+ *
+ * Programmer:	Quincey Koziol
+ *		Thursday, March  6, 2008
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5VL_iod_typeinfo_term(const H5D_type_info_t *type_info)
+{
+    FUNC_ENTER_NOAPI_NOINIT_NOERR
+
+    /* Check for releasing datatype conversion & background buffers */
+    if(type_info->tconv_buf_allocated) {
+        HDassert(type_info->tconv_buf);
+        (void)H5FL_BLK_FREE(type_conv, type_info->tconv_buf);
+    } /* end if */
+    if(type_info->bkg_buf_allocated) {
+        HDassert(type_info->bkg_buf);
+        (void)H5FL_BLK_FREE(type_conv, type_info->bkg_buf);
+    } /* end if */
+
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* end H5VL_iod_typeinfo_term() */
+#endif
+
 #endif /* H5_HAVE_EFF */
-- 
cgit v0.12