#include "H5Dmodule.h" /* This source code file is part of the H5D module */

#include "H5private.h" /* Generic Functions */

#include "H5CXprivate.h" /* API Contexts */

#include "H5Dpkg.h" /* Dataset functions */

#include "H5Eprivate.h" /* Error handling */

#include "H5Fprivate.h" /* Files */

#include "H5FDprivate.h" /* File drivers */

#include "H5FLprivate.h" /* Free Lists */

#include "H5Iprivate.h" /* IDs */

#include "H5MFprivate.h" /* File memory management */

#include "H5MMprivate.h" /* Memory management */

#include "H5Oprivate.h" /* Object headers */

#include "H5PBprivate.h" /* Page Buffer */

#include "H5VMprivate.h" /* Vector and array functions */

typedef struct H5D_contig_readvv_sieve_ud_t {

} H5D_contig_readvv_sieve_ud_t;

typedef struct H5D_contig_readvv_ud_t {

} H5D_contig_readvv_ud_t;

typedef struct H5D_contig_writevv_sieve_ud_t {

} H5D_contig_writevv_sieve_ud_t;

typedef struct H5D_contig_writevv_ud_t {

} H5D_contig_writevv_ud_t;

static herr_t H5D__contig_construct(H5F_t *f, H5D_t *dset);

static herr_t H5D__contig_init(H5F_t *f, H5D_t *dset, hid_t dapl_id, bool open_op);

static herr_t H5D__contig_io_init(H5D_io_info_t *io_info, H5D_dset_io_info_t *dinfo);

static herr_t H5D__contig_mdio_init(H5D_io_info_t *io_info, H5D_dset_io_info_t *dinfo);

static ssize_t H5D__contig_readvv(const H5D_io_info_t *io_info, const H5D_dset_io_info_t *dinfo,

size_t dset_max_nseq, size_t *dset_curr_seq, size_t dset_len_arr[],

hsize_t dset_offset_arr[], size_t mem_max_nseq, size_t *mem_curr_seq,

size_t mem_len_arr[], hsize_t mem_offset_arr[]);

static ssize_t H5D__contig_writevv(const H5D_io_info_t *io_info, const H5D_dset_io_info_t *dinfo,

size_t dset_max_nseq, size_t *dset_curr_seq, size_t dset_len_arr[],

hsize_t dset_offset_arr[], size_t mem_max_nseq, size_t *mem_curr_seq,

size_t mem_len_arr[], hsize_t mem_offset_arr[]);

static herr_t H5D__contig_flush(H5D_t *dset);

static herr_t H5D__contig_io_term(H5D_io_info_t *io_info, H5D_dset_io_info_t *di);

static herr_t H5D__contig_write_one(H5D_io_info_t *io_info, H5D_dset_io_info_t *dset_info, hsize_t offset,

size_t size);

static herr_t H5D__contig_may_use_select_io(H5D_io_info_t *io_info, const H5D_dset_io_info_t *dset_info,

H5D_io_op_type_t op_type);

const H5D_layout_ops_t H5D_LOPS_CONTIG[1] = {{

H5D__contig_construct, /* construct */

H5D__contig_init, /* init */

H5D__contig_is_space_alloc, /* is_space_alloc */

H5D__contig_is_data_cached, /* is_data_cached */

H5D__contig_io_init, /* io_init */

H5D__contig_mdio_init, /* mdio_init */

H5D__contig_read, /* ser_read */

H5D__contig_write, /* ser_write */

H5D__contig_readvv, /* readvv */

H5D__contig_writevv, /* writevv */

H5D__contig_flush, /* flush */

H5D__contig_io_term, /* io_term */

NULL /* dest */

}};

H5FL_BLK_DEFINE(sieve_buf);

H5FL_BLK_EXTERN(type_conv);

H5FL_EXTERN(H5D_piece_info_t);

H5D__contig_alloc(H5F_t *f, H5O_storage_contig_t *storage /*out */)

