diff options
Diffstat (limited to 'perform/pio_engine.c')
| -rw-r--r-- | perform/pio_engine.c | 483 |
1 files changed, 363 insertions, 120 deletions
diff --git a/perform/pio_engine.c b/perform/pio_engine.c index 753b873..928129c 100644 --- a/perform/pio_engine.c +++ b/perform/pio_engine.c @@ -34,7 +34,7 @@ /* Macro definitions */ /* sizes of various items. these sizes won't change during program execution */ -#define ELMT_SIZE ((int)sizeof(int)) /* we're doing ints */ +#define ELMT_SIZE (sizeof(int)) /* we're doing ints */ #define GOTOERROR(errcode) { ret_code = errcode; goto done; } #define GOTODONE { goto done; } @@ -216,13 +216,6 @@ do_pio(parameters param) } } - if (blk_size < 0 ) { - HDfprintf(stderr, - "interleaved I/O block size must be >= 0 (%Hd)\n", - (long_long)blk_size); - GOTOERROR(FAIL); - } - /* Should only need blk_size <= buf_size. */ /* More restrictive condition for easier implementation for now. */ if (blk_size > 0 && (buf_size % blk_size)){ @@ -455,23 +448,35 @@ do_write(results *res, file_descr *fd, parameters *parms, long ndsets, MPI_Offset mpi_offset; MPI_Status mpi_status; long ndset; - off_t nelmts_written; - size_t nelmts_towrite; + off_t nelmts_xfer; + size_t nelmts_toxfer; char dname[64]; off_t dset_offset; /*dataset offset in a file */ off_t file_offset; /*file offset of the next transfer */ off_t dset_size; /*one dataset size in bytes */ - size_t nelmts_in_buf; + size_t nelmts_in_buf; /*how many element the buffer holds */ + size_t nelmts_in_blk; /*how many element a block holds */ off_t elmts_begin; /*first elmt this process transfer */ off_t elmts_count; /*number of elmts this process transfer */ hid_t dcpl = -1; /* Dataset creation property list */ /* HDF5 variables */ - herr_t hrc; /*HDF5 return code */ - hsize_t h5dims[1]; /*dataset dim sizes */ - hid_t h5dset_space_id = -1; /*dataset space ID */ - hid_t h5mem_space_id = -1; /*memory dataspace ID */ - hid_t h5ds_id = -1; /*dataset handle */ + herr_t hrc; /*HDF5 return code */ + hsize_t h5dims[1]; /*dataset dim sizes */ + hid_t h5dset_space_id = -1; /*dataset space ID */ + hid_t h5mem_space_id = -1; /*memory dataspace ID */ + hid_t h5ds_id = -1; /*dataset handle */ + hsize_t h5mem_block[1]; /*memory space selection */ + hsize_t h5mem_stride[1]; + hsize_t h5mem_count[1]; + hssize_t h5mem_start[1]; +#if 0 + /* for future implementation */ + hsize_t h5dset_block[1]; /*dset space selection */ + hsize_t h5dset_stride[1]; + hsize_t h5dset_count[1]; + hssize_t h5dset_start[1]; +#endif /* calculate dataset parameters. data type is always native C int */ dset_size = nelmts * ELMT_SIZE; @@ -562,33 +567,103 @@ do_write(results *res, file_descr *fd, parameters *parms, long ndsets, break; } - /* Calculate the first element and how many elements this process - * transfer. First calculate the beginning element of this process - * and the next process. Count of elements is the difference between - * these two beginnings. This way, it avoids any rounding errors. - */ - elmts_begin = (long)(((double)nelmts)/pio_mpi_nprocs_g*pio_mpi_rank_g); - - if (pio_mpi_rank_g < (pio_mpi_nprocs_g - 1)) - elmts_count = (long)((((double)nelmts) / pio_mpi_nprocs_g * (pio_mpi_rank_g + 1)) - - (double)elmts_begin); - else - /* last process. Take whatever are left */ - elmts_count = nelmts - elmts_begin; - - nelmts_written = 0 ; + /* There are two kinds of transfer patterns, contiguous and interleaved. + * Let 0,1,2,...,n be data accessed by process 0,1,2,...,n + * where n is rank of the last process. + * In contiguous pattern, data are accessed as + * 000...111...222...nnn... + * In interleaved pattern, data are accessed as + * 012...n012...n... + * These are all in the scope of one dataset. + */ + /* Calculate the total number of elements (elmts_count) to be + * transferred by this process. It may be different for different + * transfer pattern due to rounding to integral values. + */ + if (blk_size==0){ + /* Contiguous Pattern: + * Calculate the beginning element of this process and the next. + * elmts_count is the difference between these two beginnings. + * This way, it eliminates any rounding errors. + */ + elmts_begin = (off_t)(((double)nelmts)/pio_mpi_nprocs_g*pio_mpi_rank_g); + + /* Do not cast elmt_begin to other types, especially non-integral + * types, else it may introduce rounding discrepency. */ + if (pio_mpi_rank_g < (pio_mpi_nprocs_g - 1)) + elmts_count = (off_t)(((double)nelmts) / pio_mpi_nprocs_g * (pio_mpi_rank_g + 1)) + - elmts_begin; + else + /* last process. Take whatever are left */ + elmts_count = nelmts - elmts_begin; + }else{ + /* Interleaved Pattern: + * Each process takes blk_size of elements, starting with the first + * process. So, the last process may have fewer or even none. + * Calculate the beginning element of this process and the next. + * The elmnts_begin here marks only the beginning of the first + * block accessed by this process. + */ + /* Algorithm: + * First allocate equal blocks per process, i.e. one block each + * process for every block_size*nprocs. + * If there is remaining unallocated, give a block each to process + * starting at proc 0. The last process may get a partial block. + */ + off_t remain_nelmts, remain_begin; /* unallocated remaining*/ + + nelmts_in_blk = blk_size/ELMT_SIZE; + elmts_begin = (off_t)(nelmts_in_blk*pio_mpi_rank_g); + + /* must use integer calculation next */ + /* allocate equal blocks per process */ + elmts_count = (nelmts / (off_t)(nelmts_in_blk*pio_mpi_nprocs_g)) * + (off_t)nelmts_in_blk; + remain_nelmts = nelmts % ((off_t)(nelmts_in_blk*pio_mpi_nprocs_g)); + + /* allocate any remaining */ + remain_begin = (off_t)(nelmts_in_blk*pio_mpi_rank_g); + if (remain_nelmts > remain_begin){ + /* it gets something */ + if (remain_nelmts > (remain_begin+(off_t)nelmts_in_blk)){ + /* one full block */ + elmts_count += nelmts_in_blk; + }else{ + /* only a partial block */ + elmts_count += remain_nelmts - remain_begin; + } + } + } + /* debug */ + if (pio_debug_level >= 4) { + HDprint_rank(output); + HDfprintf(output, "Debug(do_write): " + "nelmts_in_blk=%Hd, elmts_begin=%Hd, elmts_count=%Hd\n", + (long_long)nelmts_in_blk, (long_long)elmts_begin, + (long_long)elmts_count); + } + + + /* The task is to transfer elmts_count elements, starting at + * elmts_begin position, using transfer buffer of buf_size bytes. + * If blk_size > 0, select blk_size at a time, in round robin + * fashion, according to number of process. Otherwise, select + * all elmt_count in contiguous. + */ + nelmts_xfer = 0 ; /* Start "raw data" write timer */ set_time(res->timers, HDF5_RAW_WRITE_FIXED_DIMS, START); - while (nelmts_written < elmts_count){ - nelmts_towrite = elmts_count - nelmts_written; - - if ((elmts_count - nelmts_written) >= nelmts_in_buf) { - nelmts_towrite = nelmts_in_buf; + while (nelmts_xfer < elmts_count){ + /* transfer one buffer of data each round */ + /* Note: because size_t is unsigned, avoid expressions that */ + /* can be negative. */ + if ((nelmts_xfer + (off_t)nelmts_in_buf) <= elmts_count) { + nelmts_toxfer = nelmts_in_buf; } else { - /* last write of a partial buffer */ - nelmts_towrite = elmts_count - nelmts_written; + /* last transfer of a partial buffer */ + nelmts_toxfer = elmts_count - nelmts_xfer; } #ifdef AKCDEBUG @@ -597,8 +672,8 @@ do_write(results *res, file_descr *fd, parameters *parms, long ndsets, int *intptr = (int *)buffer; register int i; - for (i = 0; i < nelmts_towrite; ++i) - *intptr++ = nelmts_towrite + i; + for (i = 0; i < nelmts_toxfer; ++i) + *intptr++ = nelmts_toxfer + i; } #endif @@ -606,43 +681,87 @@ do_write(results *res, file_descr *fd, parameters *parms, long ndsets, /* Calculate offset of write within a dataset/file */ switch (parms->io_type) { case POSIXIO: - /* need to (off_t) the elmnts_begin expression because they */ - /* may be of smaller sized integer types */ - file_offset = dset_offset + (off_t)(elmts_begin + nelmts_written)*ELMT_SIZE; - - /* only care if seek returns error */ - rc = POSIXSEEK(fd->posixfd, file_offset) < 0 ? -1 : 0; - VRFY((rc==0), "POSIXSEEK"); - /* check if all bytes are written */ - rc = ((nelmts_towrite*ELMT_SIZE) == - POSIXWRITE(fd->posixfd, buffer, nelmts_towrite*ELMT_SIZE)); - VRFY((rc != 0), "POSIXWRITE"); + if (blk_size==0){ + /* Contiguous pattern */ + /* need to (off_t) the elmnts_begin expression because they */ + /* may be of smaller sized integer types */ + file_offset = dset_offset + (off_t)(elmts_begin + nelmts_xfer)*ELMT_SIZE; + + /* only care if seek returns error */ + rc = POSIXSEEK(fd->posixfd, file_offset) < 0 ? -1 : 0; + VRFY((rc==0), "POSIXSEEK"); + /* check if all bytes are transferred */ + rc = ((ssize_t)(nelmts_toxfer*ELMT_SIZE) == + POSIXWRITE(fd->posixfd, buffer, nelmts_toxfer*ELMT_SIZE)); + VRFY((rc != 0), "POSIXWRITE"); + }else{ + /* interleaved access pattern */ + char *buf_p=buffer; + size_t xferred=0; + size_t toxfer=0; + + file_offset = dset_offset + (off_t)(elmts_begin + nelmts_xfer)*ELMT_SIZE; + if (pio_debug_level >= 4) { +HDprint_rank(output); +HDfprintf(output, +"Debug(do_write): " +"nelmts_toxfer=%Hd, nelmts_xfer=%Hd\n" +, +(long_long)nelmts_toxfer, (long_long)nelmts_xfer); +} + while (xferred < nelmts_toxfer){ + if ((nelmts_toxfer - xferred) >= nelmts_in_blk) + toxfer = nelmts_in_blk; + else + toxfer = nelmts_toxfer - xferred; + /* Skip offset over blocks of other processes */ + file_offset = dset_offset + + (off_t)(elmts_begin + (nelmts_xfer+xferred)*pio_mpi_nprocs_g)*ELMT_SIZE; + if (pio_debug_level >= 4) { +HDprint_rank(output); +HDfprintf(output, +"Debug(do_write): " +"nelmts_toxfer=%Hd, nelmts_xfer=%Hd" +", toxfer=%Hd, xferred=%Hd" +", file_offset=%Hd" +"\n", +(long_long)nelmts_toxfer, (long_long)nelmts_xfer, +(long_long)toxfer, (long_long)xferred, +(long_long)file_offset); +} + /* only care if seek returns error */ + rc = POSIXSEEK(fd->posixfd, file_offset) < 0 ? -1 : 0; + VRFY((rc==0), "POSIXSEEK"); + /* check if all bytes are written */ + rc = ((ssize_t)(toxfer*ELMT_SIZE) == + POSIXWRITE(fd->posixfd, buf_p, toxfer*ELMT_SIZE)); + VRFY((rc != 0), "POSIXWRITE"); + xferred += toxfer; + } + } break; case MPIO: - mpi_offset = dset_offset + (elmts_begin + nelmts_written)*ELMT_SIZE; + mpi_offset = dset_offset + (elmts_begin + nelmts_xfer)*ELMT_SIZE; mrc = MPI_File_write_at(fd->mpifd, mpi_offset, buffer, - (int)(nelmts_towrite*ELMT_SIZE), MPI_CHAR, + (int)(nelmts_toxfer*ELMT_SIZE), MPI_CHAR, &mpi_status); VRFY((mrc==MPI_SUCCESS), "MPIO_WRITE"); break; case PHDF5: /*set up the dset space id to select the segment to process */ { - hsize_t block[1], stride[1], count[1]; - hssize_t start[1]; - - start[0] = elmts_begin + nelmts_written; - stride[0] = block[0] = nelmts_towrite; - count[0] = 1; + h5mem_start[0] = elmts_begin + nelmts_xfer; + h5mem_stride[0] = h5mem_block[0] = nelmts_toxfer; + h5mem_count[0] = 1; hrc = H5Sselect_hyperslab(h5dset_space_id, H5S_SELECT_SET, - start, stride, count, block); + h5mem_start, h5mem_stride, h5mem_count, h5mem_block); VRFY((hrc >= 0), "H5Sset_hyperslab"); /*setup the memory space id too. Only start is different */ - start[0] = 0; + h5mem_start[0] = 0; hrc = H5Sselect_hyperslab(h5mem_space_id, H5S_SELECT_SET, - start, stride, count, block); + h5mem_start, h5mem_stride, h5mem_count, h5mem_block); VRFY((hrc >= 0), "H5Sset_hyperslab"); } @@ -653,7 +772,7 @@ do_write(results *res, file_descr *fd, parameters *parms, long ndsets, break; } - nelmts_written += nelmts_towrite; + nelmts_xfer += nelmts_toxfer; } /* Stop "raw data" write timer */ @@ -716,22 +835,34 @@ do_read(results *res, file_descr *fd, parameters *parms, long ndsets, MPI_Offset mpi_offset; MPI_Status mpi_status; long ndset; - size_t nelmts_toread; - off_t nelmts_read; + off_t nelmts_xfer; + size_t nelmts_toxfer; char dname[64]; off_t dset_offset; /*dataset offset in a file */ off_t file_offset; /*file offset of the next transfer */ off_t dset_size; /*one dataset size in bytes */ - size_t nelmts_in_buf; + size_t nelmts_in_buf; /*how many element the buffer holds */ + size_t nelmts_in_blk; /*how many element a block holds */ off_t elmts_begin; /*first elmt this process transfer */ off_t elmts_count; /*number of elmts this process transfer */ /* HDF5 variables */ - herr_t hrc; /*HDF5 return code */ - hsize_t h5dims[1]; /*dataset dim sizes */ + herr_t hrc; /*HDF5 return code */ + hsize_t h5dims[1]; /*dataset dim sizes */ hid_t h5dset_space_id = -1; /*dataset space ID */ hid_t h5mem_space_id = -1; /*memory dataspace ID */ - hid_t h5ds_id = -1; /*dataset handle */ + hid_t h5ds_id = -1; /*dataset handle */ + hsize_t h5mem_block[1]; /*memory space selection */ + hsize_t h5mem_stride[1]; + hsize_t h5mem_count[1]; + hssize_t h5mem_start[1]; +#if 0 + /* for future implementation */ + hsize_t h5dset_block[1]; /*dset space selection */ + hsize_t h5dset_stride[1]; + hsize_t h5dset_count[1]; + hssize_t h5dset_start[1]; +#endif /* calculate dataset parameters. data type is always native C int */ dset_size = nelmts * ELMT_SIZE; @@ -784,57 +915,174 @@ do_read(results *res, file_descr *fd, parameters *parms, long ndsets, break; } - /* - * Calculate the first element and how many elements this process - * transfer. First calculate the beginning element of this process - * and the next process. Count of elements is the difference between - * these two beginnings. This way, it avoids any rounding errors. - */ - elmts_begin = (long)(((double)nelmts)/pio_mpi_nprocs_g*pio_mpi_rank_g); - - if (pio_mpi_rank_g < (pio_mpi_nprocs_g - 1)) - elmts_count = (long)((((double)nelmts) / pio_mpi_nprocs_g * (pio_mpi_rank_g + 1)) - - (double)elmts_begin); - else - /* last process. Take whatever are left */ - elmts_count = nelmts - elmts_begin; - - nelmts_read = 0 ; + /* There are two kinds of transfer patterns, contiguous and interleaved. + * Let 0,1,2,...,n be data accessed by process 0,1,2,...,n + * where n is rank of the last process. + * In contiguous pattern, data are accessed as + * 000...111...222...nnn... + * In interleaved pattern, data are accessed as + * 012...n012...n... + * These are all in the scope of one dataset. + */ + /* Calculate the total number of elements (elmts_count) to be + * transferred by this process. It may be different for different + * transfer pattern due to rounding to integral values. + */ + if (blk_size==0){ + /* Contiguous Pattern: + * Calculate the beginning element of this process and the next. + * elmts_count is the difference between these two beginnings. + * This way, it eliminates any rounding errors. + */ + elmts_begin = (off_t)(((double)nelmts)/pio_mpi_nprocs_g*pio_mpi_rank_g); + + /* Do not cast elmt_begin to other types, especially non-integral + * types, else it may introduce rounding discrepency. */ + if (pio_mpi_rank_g < (pio_mpi_nprocs_g - 1)) + elmts_count = (off_t)(((double)nelmts) / pio_mpi_nprocs_g * (pio_mpi_rank_g + 1)) + - elmts_begin; + else + /* last process. Take whatever are left */ + elmts_count = nelmts - elmts_begin; + }else{ + /* Interleaved Pattern: + * Each process takes blk_size of elements, starting with the first + * process. So, the last process may have fewer or even none. + * Calculate the beginning element of this process and the next. + * The elmnts_begin here marks only the beginning of the first + * block accessed by this process. + */ + /* Algorithm: + * First allocate equal blocks per process, i.e. one block each + * process for every block_size*nprocs. + * If there is remaining unallocated, give a block each to process + * starting at proc 0. The last process may get a partial block. + */ + off_t remain_nelmts, remain_begin; /* unallocated remaining*/ + + nelmts_in_blk = blk_size/ELMT_SIZE; + elmts_begin = (off_t)(nelmts_in_blk*pio_mpi_rank_g); + + /* must use integer calculation next */ + /* allocate equal blocks per process */ + elmts_count = (nelmts / (off_t)(nelmts_in_blk*pio_mpi_nprocs_g)) * + (off_t)nelmts_in_blk; + remain_nelmts = nelmts % ((off_t)(nelmts_in_blk*pio_mpi_nprocs_g)); + + /* allocate any remaining */ + remain_begin = (off_t)(nelmts_in_blk*pio_mpi_rank_g); + if (remain_nelmts > remain_begin){ + /* it gets something */ + if (remain_nelmts > (remain_begin+(off_t)nelmts_in_blk)){ + /* one full block */ + elmts_count += nelmts_in_blk; + }else{ + /* only a partial block */ + elmts_count += remain_nelmts - remain_begin; + } + } + } + /* debug */ + if (pio_debug_level >= 4) { + HDprint_rank(output); + HDfprintf(output, "Debug(do_read): " + "nelmts_in_blk=%Hd, elmts_begin=%Hd, elmts_count=%Hd\n", + (long_long)nelmts_in_blk, (long_long)elmts_begin, + (long_long)elmts_count); + } + + + /* The task is to transfer elmts_count elements, starting at + * elmts_begin position, using transfer buffer of buf_size bytes. + * If blk_size > 0, select blk_size at a time, in round robin + * fashion, according to number of process. Otherwise, select + * all elmt_count in contiguous. + */ + nelmts_xfer = 0 ; /* Start "raw data" read timer */ set_time(res->timers, HDF5_RAW_READ_FIXED_DIMS, START); - while (nelmts_read < elmts_count){ - nelmts_toread = elmts_count - nelmts_read; - - if ((elmts_count - nelmts_read) >= nelmts_in_buf) - nelmts_toread = nelmts_in_buf; - else - /* last read of a partial buffer */ - nelmts_toread = elmts_count - nelmts_read; + while (nelmts_xfer < elmts_count){ + /* transfer one buffer of data each round */ + /* Note: because size_t is unsigned, avoid expressions that */ + /* can be negative. */ + if ((nelmts_xfer + (off_t)nelmts_in_buf) <= elmts_count) { + nelmts_toxfer = nelmts_in_buf; + } else { + /* last transfer of a partial buffer */ + nelmts_toxfer = elmts_count - nelmts_xfer; + } /* read */ /* Calculate offset of read within a dataset/file */ switch (parms->io_type){ case POSIXIO: - /* need to (off_t) the elmnts_begin expression because they */ - /* may be of smaller sized integer types */ - file_offset = dset_offset + (off_t)(elmts_begin + nelmts_read)*ELMT_SIZE; - - /* only care if seek returns error */ - rc = POSIXSEEK(fd->posixfd, file_offset) < 0 ? -1 : 0; - VRFY((rc==0), "POSIXSEEK"); - /* check if all bytes are read */ - rc = ((nelmts_toread*ELMT_SIZE) == - POSIXREAD(fd->posixfd, buffer, nelmts_toread*ELMT_SIZE)); - VRFY((rc != 0), "POSIXREAD"); + if (blk_size==0){ + /* Contiguous pattern */ + /* need to (off_t) the elmnts_begin expression because they */ + /* may be of smaller sized integer types */ + file_offset = dset_offset + (off_t)(elmts_begin + nelmts_xfer)*ELMT_SIZE; + + /* only care if seek returns error */ + rc = POSIXSEEK(fd->posixfd, file_offset) < 0 ? -1 : 0; + VRFY((rc==0), "POSIXSEEK"); + /* check if all bytes are transferred */ + rc = ((ssize_t)(nelmts_toxfer*ELMT_SIZE) == + POSIXREAD(fd->posixfd, buffer, nelmts_toxfer*ELMT_SIZE)); + VRFY((rc != 0), "POSIXREAD"); + }else{ + /* interleaved access pattern */ + char *buf_p=buffer; + size_t xferred=0; + size_t toxfer=0; + + file_offset = dset_offset + (off_t)(elmts_begin + nelmts_xfer)*ELMT_SIZE; + if (pio_debug_level >= 4) { +HDprint_rank(output); +HDfprintf(output, +"Debug(do_read): " +"nelmts_toxfer=%Hd, nelmts_xfer=%Hd\n" +, +(long_long)nelmts_toxfer, (long_long)nelmts_xfer); +} + while (xferred < nelmts_toxfer){ + if ((nelmts_toxfer - xferred) >= nelmts_in_blk) + toxfer = nelmts_in_blk; + else + toxfer = nelmts_toxfer - xferred; + /* Skip offset over blocks of other processes */ + file_offset = dset_offset + + (off_t)(elmts_begin + (nelmts_xfer+xferred)*pio_mpi_nprocs_g)*ELMT_SIZE; + if (pio_debug_level >= 4) { +HDprint_rank(output); +HDfprintf(output, +"Debug(do_read):" +"nelmts_toxfer=%Hd, nelmts_xfer=%Hd" +", toxfer=%Hd, xferred=%Hd" +", file_offset=%Hd" +"\n", +(long_long)nelmts_toxfer, (long_long)nelmts_xfer, +(long_long)toxfer, (long_long)xferred, +(long_long)file_offset); +} + /* only care if seek returns error */ + rc = POSIXSEEK(fd->posixfd, file_offset) < 0 ? -1 : 0; + VRFY((rc==0), "POSIXSEEK"); + /* check if all bytes are transferred */ + rc = ((ssize_t)(toxfer*ELMT_SIZE) == + POSIXREAD(fd->posixfd, buf_p, toxfer*ELMT_SIZE)); + VRFY((rc != 0), "POSIXREAD"); + xferred += toxfer; + } + } break; case MPIO: - mpi_offset = dset_offset + (elmts_begin + nelmts_read)*ELMT_SIZE; + mpi_offset = dset_offset + (elmts_begin + nelmts_xfer)*ELMT_SIZE; mrc = MPI_File_read_at(fd->mpifd, mpi_offset, buffer, - (int)(nelmts_toread*ELMT_SIZE), MPI_CHAR, + (int)(nelmts_toxfer*ELMT_SIZE), MPI_CHAR, &mpi_status); VRFY((mrc==MPI_SUCCESS), "MPIO_read"); break; @@ -842,20 +1090,17 @@ do_read(results *res, file_descr *fd, parameters *parms, long ndsets, case PHDF5: /*set up the dset space id to select the segment to process */ { - hsize_t block[1], stride[1], count[1]; - hssize_t start[1]; - - start[0] = elmts_begin + nelmts_read; - stride[0] = block[0] = nelmts_toread; - count[0] = 1; + h5mem_start[0] = elmts_begin + nelmts_xfer; + h5mem_stride[0] = h5mem_block[0] = nelmts_toxfer; + h5mem_count[0] = 1; hrc = H5Sselect_hyperslab(h5dset_space_id, H5S_SELECT_SET, - start, stride, count, block); + h5mem_start, h5mem_stride, h5mem_count, h5mem_block); VRFY((hrc >= 0), "H5Sset_hyperslab"); /*setup the memory space id too. Only start is different */ - start[0] = 0; + h5mem_start[0] = 0; hrc = H5Sselect_hyperslab(h5mem_space_id, H5S_SELECT_SET, - start, stride, count, block); + h5mem_start, h5mem_stride, h5mem_count, h5mem_block); VRFY((hrc >= 0), "H5Sset_hyperslab"); } @@ -872,13 +1117,14 @@ do_read(results *res, file_descr *fd, parameters *parms, long ndsets, int *intptr = (int *)buffer; register int i; - for (i = 0; i < nelmts_towrite; ++i) + for (i = 0; i < nelmts_toxfer; ++i) /* TO BE IMPLEMENTED */ + #error "NOT IMPLEMENTED YET" ; } #endif - nelmts_read += nelmts_toread; + nelmts_xfer += nelmts_toxfer; } /* Stop "raw data" read timer */ @@ -1208,9 +1454,6 @@ stop_data_shipping(int handle) #endif /* H5_HAVE_GPFS */ -#ifndef TIME_MPI -#define TIME_MPI -#endif #ifdef TIME_MPI /* instrument the MPI_File_wrirte_xxx and read_xxx calls to measure * pure time spent in MPI_File code. |