{

herr_t ret_value = SUCCEED; /* Return value */

FUNC_ENTER_PACKAGE

/* check args */

assert(f);

assert(storage);

/* Allocate space for the contiguous data */

if (HADDR_UNDEF == (storage->addr = H5MF_alloc(f, H5FD_MEM_DRAW, storage->size)))

HGOTO_ERROR(H5E_IO, H5E_NOSPACE, FAIL, "unable to reserve file space");

done:

FUNC_LEAVE_NOAPI(ret_value)

} /* end H5D__contig_alloc */

H5D__contig_fill(H5D_t *dset)

{

H5D_io_info_t ioinfo; /* Dataset I/O info */

H5D_dset_io_info_t dset_info; /* Dset info */

H5D_storage_t store; /* Union of storage info for dataset */

hssize_t snpoints; /* Number of points in space (for error checking) */

size_t npoints; /* Number of points in space */

hsize_t offset; /* Offset of dataset */

size_t max_temp_buf; /* Maximum size of temporary buffer */

#ifdef H5_HAVE_PARALLEL

MPI_Comm mpi_comm = MPI_COMM_NULL; /* MPI communicator for file */

int mpi_rank = (-1); /* This process's rank */

int mpi_code; /* MPI return code */

bool blocks_written = false; /* Flag to indicate that chunk was actually written */

bool using_mpi =

false; /* Flag to indicate that the file is being accessed with an MPI-capable file driver */

#endif /* H5_HAVE_PARALLEL */

H5D_fill_buf_info_t fb_info; /* Dataset's fill buffer info */

bool fb_info_init = false; /* Whether the fill value buffer has been initialized */

herr_t ret_value = SUCCEED; /* Return value */

FUNC_ENTER_PACKAGE

/* Check args */

assert(dset && H5D_CONTIGUOUS == dset->shared->layout.type);

assert(H5_addr_defined(dset->shared->layout.storage.u.contig.addr));

assert(dset->shared->layout.storage.u.contig.size > 0);

assert(dset->shared->space);

assert(dset->shared->type);

#ifdef H5_HAVE_PARALLEL

/* Retrieve MPI parameters */

if (H5F_HAS_FEATURE(dset->oloc.file, H5FD_FEAT_HAS_MPI)) {

/* Get the MPI communicator */

if (MPI_COMM_NULL == (mpi_comm = H5F_mpi_get_comm(dset->oloc.file)))

HGOTO_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "Can't retrieve MPI communicator");

/* Get the MPI rank */

if ((mpi_rank = H5F_mpi_get_rank(dset->oloc.file)) < 0)

HGOTO_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "Can't retrieve MPI rank");

/* Set the MPI-capable file driver flag */

using_mpi = true;

} /* end if */

#endif /* H5_HAVE_PARALLEL */

/* Initialize storage info for this dataset */

store.contig.dset_addr = dset->shared->layout.storage.u.contig.addr;

store.contig.dset_size = dset->shared->layout.storage.u.contig.size;

/* Get the number of elements in the dataset's dataspace */

if ((snpoints = H5S_GET_EXTENT_NPOINTS(dset->shared->space)) < 0)

HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "dataset has negative number of elements");

H5_CHECKED_ASSIGN(npoints, size_t, snpoints, hssize_t);

/* Get the maximum size of temporary buffers */

if (H5CX_get_max_temp_buf(&max_temp_buf) < 0)

HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't retrieve max. temp. buf size");

/* Initialize the fill value buffer */

if (H5D__fill_init(&fb_info, NULL, NULL, NULL, NULL, NULL, &dset->shared->dcpl_cache.fill,

dset->shared->type, npoints, max_temp_buf) < 0)

HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "can't initialize fill buffer info");

fb_info_init = true;

/* Start at the beginning of the dataset */

offset = 0;

/* Simple setup for dataset I/O info struct */

ioinfo.op_type = H5D_IO_OP_WRITE;

dset_info.dset = (H5D_t *)dset;

dset_info.store = &store;

dset_info.buf.cvp = fb_info.fill_buf;

dset_info.mem_space = NULL;

ioinfo.dsets_info = &dset_info;

ioinfo.f_sh = H5F_SHARED(dset->oloc.file);

/*

/* Loop through writing the fill value to the dataset */

while (npoints > 0) {

size_t curr_points; /* Number of elements to write on this iteration of the loop */

size_t size; /* Size of buffer to write */

/* Compute # of elements and buffer size to write for this iteration */

curr_points = MIN(fb_info.elmts_per_buf, npoints);

size = curr_points * fb_info.file_elmt_size;

/* Check for VL datatype & non-default fill value */

if (fb_info.has_vlen_fill_type)

/* Re-fill the buffer to use for this I/O operation */

if (H5D__fill_refill_vl(&fb_info, curr_points) < 0)

HGOTO_ERROR(H5E_DATASET, H5E_CANTCONVERT, FAIL, "can't refill fill value buffer");

#ifdef H5_HAVE_PARALLEL

/* Check if this file is accessed with an MPI-capable file driver */

if (using_mpi) {

/* Write the chunks out from only one process */

/* !! Use the internal "independent" DXPL!! -QAK */

if (H5_PAR_META_WRITE == mpi_rank) {

if (H5D__contig_write_one(&ioinfo, &dset_info, offset, size) < 0) {

/* If writing fails, push an error and stop writing, but

blocks_written = true;

HDONE_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to write fill value to dataset");

break;

}

}

/* Indicate that blocks are being written */

blocks_written = true;

} /* end if */

else {

#endif /* H5_HAVE_PARALLEL */

H5_CHECK_OVERFLOW(size, size_t, hsize_t);

if (H5D__contig_write_one(&ioinfo, &dset_info, offset, size) < 0)

HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to write fill value to dataset");

#ifdef H5_HAVE_PARALLEL

} /* end else */

#endif /* H5_HAVE_PARALLEL */

npoints -= curr_points;

offset += size;

} /* end while */

#ifdef H5_HAVE_PARALLEL

/* Only need to block at the barrier if we actually wrote fill values */

/* And if we are using an MPI-capable file driver */

if (using_mpi && blocks_written) {

/* Wait at barrier to avoid race conditions where some processes are

if (MPI_SUCCESS != (mpi_code = MPI_Barrier(mpi_comm)))

HMPI_GOTO_ERROR(FAIL, "MPI_Barrier failed", mpi_code)

} /* end if */

#endif /* H5_HAVE_PARALLEL */

done:

/* Release the fill buffer info, if it's been initialized */

if (fb_info_init && H5D__fill_term(&fb_info) < 0)

HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release fill buffer info");

FUNC_LEAVE_NOAPI(ret_value)

} /* end H5D__contig_fill() */

H5D__contig_delete(H5F_t *f, const H5O_storage_t *storage)

{

herr_t ret_value = SUCCEED; /* Return value */

FUNC_ENTER_PACKAGE

/* check args */

assert(f);

assert(storage);

/* Free the file space for the chunk */

if (H5MF_xfree(f, H5FD_MEM_DRAW, storage->u.contig.addr, storage->u.contig.size) < 0)

HGOTO_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "unable to free contiguous storage space");

done:

FUNC_LEAVE_NOAPI(ret_value)

} /* end H5D__contig_delete */

H5D__contig_check(const H5F_t *f, const H5O_layout_t *layout, const H5S_extent_t *extent, const H5T_t *dt)

{

hsize_t nelmts; /* Number of elements in dataspace */

size_t dt_size; /* Size of datatype */

hsize_t data_size; /* Raw data size */

herr_t ret_value = SUCCEED; /* Return value */

FUNC_ENTER_PACKAGE

/* Sanity check */

assert(f);

assert(layout);

assert(extent);

assert(dt);

/* Retrieve the number of elements in the dataspace */

nelmts = H5S_extent_nelem(extent);

/* Get the datatype's size */

if (0 == (dt_size = H5T_GET_SIZE(dt)))

HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "unable to retrieve size of datatype");

/* Compute the size of the dataset's contiguous storage */

data_size = nelmts * dt_size;

/* Check for overflow during multiplication */

if (nelmts != (data_size / dt_size))

HGOTO_ERROR(H5E_DATASET, H5E_OVERFLOW, FAIL, "size of dataset's storage overflowed");

/* Check for invalid (corrupted in the file, probably) dimensions */

if (H5_addr_defined(layout->storage.u.contig.addr)) {

haddr_t rel_eoa; /* Relative end of file address */

if (HADDR_UNDEF == (rel_eoa = H5F_get_eoa(f, H5FD_MEM_DRAW)))

HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "unable to determine file size");

/* Check for invalid dataset size (from bad dimensions) putting the

if (H5_addr_le((layout->storage.u.contig.addr + data_size), layout->storage.u.contig.addr))

HGOTO_ERROR(H5E_DATASET, H5E_OVERFLOW, FAIL, "invalid dataset size, likely file corruption");

if (H5_addr_gt((layout->storage.u.contig.addr + data_size), rel_eoa))

HGOTO_ERROR(H5E_DATASET, H5E_OVERFLOW, FAIL, "invalid dataset size, likely file corruption");

}

done:

FUNC_LEAVE_NOAPI(ret_value)

} /* end H5D__contig_check() */

static herr_t

H5D__contig_construct(H5F_t *f, H5D_t *dset)

{

hssize_t snelmts; /* Temporary holder for number of elements in dataspace */

hsize_t nelmts; /* Number of elements in dataspace */

size_t dt_size; /* Size of datatype */

hsize_t tmp_size; /* Temporary holder for raw data size */

size_t tmp_sieve_buf_size; /* Temporary holder for sieve buffer size */

unsigned version; /* Message version */

unsigned u; /* Local index variable */

herr_t ret_value = SUCCEED; /* Return value */

FUNC_ENTER_PACKAGE

/* Sanity checks */

assert(f);

assert(dset);

assert(dset->shared);

/*

/* Check for invalid dataset dimensions */

for (u = 0; u < dset->shared->ndims; u++)

if (dset->shared->max_dims[u] > dset->shared->curr_dims[u])

HGOTO_ERROR(H5E_DATASET, H5E_UNSUPPORTED, FAIL,

"extendible contiguous non-external dataset not allowed");

/* Retrieve the number of elements in the dataspace */

if ((snelmts = H5S_GET_EXTENT_NPOINTS(dset->shared->space)) < 0)

HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "unable to retrieve number of elements in dataspace");

nelmts = (hsize_t)snelmts;

/* Get the datatype's size */

if (0 == (dt_size = H5T_GET_SIZE(dset->shared->type)))

HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "unable to retrieve size of datatype");

/* Compute the size of the dataset's contiguous storage */

tmp_size = nelmts * dt_size;

/* Check for overflow during multiplication */

if (nelmts != (tmp_size / dt_size))

HGOTO_ERROR(H5E_DATASET, H5E_OVERFLOW, FAIL, "size of dataset's storage overflowed");

/* Assign the dataset's contiguous storage size */

dset->shared->layout.storage.u.contig.size = tmp_size;

/* Get the sieve buffer size for the file */

tmp_sieve_buf_size = H5F_SIEVE_BUF_SIZE(f);

/* Adjust the sieve buffer size to the smaller one between the dataset size and the buffer size

if (tmp_size < tmp_sieve_buf_size)

dset->shared->cache.sieve.sieve_buf_size = tmp_size;

else

dset->shared->cache.sieve.sieve_buf_size = tmp_sieve_buf_size;

/* If the layout is below version 3, upgrade to version 3 if allowed. Do not upgrade past version 3 since

if (dset->shared->layout.version < H5O_LAYOUT_VERSION_3) {

version = MAX(dset->shared->layout.version,

MIN(H5O_layout_ver_bounds[H5F_LOW_BOUND(f)], H5O_LAYOUT_VERSION_3));

/* Version bounds check */

if (version > H5O_layout_ver_bounds[H5F_HIGH_BOUND(f)])

HGOTO_ERROR(H5E_DATASET, H5E_BADRANGE, FAIL, "layout version out of bounds");

dset->shared->layout.version = version;

}

done:

FUNC_LEAVE_NOAPI(ret_value)

} /* end H5D__contig_construct() */

static herr_t

H5D__contig_init(H5F_t *f, H5D_t *dset, hid_t H5_ATTR_UNUSED dapl_id, bool H5_ATTR_UNUSED open_op)

{

size_t tmp_sieve_buf_size; /* Temporary holder for sieve buffer size */

herr_t ret_value = SUCCEED; /* Return value */

FUNC_ENTER_PACKAGE

/* Sanity check */

assert(f);

assert(dset);

/* Sanity check the dataset's info */

if (H5D__contig_check(f, &dset->shared->layout, H5S_GET_EXTENT(dset->shared->space), dset->shared->type) <

0)

HGOTO_ERROR(H5E_DATASET, H5E_BADVALUE, FAIL, "invalid dataset info");

/* Compute the size of the contiguous storage for versions of the

if (dset->shared->layout.version < 3) {

hssize_t snelmts; /* Temporary holder for number of elements in dataspace */

hsize_t nelmts; /* Number of elements in dataspace */

size_t dt_size; /* Size of datatype */

/* Retrieve the number of elements in the dataspace */

if ((snelmts = H5S_GET_EXTENT_NPOINTS(dset->shared->space)) < 0)

HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "unable to retrieve number of elements in dataspace");

nelmts = (hsize_t)snelmts;

/* Get the datatype's size */

if (0 == (dt_size = H5T_GET_SIZE(dset->shared->type)))

HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "unable to retrieve size of datatype");

/* Compute the size of the dataset's contiguous storage */

dset->shared->layout.storage.u.contig.size = nelmts * dt_size;

}

/* Get the sieve buffer size for the file */

tmp_sieve_buf_size = H5F_SIEVE_BUF_SIZE(dset->oloc.file);

/* Adjust the sieve buffer size to the smaller one between the dataset size and the buffer size

if (dset->shared->layout.storage.u.contig.size < tmp_sieve_buf_size)

dset->shared->cache.sieve.sieve_buf_size = dset->shared->layout.storage.u.contig.size;

else

dset->shared->cache.sieve.sieve_buf_size = tmp_sieve_buf_size;

done:

FUNC_LEAVE_NOAPI(ret_value)

} /* end H5D__contig_init() */

H5D__contig_is_space_alloc(const H5O_storage_t *storage)

{

bool ret_value = false; /* Return value */

FUNC_ENTER_PACKAGE_NOERR

/* Sanity checks */

assert(storage);

/* Set return value */

ret_value = (bool)H5_addr_defined(storage->u.contig.addr);

FUNC_LEAVE_NOAPI(ret_value)

} /* end H5D__contig_is_space_alloc() */

H5D__contig_is_data_cached(const H5D_shared_t *shared_dset)

{

FUNC_ENTER_PACKAGE_NOERR

/* Sanity checks */

assert(shared_dset);

FUNC_LEAVE_NOAPI(shared_dset->cache.sieve.sieve_size > 0)

} /* end H5D__contig_is_data_cached() */

static herr_t

H5D__contig_io_init(H5D_io_info_t *io_info, H5D_dset_io_info_t *dinfo)

{

H5D_t *dataset = dinfo->dset; /* Local pointer to dataset info */

hssize_t old_offset[H5O_LAYOUT_NDIMS]; /* Old selection offset */

htri_t file_space_normalized = false; /* File dataspace was normalized */

int sf_ndims; /* The number of dimensions of the file dataspace (signed) */

herr_t ret_value = SUCCEED; /* Return value */

FUNC_ENTER_PACKAGE

dinfo->store->contig.dset_addr = dataset->shared->layout.storage.u.contig.addr;

dinfo->store->contig.dset_size = dataset->shared->layout.storage.u.contig.size;

/* Initialize piece info */

dinfo->layout_io_info.contig_piece_info = NULL;

/* Get layout for dataset */

dinfo->layout = &(dataset->shared->layout);

/* Get dim number and dimensionality for each dataspace */

if ((sf_ndims = H5S_GET_EXTENT_NDIMS(dinfo->file_space)) < 0)

HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "unable to get dimension number");

/* Normalize hyperslab selections by adjusting them by the offset */

/* (It might be worthwhile to normalize both the file and memory dataspaces

if ((file_space_normalized = H5S_hyper_normalize_offset(dinfo->file_space, old_offset)) < 0)

HGOTO_ERROR(H5E_DATASET, H5E_BADSELECT, FAIL, "unable to normalize dataspace by offset");

/* if selected elements exist */

if (dinfo->nelmts) {

int u;

H5D_piece_info_t *new_piece_info; /* piece information to insert into skip list */

/* Get copy of dset file_space, so it can be changed temporarily

H5S_t *tmp_fspace; /* Temporary file dataspace */

/* Create "temporary" chunk for selection operations (copy file space) */

if (NULL == (tmp_fspace = H5S_copy(dinfo->file_space, true, false)))

HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, FAIL, "unable to copy memory space");

/* Add temporary chunk to the list of pieces */

/* collect piece_info into Skip List */

/* Allocate the file & memory chunk information */

if (NULL == (new_piece_info = H5FL_MALLOC(H5D_piece_info_t))) {

(void)H5S_close(tmp_fspace);

HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate chunk info");

} /* end if */

/* Set the piece index */

new_piece_info->index = 0;

/* Set the file chunk dataspace */

new_piece_info->fspace = tmp_fspace;

new_piece_info->fspace_shared = false;

/* Set the memory chunk dataspace */

/* same as one chunk, just use dset mem space */

new_piece_info->mspace = dinfo->mem_space;

/* set true for sharing mem space with dset, which means

new_piece_info->mspace_shared = true;

/* Set the number of points */

new_piece_info->piece_points = dinfo->nelmts;

/* Copy the piece's coordinates */

for (u = 0; u < sf_ndims; u++)

new_piece_info->scaled[u] = 0;

new_piece_info->scaled[sf_ndims] = 0;

/* make connection to related dset info from this piece_info */

new_piece_info->dset_info = dinfo;

/* get dset file address for piece */

new_piece_info->faddr = dinfo->dset->shared->layout.storage.u.contig.addr;

/* Initialize in-place type conversion info. Start with it disabled. */

new_piece_info->in_place_tconv = false;

new_piece_info->buf_off = 0;

new_piece_info->filtered_dset = dinfo->dset->shared->dcpl_cache.pline.nused > 0;

/* Calculate type conversion buffer size and check for in-place conversion if necessary. Currently

if (io_info->use_select_io != H5D_SELECTION_IO_MODE_OFF &&

!(dinfo->type_info.is_xform_noop && dinfo->type_info.is_conv_noop))

H5D_INIT_PIECE_TCONV(io_info, dinfo, new_piece_info)

/* Save piece to dataset info struct so it is freed at the end of the

dinfo->layout_io_info.contig_piece_info = new_piece_info;

/* Add piece to piece_count */

io_info->piece_count++;

} /* end if */

/* Check if we're performing selection I/O if it hasn't been disabled

if (io_info->use_select_io != H5D_SELECTION_IO_MODE_OFF)

if (H5D__contig_may_use_select_io(io_info, dinfo, io_info->op_type) < 0)

HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't check if selection I/O is possible");

done:

if (ret_value < 0) {

if (H5D__contig_io_term(io_info, dinfo) < 0)

HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release dataset I/O info");

} /* end if */

if (file_space_normalized) {

/* (Casting away const OK -QAK) */

if (H5S_hyper_denormalize_offset(dinfo->file_space, old_offset) < 0)

HDONE_ERROR(H5E_DATASET, H5E_BADSELECT, FAIL, "unable to normalize dataspace by offset");

} /* end if */

FUNC_LEAVE_NOAPI(ret_value)

} /* end H5D__contig_io_init() */

static herr_t

H5D__contig_mdio_init(H5D_io_info_t *io_info, H5D_dset_io_info_t *dinfo)

{

FUNC_ENTER_PACKAGE_NOERR

/* Add piece if it exists */

if (dinfo->layout_io_info.contig_piece_info) {

assert(io_info->sel_pieces);

assert(io_info->pieces_added < io_info->piece_count);

/* Add contiguous data block to sel_pieces */

io_info->sel_pieces[io_info->pieces_added] = dinfo->layout_io_info.contig_piece_info;

/* Update pieces_added */

io_info->pieces_added++;

}

FUNC_LEAVE_NOAPI(SUCCEED)

} /* end H5D__contig_mdio_init() */

static herr_t

H5D__contig_may_use_select_io(H5D_io_info_t *io_info, const H5D_dset_io_info_t *dset_info,

H5D_io_op_type_t op_type)

{

const H5D_t *dataset = NULL; /* Local pointer to dataset info */

herr_t ret_value = SUCCEED; /* Return value */

FUNC_ENTER_PACKAGE

/* Sanity check */

assert(io_info);

assert(dset_info);

assert(dset_info->dset);

assert(op_type == H5D_IO_OP_READ || op_type == H5D_IO_OP_WRITE);

dataset = dset_info->dset;

/* None of the reasons this function might disable selection I/O are relevant to parallel, so no need to

/* Don't use selection I/O if it's globally disabled, if it's not a contiguous dataset, or if the sieve

if (dset_info->layout_ops.readvv != H5D__contig_readvv) {

io_info->use_select_io = H5D_SELECTION_IO_MODE_OFF;

io_info->no_selection_io_cause |= H5D_SEL_IO_NOT_CONTIGUOUS_OR_CHUNKED_DATASET;

}

else if ((op_type == H5D_IO_OP_READ && dataset->shared->cache.sieve.sieve_dirty) ||

(op_type == H5D_IO_OP_WRITE && dataset->shared->cache.sieve.sieve_buf)) {

io_info->use_select_io = H5D_SELECTION_IO_MODE_OFF;

io_info->no_selection_io_cause |= H5D_SEL_IO_CONTIGUOUS_SIEVE_BUFFER;

}

else {

bool page_buf_enabled;

assert(dset_info->layout_ops.writevv == H5D__contig_writevv);

/* Check if the page buffer is enabled */

if (H5PB_enabled(io_info->f_sh, H5FD_MEM_DRAW, &page_buf_enabled) < 0)

HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't check if page buffer is enabled");

if (page_buf_enabled) {

io_info->use_select_io = H5D_SELECTION_IO_MODE_OFF;

io_info->no_selection_io_cause |= H5D_SEL_IO_PAGE_BUFFER;

}

} /* end else */

done:

FUNC_LEAVE_NOAPI(ret_value)

} /* end H5D__contig_may_use_select_io() */

H5D__contig_read(H5D_io_info_t *io_info, H5D_dset_io_info_t *dinfo)

{

herr_t ret_value = SUCCEED; /* Return value */

FUNC_ENTER_PACKAGE

/* Sanity check */

assert(io_info);

assert(dinfo);

assert(dinfo->buf.vp);

assert(dinfo->mem_space);

assert(dinfo->file_space);

if (io_info->use_select_io == H5D_SELECTION_IO_MODE_ON) {

/* Only perform I/O if not performing multi dataset I/O or type conversion,

if (H5D_LAYOUT_CB_PERFORM_IO(io_info)) {

size_t dst_type_size = dinfo->type_info.dst_type_size;

/* Issue selection I/O call (we can skip the page buffer because we've

if (H5F_shared_select_read(H5F_SHARED(dinfo->dset->oloc.file), H5FD_MEM_DRAW,

dinfo->nelmts > 0 ? 1 : 0, &dinfo->mem_space, &dinfo->file_space,

&(dinfo->store->contig.dset_addr), &dst_type_size,

&(dinfo->buf.vp)) < 0)

HGOTO_ERROR(H5E_DATASET, H5E_READERROR, FAIL, "contiguous selection read failed");

}

else {

if (dinfo->layout_io_info.contig_piece_info) {

/* Add to mdset selection I/O arrays */

assert(io_info->mem_spaces);

assert(io_info->file_spaces);

assert(io_info->addrs);

assert(io_info->element_sizes);

assert(io_info->rbufs);

assert(io_info->pieces_added < io_info->piece_count);

io_info->mem_spaces[io_info->pieces_added] = dinfo->mem_space;

io_info->file_spaces[io_info->pieces_added] = dinfo->file_space;

io_info->addrs[io_info->pieces_added] = dinfo->store->contig.dset_addr;

io_info->element_sizes[io_info->pieces_added] = dinfo->type_info.src_type_size;

io_info->rbufs[io_info->pieces_added] = dinfo->buf.vp;

if (io_info->sel_pieces)

io_info->sel_pieces[io_info->pieces_added] = dinfo->layout_io_info.contig_piece_info;

io_info->pieces_added++;

}

}

#ifdef H5_HAVE_PARALLEL

/* Report that collective contiguous I/O was used */

io_info->actual_io_mode |= H5D_MPIO_CONTIGUOUS_COLLECTIVE;

#endif /* H5_HAVE_PARALLEL */

} /* end if */

else

/* Read data through legacy (non-selection I/O) pathway */

if ((dinfo->io_ops.single_read)(io_info, dinfo) < 0)

HGOTO_ERROR(H5E_DATASET, H5E_READERROR, FAIL, "contiguous read failed");

done:

FUNC_LEAVE_NOAPI(ret_value)

} /* end H5D__contig_read() */

H5D__contig_write(H5D_io_info_t *io_info, H5D_dset_io_info_t *dinfo)

{

herr_t ret_value = SUCCEED; /* Return value */

FUNC_ENTER_PACKAGE

/* Sanity check */

assert(io_info);

assert(dinfo);

assert(dinfo->buf.cvp);

assert(dinfo->mem_space);

assert(dinfo->file_space);

if (io_info->use_select_io == H5D_SELECTION_IO_MODE_ON) {

/* Only perform I/O if not performing multi dataset I/O or type conversion,

if (H5D_LAYOUT_CB_PERFORM_IO(io_info)) {

size_t dst_type_size = dinfo->type_info.dst_type_size;

/* Issue selection I/O call (we can skip the page buffer because we've

if (H5F_shared_select_write(H5F_SHARED(dinfo->dset->oloc.file), H5FD_MEM_DRAW,

dinfo->nelmts > 0 ? 1 : 0, &dinfo->mem_space, &dinfo->file_space,

&(dinfo->store->contig.dset_addr), &dst_type_size,

&(dinfo->buf.cvp)) < 0)

HGOTO_ERROR(H5E_DATASET, H5E_WRITEERROR, FAIL, "contiguous selection write failed");

}

else {

if (dinfo->layout_io_info.contig_piece_info) {

/* Add to mdset selection I/O arrays */

assert(io_info->mem_spaces);

assert(io_info->file_spaces);

assert(io_info->addrs);

assert(io_info->element_sizes);

assert(io_info->wbufs);

assert(io_info->pieces_added < io_info->piece_count);

io_info->mem_spaces[io_info->pieces_added] = dinfo->mem_space;

io_info->file_spaces[io_info->pieces_added] = dinfo->file_space;

io_info->addrs[io_info->pieces_added] = dinfo->store->contig.dset_addr;

io_info->element_sizes[io_info->pieces_added] = dinfo->type_info.dst_type_size;

io_info->wbufs[io_info->pieces_added] = dinfo->buf.cvp;

if (io_info->sel_pieces)

io_info->sel_pieces[io_info->pieces_added] = dinfo->layout_io_info.contig_piece_info;

io_info->pieces_added++;

}

}

#ifdef H5_HAVE_PARALLEL

/* Report that collective contiguous I/O was used */

io_info->actual_io_mode |= H5D_MPIO_CONTIGUOUS_COLLECTIVE;

#endif /* H5_HAVE_PARALLEL */

} /* end if */

else

/* Write data through legacy (non-selection I/O) pathway */

if ((dinfo->io_ops.single_write)(io_info, dinfo) < 0)

HGOTO_ERROR(H5E_DATASET, H5E_WRITEERROR, FAIL, "contiguous write failed");

done:

FUNC_LEAVE_NOAPI(ret_value)

} /* end H5D__contig_write() */