int MPIO_Err_return_file(MPI_File mpi_fh, int error_code)
{
MPI_Errhandler e;
void (*c_errhandler) (MPI_File *, int *, ...);
int kind; /* Error handler kind (see below) */
char error_msg[4096];
int len;
/* If the file pointer is not valid, we use the handler on
* MPI_FILE_NULL (MPI-2, section 9.7). For now, this code assumes that
* MPI_FILE_NULL has the default handler (return). FIXME. See
* below - the set error handler uses ADIOI_DFLT_ERR_HANDLER;
*/
/* First, get the handler and the corresponding function */
if (mpi_fh == MPI_FILE_NULL) {
e = ADIOI_DFLT_ERR_HANDLER;
} else {
ADIO_File fh;
fh = MPIO_File_resolve(mpi_fh);
e = fh->err_handler;
}
/* Actually, e is just the value provide by the MPICH routines
* file_set_errhandler. This is actually a *pointer* to the
* errhandler structure. We don't know that, so we ask
* the MPICH code to translate this object into an error handler.
* kind = 0: errors are fatal
* kind = 1: errors return
* kind = 2: errors call function
*/
if (e == MPI_ERRORS_RETURN || e == MPIR_ERRORS_THROW_EXCEPTIONS || !e) {
/* FIXME: This is a hack in case no error handler was set */
kind = 1;
c_errhandler = 0;
} else {
MPIR_Get_file_error_routine(e, &c_errhandler, &kind);
}
/* --BEGIN ERROR HANDLING-- */
if (MPIR_Err_is_fatal(error_code) || kind == 0) {
ADIO_File fh = MPIO_File_resolve(mpi_fh);
MPL_snprintf(error_msg, 4096, "I/O error: ");
len = (int) strlen(error_msg);
MPIR_Err_get_string(error_code, &error_msg[len], 4096 - len, NULL);
MPIR_Abort(fh->comm, MPI_SUCCESS, error_code, error_msg);
}
/* --END ERROR HANDLING-- */
else if (kind == 2) {
(*c_errhandler) (&mpi_fh, &error_code, 0);
} else if (kind == 3) {
MPIR_File_call_cxx_errhandler(&mpi_fh, &error_code, c_errhandler);
}
/* kind == 1 just returns */
return error_code;
}
/*@
MPI_File_set_info - Sets new values for the hints associated with a file
Input Parameters:
. fh - file handle (handle)
. info - info object (handle)
.N fortran
@*/
int MPI_File_set_info(MPI_File mpi_fh, MPI_Info info)
{
int error_code;
static char myname[] = "MPI_FILE_SET_INFO";
ADIO_File fh;
MPIU_THREAD_SINGLE_CS_ENTER("io");
MPIR_Nest_incr();
fh = MPIO_File_resolve(mpi_fh);
/* --BEGIN ERROR HANDLING-- */
MPIO_CHECK_FILE_HANDLE(fh, myname, error_code);
/* --END ERROR HANDLING-- */
/* set new info */
ADIO_SetInfo(fh, info, &error_code);
/* TODO: what to do with error code? */
/* --BEGIN ERROR HANDLING-- */
if (error_code != MPI_SUCCESS)
error_code = MPIO_Err_return_file(fh, error_code);
/* --END ERROR HANDLING-- */
fn_exit:
MPIR_Nest_decr();
MPIU_THREAD_SINGLE_CS_EXIT("io");
return error_code;
}
/*@
MPI_File_get_byte_offset - Returns the absolute byte position in
the file corresponding to "offset" etypes relative to
the current view
Input Parameters:
. fh - file handle (handle)
. offset - offset (nonnegative integer)
Output Parameters:
. disp - absolute byte position of offset (nonnegative integer)
.N fortran
@*/
int MPI_File_get_byte_offset(MPI_File fh, MPI_Offset offset, MPI_Offset *disp)
{
int error_code;
ADIO_File adio_fh;
static char myname[] = "MPI_FILE_GET_BYTE_OFFSET";
adio_fh = MPIO_File_resolve(fh);
/* --BEGIN ERROR HANDLING-- */
MPIO_CHECK_FILE_HANDLE(adio_fh, myname, error_code);
if (offset < 0)
{
error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_ARG,
"**iobadoffset", 0);
error_code = MPIO_Err_return_file(adio_fh, error_code);
goto fn_exit;
}
MPIO_CHECK_NOT_SEQUENTIAL_MODE(adio_fh, myname, error_code);
/* --END ERROR HANDLING-- */
ADIOI_Get_byte_offset(adio_fh, offset, disp);
fn_exit:
return MPI_SUCCESS;
}
/*@
MPI_File_get_errhandler - Returns the error handler for a file
Input Parameters:
. fh - file handle (handle)
Output Parameters:
. errhandler - error handler (handle)
.N fortran
@*/
int MPI_File_get_errhandler(MPI_File mpi_fh, MPI_Errhandler *errhandler)
{
int error_code = MPI_SUCCESS;
ADIO_File fh;
static char myname[] = "MPI_FILE_GET_ERRHANDLER";
MPID_THREADPRIV_DECL;
if (mpi_fh == MPI_FILE_NULL) {
*errhandler = ADIOI_DFLT_ERR_HANDLER;
}
else {
fh = MPIO_File_resolve(mpi_fh);
/* --BEGIN ERROR HANDLING-- */
if ((fh <= (MPI_File) 0) || ((fh)->cookie != ADIOI_FILE_COOKIE))
{
error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_ARG,
"**iobadfh", 0);
error_code = MPIO_Err_return_file(MPI_FILE_NULL, error_code);
goto fn_exit;
}
/* --END ERROR HANDLING-- */
*errhandler = fh->err_handler;
}
fn_exit:
return MPI_SUCCESS;
}
/*@
MPI_File_get_position_shared - Returns the current position of the
shared file pointer in etype units relative to the current view
Input Parameters:
. fh - file handle (handle)
Output Parameters:
. offset - offset of shared file pointer (nonnegative integer)
.N fortran
@*/
int MPI_File_get_position_shared(MPI_File fh, MPI_Offset *offset)
{
int error_code;
ADIO_File adio_fh;
static char myname[] = "MPI_FILE_GET_POSITION_SHARED";
adio_fh = MPIO_File_resolve(fh);
/* --BEGIN ERROR HANDLING-- */
MPIO_CHECK_FILE_HANDLE(adio_fh, myname, error_code);
MPIO_CHECK_NOT_SEQUENTIAL_MODE(adio_fh, myname, error_code);
MPIO_CHECK_FS_SUPPORTS_SHARED(adio_fh, myname, error_code);
/* --END ERROR HANDLING-- */
ADIOI_TEST_DEFERRED(adio_fh, myname, &error_code);
ADIO_Get_shared_fp(adio_fh, 0, offset, &error_code);
/* --BEGIN ERROR HANDLING-- */
if (error_code != MPI_SUCCESS)
error_code = MPIO_Err_return_file(adio_fh, error_code);
/* --END ERROR HANDLING-- */
fn_exit:
return error_code;
}
int MPI_File_iwrite_at(MPI_File mpi_fh, MPI_Offset offset, void *buf,
int count, MPI_Datatype datatype,
MPIO_Request *request)
{
int error_code;
ADIO_File fh;
static char myname[] = "MPI_FILE_IWRITE_AT";
#ifdef MPI_hpux
int fl_xmpi;
HPMP_IO_START(fl_xmpi, BLKMPIFILEIWRITEAT, TRDTSYSTEM,
mpi_fh, datatype, count);
#endif /* MPI_hpux */
fh = MPIO_File_resolve(mpi_fh);
error_code = MPIOI_File_iwrite(fh, offset, ADIO_EXPLICIT_OFFSET, buf,
count, datatype, myname, request);
/* --BEGIN ERROR HANDLING-- */
if (error_code != MPI_SUCCESS)
error_code = MPIO_Err_return_file(fh, error_code);
/* --END ERROR HANDLING-- */
#ifdef MPI_hpux
HPMP_IO_END(fl_xmpi, mpi_fh, datatype, count)
#endif /* MPI_hpux */
return error_code;
}
/*@
MPI_File_get_group - Returns the group of processes that
opened the file
Input Parameters:
. fh - file handle (handle)
Output Parameters:
. group - group that opened the file (handle)
.N fortran
@*/
int MPI_File_get_group(MPI_File mpi_fh, MPI_Group *group)
{
int error_code;
ADIO_File fh;
static char myname[] = "MPI_FILE_GET_GROUP";
MPID_CS_ENTER();
MPIR_Nest_incr();
fh = MPIO_File_resolve(mpi_fh);
/* --BEGIN ERROR HANDLING-- */
MPIO_CHECK_FILE_HANDLE(fh, myname, error_code);
/* --END ERROR HANDLING-- */
/* note: this will return the group of processes that called open, but
* with deferred open this might not be the group of processes that
* actually opened the file from the file system's perspective
*/
error_code = MPI_Comm_group(fh->comm, group);
fn_exit:
MPIR_Nest_decr();
MPID_CS_EXIT();
return error_code;
}
int MPIO_Err_return_file(MPI_File mpi_fh, int error_code)
{
ADIO_File adio_fh;
if (mpi_fh == MPI_FILE_NULL)
{
if (ADIOI_DFLT_ERR_HANDLER == MPI_ERRORS_ARE_FATAL ||
ADIOI_DFLT_ERR_HANDLER != MPI_ERRORS_RETURN)
{
MPI_Abort(MPI_COMM_WORLD, 1);
}
else
{
return error_code;
}
}
adio_fh = MPIO_File_resolve(mpi_fh);
if (adio_fh->err_handler == MPI_ERRORS_ARE_FATAL ||
adio_fh->err_handler != MPI_ERRORS_RETURN)
{
MPI_Abort(MPI_COMM_WORLD, 1);
}
else
{
return error_code;
}
}
/*@
MPI_File_set_info - Sets new values for the hints associated with a file
Input Parameters:
. fh - file handle (handle)
. info - info object (handle)
.N fortran
@*/
int MPI_File_set_info(MPI_File fh, MPI_Info info)
{
int error_code;
static char myname[] = "MPI_FILE_SET_INFO";
ADIO_File adio_fh;
MPIU_THREAD_CS_ENTER(ALLFUNC,);
adio_fh = MPIO_File_resolve(fh);
/* --BEGIN ERROR HANDLING-- */
MPIO_CHECK_FILE_HANDLE(adio_fh, myname, error_code);
/* --END ERROR HANDLING-- */
/* set new info */
ADIO_SetInfo(adio_fh, info, &error_code);
fn_exit:
/* --BEGIN ERROR HANDLING-- */
if (error_code != MPI_SUCCESS)
error_code = MPIO_Err_return_file(adio_fh, error_code);
/* --END ERROR HANDLING-- */
MPIU_THREAD_CS_EXIT(ALLFUNC,);
return error_code;
}
int MPIOI_File_read_all_end(MPI_File fh,
void *buf,
char *myname,
MPI_Status *status)
{
int error_code = MPI_SUCCESS;
ADIO_File adio_fh;
MPIU_UNREFERENCED_ARG(buf);
adio_fh = MPIO_File_resolve(fh);
/* --BEGIN ERROR HANDLING-- */
MPIO_CHECK_FILE_HANDLE(adio_fh, myname, error_code);
if (!(adio_fh->split_coll_count)) {
error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**iosplitcollnone", 0);
error_code = MPIO_Err_return_file(adio_fh, error_code);
goto fn_exit;
}
/* --END ERROR HANDLING-- */
#ifdef HAVE_STATUS_SET_BYTES
if (status != MPI_STATUS_IGNORE)
*status = adio_fh->split_status;
#endif
adio_fh->split_coll_count = 0;
fn_exit:
return error_code;
}
/*@
MPI_File_set_size - Sets the file size
Input Parameters:
. fh - file handle (handle)
. size - size to truncate or expand file (nonnegative integer)
.N fortran
@*/
int MPI_File_set_size(MPI_File mpi_fh, MPI_Offset size)
{
int error_code;
ADIO_File fh;
static char myname[] = "MPI_FILE_SET_SIZE";
MPI_Offset tmp_sz;
#ifdef MPI_hpux
int fl_xmpi;
HPMP_IO_START(fl_xmpi, BLKMPIFILESETSIZE, TRDTBLOCK, fh,
MPI_DATATYPE_NULL, -1);
#endif /* MPI_hpux */
MPID_CS_ENTER();
MPIR_Nest_incr();
fh = MPIO_File_resolve(mpi_fh);
/* --BEGIN ERROR HANDLING-- */
MPIO_CHECK_FILE_HANDLE(fh, myname, error_code);
if (size < 0) {
error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_ARG,
"**iobadsize", 0);
error_code = MPIO_Err_return_file(fh, error_code);
goto fn_exit;
}
/* --END ERROR HANDLING-- */
tmp_sz = size;
MPI_Bcast(&tmp_sz, 1, ADIO_OFFSET, 0, fh->comm);
/* --BEGIN ERROR HANDLING-- */
if (tmp_sz != size) {
error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_ARG,
"**notsame", 0);
error_code = MPIO_Err_return_file(fh, error_code);
goto fn_exit;
}
/* --END ERROR HANDLING-- */
ADIOI_TEST_DEFERRED(fh, "MPI_File_set_size", &error_code);
ADIO_Resize(fh, size, &error_code);
/* TODO: what to do with error code? */
#ifdef MPI_hpux
HPMP_IO_END(fl_xmpi, fh, MPI_DATATYPE_NULL, -1);
#endif /* MPI_hpux */
fn_exit:
MPIR_Nest_decr();
MPID_CS_EXIT();
return error_code;
}
/*@
MPI_File_get_view - Returns the file view
Input Parameters:
. fh - file handle (handle)
Output Parameters:
. disp - displacement (nonnegative integer)
. etype - elementary datatype (handle)
. filetype - filetype (handle)
. datarep - data representation (string)
.N fortran
@*/
int MPI_File_get_view(MPI_File fh, MPI_Offset * disp, MPI_Datatype * etype,
MPI_Datatype * filetype, char *datarep)
{
int error_code;
ADIO_File adio_fh;
static char myname[] = "MPI_FILE_GET_VIEW";
int i, j, k, combiner;
MPI_Datatype copy_etype, copy_filetype;
ROMIO_THREAD_CS_ENTER();
adio_fh = MPIO_File_resolve(fh);
/* --BEGIN ERROR HANDLING-- */
MPIO_CHECK_FILE_HANDLE(adio_fh, myname, error_code);
if (datarep == NULL) {
error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_ARG, "**iodatarepnomem", 0);
error_code = MPIO_Err_return_file(adio_fh, error_code);
goto fn_exit;
}
/* --END ERROR HANDLING-- */
*disp = adio_fh->disp;
ADIOI_Strncpy(datarep,
(adio_fh->is_external32 ? "external32" : "native"), MPI_MAX_DATAREP_STRING);
MPI_Type_get_envelope(adio_fh->etype, &i, &j, &k, &combiner);
if (combiner == MPI_COMBINER_NAMED)
*etype = adio_fh->etype;
else {
/* FIXME: It is wrong to use MPI_Type_contiguous; the user could choose to
* re-implement MPI_Type_contiguous in an unexpected way. Either use
* MPID_Barrier as in MPICH or PMPI_Type_contiguous */
MPI_Type_contiguous(1, adio_fh->etype, ©_etype);
/* FIXME: Ditto for MPI_Type_commit - use NMPI or PMPI */
MPI_Type_commit(©_etype);
*etype = copy_etype;
}
/* FIXME: Ditto for MPI_Type_xxx - use NMPI or PMPI */
MPI_Type_get_envelope(adio_fh->filetype, &i, &j, &k, &combiner);
if (combiner == MPI_COMBINER_NAMED)
*filetype = adio_fh->filetype;
else {
MPI_Type_contiguous(1, adio_fh->filetype, ©_filetype);
MPI_Type_commit(©_filetype);
*filetype = copy_filetype;
}
fn_exit:
ROMIO_THREAD_CS_EXIT();
return MPI_SUCCESS;
}
int MPIOI_File_read_all_begin(MPI_File mpi_fh,
MPI_Offset offset,
int file_ptr_type,
void *buf,
int count,
MPI_Datatype datatype,
char *myname)
{
int error_code, datatype_size;
ADIO_File fh;
MPID_CS_ENTER();
MPIR_Nest_incr();
fh = MPIO_File_resolve(mpi_fh);
/* --BEGIN ERROR HANDLING-- */
MPIO_CHECK_FILE_HANDLE(fh, myname, error_code);
MPIO_CHECK_COUNT(fh, count, myname, error_code);
MPIO_CHECK_DATATYPE(fh, datatype, myname, error_code);
if (file_ptr_type == ADIO_EXPLICIT_OFFSET && offset < 0)
{
error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_ARG,
"**iobadoffset", 0);
error_code = MPIO_Err_return_file(fh, error_code);
goto fn_exit;
}
/* --END ERROR HANDLING-- */
MPI_Type_size(datatype, &datatype_size);
/* --BEGIN ERROR HANDLING-- */
MPIO_CHECK_INTEGRAL_ETYPE(fh, count, datatype_size, myname, error_code);
MPIO_CHECK_READABLE(fh, myname, error_code);
MPIO_CHECK_NOT_SEQUENTIAL_MODE(fh, myname, error_code);
if (fh->split_coll_count) {
error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**iosplitcoll", 0);
error_code = MPIO_Err_return_file(fh, error_code);
goto fn_exit;
}
/* --END ERROR HANDLING-- */
fh->split_coll_count = 1;
ADIO_ReadStridedColl(fh, buf, count, datatype, file_ptr_type,
offset, &fh->split_status, &error_code);
fn_exit:
MPIR_Nest_decr();
MPID_CS_EXIT();
return error_code;
}
/*@
MPI_File_set_atomicity - Sets the atomicity mode
Input Parameters:
. fh - file handle (handle)
. flag - true to set atomic mode, false to set nonatomic mode (logical)
.N fortran
@*/
int MPI_File_set_atomicity(MPI_File fh, int flag)
{
int error_code, tmp_flag;
static char myname[] = "MPI_FILE_SET_ATOMICITY";
ADIO_Fcntl_t *fcntl_struct;
ADIO_File adio_fh;
MPIU_THREAD_CS_ENTER(ALLFUNC,);
adio_fh = MPIO_File_resolve(fh);
/* --BEGIN ERROR HANDLING-- */
MPIO_CHECK_FILE_HANDLE(adio_fh, myname, error_code);
/* --END ERROR HANDLING-- */
ADIOI_TEST_DEFERRED(adio_fh, myname, &error_code);
if (flag) flag = 1; /* take care of non-one values! */
/* check if flag is the same on all processes */
tmp_flag = flag;
MPI_Bcast(&tmp_flag, 1, MPI_INT, 0, adio_fh->comm);
/* --BEGIN ERROR HANDLING-- */
if (tmp_flag != flag) {
error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_ARG,
"**notsame", 0);
error_code = MPIO_Err_return_file(adio_fh, error_code);
goto fn_exit;
}
/* --END ERROR HANDLING-- */
if (adio_fh->atomicity == flag){
error_code = MPI_SUCCESS;
goto fn_exit;
}
fcntl_struct = (ADIO_Fcntl_t *) ADIOI_Malloc(sizeof(ADIO_Fcntl_t));
fcntl_struct->atomicity = flag;
ADIO_Fcntl(adio_fh, ADIO_FCNTL_SET_ATOMICITY, fcntl_struct, &error_code);
/* TODO: what do we do with this error code? */
/* --BEGIN ERROR HANDLING-- */
if (error_code != MPI_SUCCESS)
error_code = MPIO_Err_return_file(adio_fh, error_code);
/* --END ERROR HANDLING-- */
ADIOI_Free(fcntl_struct);
fn_exit:
MPIU_THREAD_CS_EXIT(ALLFUNC,);
return error_code;
}
int MPIOI_File_write_all_end(MPI_File mpi_fh,
void *buf,
char *myname,
MPI_Status *status)
{
int error_code;
ADIO_File fh;
MPIU_UNREFERENCED_ARG(buf);
MPIU_THREAD_CS_ENTER(ALLFUNC,);
fh = MPIO_File_resolve(mpi_fh);
/* --BEGIN ERROR HANDLING-- */
MPIO_CHECK_FILE_HANDLE(fh, myname, error_code);
if (!(fh->split_coll_count))
{
error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**iosplitcollnone", 0);
error_code = MPIO_Err_return_file(fh, error_code);
goto fn_exit;
}
/* --END ERROR HANDLING-- */
#ifdef HAVE_STATUS_SET_BYTES
/* FIXME - we should really ensure that the split_datatype remains
valid by incrementing the ref count in the write_allb.c routine
and decrement it here after setting the bytes */
if (status != MPI_STATUS_IGNORE)
*status = fh->split_status;
#endif
fh->split_coll_count = 0;
error_code = MPI_SUCCESS;
fn_exit:
MPIU_THREAD_CS_EXIT(ALLFUNC,);
return error_code;
}
/*@
MPI_File_get_type_extent - Returns the extent of datatype in the file
Input Parameters:
. fh - file handle (handle)
. datatype - datatype (handle)
Output Parameters:
. extent - extent of the datatype (nonnegative integer)
.N fortran
@*/
int MPI_File_get_type_extent(MPI_File mpi_fh, MPI_Datatype datatype,
MPI_Aint *extent)
{
int error_code;
ADIO_File fh;
static char myname[] = "MPI_FILE_GET_TYPE_EXTENT";
fh = MPIO_File_resolve(mpi_fh);
/* --BEGIN ERROR HANDLING-- */
MPIO_CHECK_FILE_HANDLE(fh, myname, error_code);
MPIO_CHECK_DATATYPE(fh, datatype, myname, error_code);
/* --END ERROR HANDLING-- */
/* FIXME: handle other file data representations */
error_code = MPI_Type_extent(datatype, extent);
fn_exit:
return error_code;
}
/*@
MPI_File_sync - Causes all previous writes to be transferred
to the storage device
Input Parameters:
. fh - file handle (handle)
.N fortran
@*/
int MPI_File_sync(MPI_File fh)
{
int error_code;
ADIO_File adio_fh;
static char myname[] = "MPI_FILE_SYNC";
#ifdef MPI_hpux
int fl_xmpi;
HPMP_IO_START(fl_xmpi, BLKMPIFILESYNC, TRDTBLOCK, adio_fh,
MPI_DATATYPE_NULL, -1);
#endif /* MPI_hpux */
MPIU_THREAD_CS_ENTER(ALLFUNC,);
adio_fh = MPIO_File_resolve(fh);
/* --BEGIN ERROR HANDLING-- */
if ((adio_fh <= (MPI_File) 0) || ((adio_fh)->cookie != ADIOI_FILE_COOKIE))
{
error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_ARG,
"**iobadfh", 0);
error_code = MPIO_Err_return_file(MPI_FILE_NULL, error_code);
goto fn_exit;
}
MPIO_CHECK_WRITABLE(fh, myname, error_code);
/* --END ERROR HANDLING-- */
ADIO_Flush(adio_fh, &error_code);
/* --BEGIN ERROR HANDLING-- */
if (error_code != MPI_SUCCESS)
error_code = MPIO_Err_return_file(adio_fh, error_code);
/* --END ERROR HANDLING-- */
#ifdef MPI_hpux
HPMP_IO_END(fl_xmpi, adio_fh, MPI_DATATYPE_NULL, -1);
#endif /* MPI_hpux */
fn_exit:
MPIU_THREAD_CS_EXIT(ALLFUNC,);
return error_code;
}
/*@
MPI_File_get_position - Returns the current position of the
individual file pointer in etype units relative to
the current view
Input Parameters:
. fh - file handle (handle)
Output Parameters:
. offset - offset of individual file pointer (nonnegative integer)
.N fortran
@*/
int MPI_File_get_position(MPI_File mpi_fh, MPI_Offset *offset)
{
int error_code;
ADIO_File fh;
static char myname[] = "MPI_FILE_GET_POSITION";
MPIR_Nest_incr();
fh = MPIO_File_resolve(mpi_fh);
/* --BEGIN ERROR HANDLING-- */
MPIO_CHECK_FILE_HANDLE(fh, myname, error_code);
MPIO_CHECK_NOT_SEQUENTIAL_MODE(fh, myname, error_code);
/* --END ERROR HANDLING-- */
ADIOI_Get_position(fh, offset);
fn_exit:
MPIR_Nest_decr();
return MPI_SUCCESS;
}
int MPIOI_File_read_all_end(MPI_File mpi_fh,
void *buf,
char *myname,
MPI_Status *status)
{
int error_code;
ADIO_File fh;
MPIU_UNREFERENCED_ARG(buf);
MPIU_THREAD_SINGLE_CS_ENTER("io");
MPIR_Nest_incr();
fh = MPIO_File_resolve(mpi_fh);
/* --BEGIN ERROR HANDLING-- */
MPIO_CHECK_FILE_HANDLE(fh, myname, error_code);
if (!(fh->split_coll_count)) {
error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**iosplitcollnone", 0);
error_code = MPIO_Err_return_file(fh, error_code);
goto fn_exit;
}
/* --END ERROR HANDLING-- */
#ifdef HAVE_STATUS_SET_BYTES
if (status != MPI_STATUS_IGNORE)
*status = fh->split_status;
#endif
fh->split_coll_count = 0;
fn_exit:
MPIR_Nest_decr();
MPIU_THREAD_SINGLE_CS_EXIT("io");
return MPI_SUCCESS;
}
/*@
MPI_File_get_info - Returns the hints for a file that are actually being used by MPI
Input Parameters:
. fh - file handle (handle)
Output Parameters:
. info_used - info object (handle)
.N fortran
@*/
int MPI_File_get_info(MPI_File fh, MPI_Info *info_used)
{
int error_code;
ADIO_File adio_fh;
static char myname[] = "MPI_FILE_GET_INFO";
ROMIO_THREAD_CS_ENTER();
adio_fh = MPIO_File_resolve(fh);
/* --BEGIN ERROR HANDLING-- */
MPIO_CHECK_FILE_HANDLE(adio_fh, myname, error_code);
/* --END ERROR HANDLING-- */
error_code = MPI_Info_dup(adio_fh->info, info_used);
/* --BEGIN ERROR HANDLING-- */
if (error_code != MPI_SUCCESS)
error_code = MPIO_Err_return_file(adio_fh, error_code);
/* --END ERROR HANDLING-- */
fn_exit:
ROMIO_THREAD_CS_EXIT();
return error_code;
}
/*@
MPI_File_write_ordered_end - Complete a split collective write using shared file pointer
Input Parameters:
. fh - file handle (handle)
Output Parameters:
. buf - initial address of buffer (choice)
. status - status object (Status)
.N fortran
@*/
int MPI_File_write_ordered_end(MPI_File fh, ROMIO_CONST void *buf, MPI_Status *status)
{
int error_code;
static char myname[] = "MPI_FILE_WRITE_ORDERED_END";
ADIO_File adio_fh;
MPIU_UNREFERENCED_ARG(buf);
ROMIO_THREAD_CS_ENTER();
adio_fh = MPIO_File_resolve(fh);
/* --BEGIN ERROR HANDLING-- */
MPIO_CHECK_FILE_HANDLE(adio_fh, myname, error_code);
if (!(adio_fh->split_coll_count))
{
error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**iosplitcollnone", 0);
error_code = MPIO_Err_return_file(adio_fh, error_code);
goto fn_exit;
}
/* --END ERROR HANDLING-- */
#ifdef HAVE_STATUS_SET_BYTES
if (status != MPI_STATUS_IGNORE)
*status = adio_fh->split_status;
#endif
adio_fh->split_coll_count = 0;
fn_exit:
ROMIO_THREAD_CS_EXIT();
return MPI_SUCCESS;
}
int MPIOI_File_write_all(MPI_File fh,
MPI_Offset offset,
int file_ptr_type,
const void *buf,
int count,
MPI_Datatype datatype,
char *myname,
MPI_Status *status)
{
int error_code;
MPI_Count datatype_size;
ADIO_File adio_fh;
void *e32buf=NULL;
const void *xbuf=NULL;
MPIU_THREAD_CS_ENTER(ALLFUNC,);
adio_fh = MPIO_File_resolve(fh);
/* --BEGIN ERROR HANDLING-- */
MPIO_CHECK_FILE_HANDLE(adio_fh, myname, error_code);
MPIO_CHECK_COUNT(adio_fh, count, myname, error_code);
MPIO_CHECK_DATATYPE(adio_fh, datatype, myname, error_code);
if (file_ptr_type == ADIO_EXPLICIT_OFFSET && offset < 0)
{
error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_ARG,
"**iobadoffset", 0);
error_code = MPIO_Err_return_file(adio_fh, error_code);
goto fn_exit;
}
/* --END ERROR HANDLING-- */
MPI_Type_size_x(datatype, &datatype_size);
/* --BEGIN ERROR HANDLING-- */
MPIO_CHECK_INTEGRAL_ETYPE(adio_fh, count, datatype_size, myname, error_code);
MPIO_CHECK_WRITABLE(adio_fh, myname, error_code);
MPIO_CHECK_NOT_SEQUENTIAL_MODE(adio_fh, myname, error_code);
MPIO_CHECK_COUNT_SIZE(adio_fh, count, datatype_size, myname, error_code);
/* --END ERROR HANDLING-- */
xbuf = buf;
if (adio_fh->is_external32) {
error_code = MPIU_external32_buffer_setup(buf, count, datatype, &e32buf);
if (error_code != MPI_SUCCESS)
goto fn_exit;
xbuf = e32buf;
}
ADIO_WriteStridedColl(adio_fh, xbuf, count, datatype, file_ptr_type,
offset, status, &error_code);
/* --BEGIN ERROR HANDLING-- */
if (error_code != MPI_SUCCESS)
error_code = MPIO_Err_return_file(adio_fh, error_code);
/* --END ERROR HANDLING-- */
fn_exit:
if (e32buf != NULL) ADIOI_Free(e32buf);
MPIU_THREAD_CS_EXIT(ALLFUNC,);
return error_code;
}
/*@
MPI_File_set_view - Sets the file view
Input Parameters:
. fh - file handle (handle)
. disp - displacement (nonnegative integer)
. etype - elementary datatype (handle)
. filetype - filetype (handle)
. datarep - data representation (string)
. info - info object (handle)
.N fortran
@*/
int MPI_File_set_view(MPI_File mpi_fh, MPI_Offset disp, MPI_Datatype etype,
MPI_Datatype filetype, char *datarep, MPI_Info info)
{
int filetype_size, etype_size, error_code;
static char myname[] = "MPI_FILE_SET_VIEW";
ADIO_Offset shared_fp, byte_off;
ADIO_File fh;
MPIU_THREAD_SINGLE_CS_ENTER("io");
MPIR_Nest_incr();
fh = MPIO_File_resolve(mpi_fh);
/* --BEGIN ERROR HANDLING-- */
MPIO_CHECK_FILE_HANDLE(fh, myname, error_code);
if ((disp < 0) && (disp != MPI_DISPLACEMENT_CURRENT))
{
error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_ARG,
"**iobaddisp", 0);
error_code = MPIO_Err_return_file(fh, error_code);
goto fn_exit;
}
/* rudimentary checks for incorrect etype/filetype.*/
if (etype == MPI_DATATYPE_NULL) {
error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_ARG,
"**ioetype", 0);
error_code = MPIO_Err_return_file(fh, error_code);
goto fn_exit;
}
if (filetype == MPI_DATATYPE_NULL) {
error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_ARG,
"**iofiletype", 0);
error_code = MPIO_Err_return_file(fh, error_code);
goto fn_exit;
}
if ((fh->access_mode & MPI_MODE_SEQUENTIAL) &&
(disp != MPI_DISPLACEMENT_CURRENT))
{
error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_ARG,
"**iodispifseq", 0);
error_code = MPIO_Err_return_file(fh, error_code);
goto fn_exit;
}
if ((disp == MPI_DISPLACEMENT_CURRENT) &&
!(fh->access_mode & MPI_MODE_SEQUENTIAL))
{
error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_ARG,
"**iodispifseq", 0);
error_code = MPIO_Err_return_file(fh, error_code);
goto fn_exit;
}
/* --END ERROR HANDLING-- */
MPI_Type_size(filetype, &filetype_size);
MPI_Type_size(etype, &etype_size);
/* --BEGIN ERROR HANDLING-- */
if (filetype_size % etype_size != 0)
{
error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_ARG,
"**iofiletype", 0);
error_code = MPIO_Err_return_file(fh, error_code);
goto fn_exit;
}
if (strcmp(datarep, "native") && strcmp(datarep, "NATIVE"))
{
error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__,
MPI_ERR_UNSUPPORTED_DATAREP,
"**unsupporteddatarep",0);
error_code = MPIO_Err_return_file(fh, error_code);
goto fn_exit;
}
/* --END ERROR HANDLING-- */
if (disp == MPI_DISPLACEMENT_CURRENT) {
MPI_Barrier(fh->comm);
ADIO_Get_shared_fp(fh, 0, &shared_fp, &error_code);
/* TODO: check error code */
MPI_Barrier(fh->comm);
ADIOI_Get_byte_offset(fh, shared_fp, &byte_off);
/* TODO: check error code */
disp = byte_off;
}
ADIO_Set_view(fh, disp, etype, filetype, info, &error_code);
/* --BEGIN ERROR HANDLING-- */
if (error_code != MPI_SUCCESS) {
error_code = MPIO_Err_return_file(fh, error_code);
goto fn_exit;
}
/* --END ERROR HANDLING-- */
/* reset shared file pointer to zero */
if ((fh->file_system != ADIO_PIOFS) &&
(fh->file_system != ADIO_PVFS) &&
(fh->file_system != ADIO_PVFS2) &&
(fh->shared_fp_fd != ADIO_FILE_NULL))
{
/* only one process needs to set it to zero, but I don't want to
create the shared-file-pointer file if shared file pointers have
not been used so far. Therefore, every process that has already
opened the shared-file-pointer file sets the shared file pointer
to zero. If the file was not opened, the value is automatically
zero. Note that shared file pointer is stored as no. of etypes
relative to the current view, whereas indiv. file pointer is
stored in bytes. */
ADIO_Set_shared_fp(fh, 0, &error_code);
/* --BEGIN ERROR HANDLING-- */
if (error_code != MPI_SUCCESS)
error_code = MPIO_Err_return_file(fh, error_code);
/* --END ERROR HANDLING-- */
}
if ((fh->file_system != ADIO_PIOFS) &&
(fh->file_system != ADIO_PVFS) &&
(fh->file_system != ADIO_PVFS2 ))
{
MPI_Barrier(fh->comm); /* for above to work correctly */
}
fn_exit:
MPIR_Nest_decr();
MPIU_THREAD_SINGLE_CS_EXIT("io");
return error_code;
}
/*@
MPI_File_close - Closes a file
Input Parameters:
. fh - file handle (handle)
.N fortran
@*/
int MPI_File_close(MPI_File *fh)
{
int error_code;
ADIO_File adio_fh;
static char myname[] = "MPI_FILE_CLOSE";
#ifdef MPI_hpux
int fl_xmpi;
HPMP_IO_WSTART(fl_xmpi, BLKMPIFILECLOSE, TRDTBLOCK, *adio_fh);
#endif /* MPI_hpux */
MPIU_THREAD_CS_ENTER(ALLFUNC,);
adio_fh = MPIO_File_resolve(*fh);
/* --BEGIN ERROR HANDLING-- */
MPIO_CHECK_FILE_HANDLE(adio_fh, myname, error_code);
/* --END ERROR HANDLING-- */
if (ADIO_Feature(adio_fh, ADIO_SHARED_FP))
{
ADIOI_Free((adio_fh)->shared_fp_fname);
/* POSIX semantics say a deleted file remains available until all
* processes close the file. But since when was NFS posix-compliant?
*/
if (!ADIO_Feature(adio_fh, ADIO_UNLINK_AFTER_CLOSE)) {
MPI_Barrier((adio_fh)->comm);
}
if ((adio_fh)->shared_fp_fd != ADIO_FILE_NULL) {
MPI_File *fh_shared = &(adio_fh->shared_fp_fd);
ADIO_Close((adio_fh)->shared_fp_fd, &error_code);
MPIO_File_free(fh_shared);
/* --BEGIN ERROR HANDLING-- */
if (error_code != MPI_SUCCESS) goto fn_fail;
/* --END ERROR HANDLING-- */
}
}
/* Because ROMIO expects the MPI library to provide error handler management
* routines but it doesn't ever participate in MPI_File_close, we have to
* somehow inform the MPI library that we no longer hold a reference to any
* user defined error handler. We do this by setting the errhandler at this
* point to MPI_ERRORS_RETURN. */
error_code = PMPI_File_set_errhandler(*fh, MPI_ERRORS_RETURN);
if (error_code != MPI_SUCCESS) goto fn_fail;
ADIO_Close(adio_fh, &error_code);
MPIO_File_free(fh);
/* --BEGIN ERROR HANDLING-- */
if (error_code != MPI_SUCCESS) goto fn_fail;
/* --END ERROR HANDLING-- */
#ifdef MPI_hpux
HPMP_IO_WEND(fl_xmpi);
#endif /* MPI_hpux */
fn_exit:
MPIU_THREAD_CS_EXIT(ALLFUNC,);
return error_code;
fn_fail:
/* --BEGIN ERROR HANDLING-- */
error_code = MPIO_Err_return_file(adio_fh, error_code);
goto fn_exit;
/* --END ERROR HANDLING-- */
}
/*@
MPI_File_get_view - Returns the file view
Input Parameters:
. fh - file handle (handle)
Output Parameters:
. disp - displacement (nonnegative integer)
. etype - elementary datatype (handle)
. filetype - filetype (handle)
. datarep - data representation (string)
.N fortran
@*/
int MPI_File_get_view(MPI_File mpi_fh,
MPI_Offset *disp,
MPI_Datatype *etype,
MPI_Datatype *filetype,
char *datarep)
{
int error_code;
ADIO_File fh;
static char myname[] = "MPI_FILE_GET_VIEW";
int i, j, k, combiner;
MPI_Datatype copy_etype, copy_filetype;
MPID_CS_ENTER();
MPIR_Nest_incr();
fh = MPIO_File_resolve(mpi_fh);
/* --BEGIN ERROR HANDLING-- */
MPIO_CHECK_FILE_HANDLE(fh, myname, error_code);
if (datarep <= (char *) 0)
{
error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_ARG,
"**iodatarepnomem", 0);
error_code = MPIO_Err_return_file(fh, error_code);
goto fn_exit;
}
/* --END ERROR HANDLING-- */
*disp = fh->disp;
strcpy(datarep, "native");
MPI_Type_get_envelope(fh->etype, &i, &j, &k, &combiner);
if (combiner == MPI_COMBINER_NAMED) *etype = fh->etype;
else {
MPIR_Nest_incr();
MPI_Type_contiguous(1, fh->etype, ©_etype);
MPIR_Nest_decr();
MPIR_Nest_incr();
MPI_Type_commit(©_etype);
MPIR_Nest_decr();
*etype = copy_etype;
}
MPI_Type_get_envelope(fh->filetype, &i, &j, &k, &combiner);
if (combiner == MPI_COMBINER_NAMED) *filetype = fh->filetype;
else {
MPI_Type_contiguous(1, fh->filetype, ©_filetype);
MPI_Type_commit(©_filetype);
*filetype = copy_filetype;
}
fn_exit:
MPIR_Nest_decr();
MPID_CS_EXIT();
return MPI_SUCCESS;
}
/*@
MPI_File_write_ordered - Collective write using shared file pointer
Input Parameters:
. fh - file handle (handle)
. buf - initial address of buffer (choice)
. count - number of elements in buffer (nonnegative integer)
. datatype - datatype of each buffer element (handle)
Output Parameters:
. status - status object (Status)
.N fortran
@*/
int MPI_File_write_ordered(MPI_File fh, ROMIO_CONST void *buf, int count,
MPI_Datatype datatype, MPI_Status *status)
{
int error_code, nprocs, myrank;
ADIO_Offset incr;
MPI_Count datatype_size;
int source, dest;
static char myname[] = "MPI_FILE_WRITE_ORDERED";
ADIO_Offset shared_fp;
ADIO_File adio_fh;
void *e32buf=NULL;
const void *xbuf;
adio_fh = MPIO_File_resolve(fh);
/* --BEGIN ERROR HANDLING-- */
MPIO_CHECK_FILE_HANDLE(adio_fh, myname, error_code);
MPIO_CHECK_COUNT(adio_fh, count, myname, error_code);
MPIO_CHECK_DATATYPE(adio_fh, datatype, myname, error_code);
/* --END ERROR HANDLING-- */
MPI_Type_size_x(datatype, &datatype_size);
/* --BEGIN ERROR HANDLING-- */
MPIO_CHECK_INTEGRAL_ETYPE(adio_fh, count, datatype_size, myname, error_code);
MPIO_CHECK_FS_SUPPORTS_SHARED(adio_fh, myname, error_code);
MPIO_CHECK_COUNT_SIZE(adio_fh, count, datatype_size, myname, error_code);
/* --END ERROR HANDLING-- */
ADIOI_TEST_DEFERRED(adio_fh, myname, &error_code);
MPI_Comm_size(adio_fh->comm, &nprocs);
MPI_Comm_rank(adio_fh->comm, &myrank);
incr = (count*datatype_size)/adio_fh->etype_size;
/* Use a message as a 'token' to order the operations */
source = myrank - 1;
dest = myrank + 1;
if (source < 0) source = MPI_PROC_NULL;
if (dest >= nprocs) dest = MPI_PROC_NULL;
MPI_Recv(NULL, 0, MPI_BYTE, source, 0, adio_fh->comm, MPI_STATUS_IGNORE);
ADIO_Get_shared_fp(adio_fh, incr, &shared_fp, &error_code);
/* --BEGIN ERROR HANDLING-- */
if (error_code != MPI_SUCCESS) {
error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_FATAL,
myname, __LINE__, MPI_ERR_INTERN,
"**iosharedfailed", 0);
error_code = MPIO_Err_return_file(adio_fh, error_code);
goto fn_exit;
}
/* --END ERROR HANDLING-- */
MPI_Send(NULL, 0, MPI_BYTE, dest, 0, adio_fh->comm);
xbuf = buf;
if (adio_fh->is_external32) {
error_code = MPIU_external32_buffer_setup(buf, count, datatype, &e32buf);
if (error_code != MPI_SUCCESS)
goto fn_exit;
xbuf = e32buf;
}
ADIO_WriteStridedColl(adio_fh, xbuf, count, datatype, ADIO_EXPLICIT_OFFSET,
shared_fp, status, &error_code);
/* --BEGIN ERROR HANDLING-- */
if (error_code != MPI_SUCCESS)
error_code = MPIO_Err_return_file(adio_fh, error_code);
/* --END ERROR HANDLING-- */
fn_exit:
if (e32buf != NULL) ADIOI_Free(e32buf);
/* FIXME: Check for error code from WriteStridedColl? */
return error_code;
}
/*@
MPI_File_read_ordered_begin - Begin a split collective read using shared file pointer
Input Parameters:
. fh - file handle (handle)
. count - number of elements in buffer (nonnegative integer)
. datatype - datatype of each buffer element (handle)
Output Parameters:
. buf - initial address of buffer (choice)
.N fortran
@*/
int MPI_File_read_ordered_begin(MPI_File fh, void *buf, int count,
MPI_Datatype datatype)
{
int error_code, datatype_size, nprocs, myrank, incr;
int source, dest;
ADIO_Offset shared_fp;
ADIO_File adio_fh;
static char myname[] = "MPI_FILE_READ_ORDERED_BEGIN";
void *xbuf=NULL, *e32_buf=NULL;
MPIU_THREAD_CS_ENTER(ALLFUNC,);
adio_fh = MPIO_File_resolve(fh);
/* --BEGIN ERROR HANDLING-- */
MPIO_CHECK_FILE_HANDLE(adio_fh, myname, error_code);
MPIO_CHECK_COUNT(adio_fh, count, myname, error_code);
MPIO_CHECK_DATATYPE(adio_fh, datatype, myname, error_code);
if (adio_fh->split_coll_count)
{
error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**iosplitcoll", 0);
error_code = MPIO_Err_return_file(adio_fh, error_code);
goto fn_exit;
}
/* --END ERROR HANDLING-- */
adio_fh->split_coll_count = 1;
MPI_Type_size(datatype, &datatype_size);
/* --BEGIN ERROR HANDLING-- */
MPIO_CHECK_INTEGRAL_ETYPE(adio_fh, count, datatype_size, myname, error_code);
MPIO_CHECK_FS_SUPPORTS_SHARED(adio_fh, myname, error_code);
MPIO_CHECK_COUNT_SIZE(adio_fh, count, datatype_size, myname, error_code);
/* --END ERROR HANDLING-- */
ADIOI_TEST_DEFERRED(adio_fh, myname, &error_code);
MPI_Comm_size(adio_fh->comm, &nprocs);
MPI_Comm_rank(adio_fh->comm, &myrank);
incr = (count*datatype_size)/adio_fh->etype_size;
/* Use a message as a 'token' to order the operations */
source = myrank - 1;
dest = myrank + 1;
if (source < 0) source = MPI_PROC_NULL;
if (dest >= nprocs) dest = MPI_PROC_NULL;
MPI_Recv(NULL, 0, MPI_BYTE, source, 0, adio_fh->comm, MPI_STATUS_IGNORE);
ADIO_Get_shared_fp(adio_fh, incr, &shared_fp, &error_code);
/* --BEGIN ERROR HANDLING-- */
if (error_code != MPI_SUCCESS)
{
error_code = MPIO_Err_return_file(adio_fh, error_code);
goto fn_exit;
}
/* --END ERROR HANDLING-- */
MPI_Send(NULL, 0, MPI_BYTE, dest, 0, adio_fh->comm);
xbuf = buf;
if (adio_fh->is_external32)
{
error_code = MPIU_datatype_full_size(datatype, &datatype_size);
if (error_code != MPI_SUCCESS)
goto fn_exit;
e32_buf = ADIOI_Malloc(datatype_size*count);
xbuf = e32_buf;
}
ADIO_ReadStridedColl(adio_fh, xbuf, count, datatype, ADIO_EXPLICIT_OFFSET,
shared_fp, &adio_fh->split_status, &error_code);
/* --BEGIN ERROR HANDLING-- */
if (error_code != MPI_SUCCESS)
error_code = MPIO_Err_return_file(adio_fh, error_code);
/* --END ERROR HANDLING-- */
if (e32_buf != NULL) {
error_code = MPIU_read_external32_conversion_fn(xbuf, datatype,
count, e32_buf);
ADIOI_Free(e32_buf);
}
fn_exit:
MPIU_THREAD_CS_EXIT(ALLFUNC,);
return error_code;
}
int MPIOI_File_iread_all(MPI_File fh,
MPI_Offset offset,
int file_ptr_type,
void *buf,
int count,
MPI_Datatype datatype,
char *myname,
MPI_Request *request)
{
int error_code;
MPI_Count datatype_size;
ADIO_File adio_fh;
void *xbuf=NULL, *e32_buf=NULL;
ROMIO_THREAD_CS_ENTER();
adio_fh = MPIO_File_resolve(fh);
/* --BEGIN ERROR HANDLING-- */
MPIO_CHECK_FILE_HANDLE(adio_fh, myname, error_code);
MPIO_CHECK_COUNT(adio_fh, count, myname, error_code);
MPIO_CHECK_DATATYPE(adio_fh, datatype, myname, error_code);
if (file_ptr_type == ADIO_EXPLICIT_OFFSET && offset < 0) {
error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_ARG,
"**iobadoffset", 0);
error_code = MPIO_Err_return_file(adio_fh, error_code);
goto fn_exit;
}
/* --END ERROR HANDLING-- */
MPI_Type_size_x(datatype, &datatype_size);
/* --BEGIN ERROR HANDLING-- */
MPIO_CHECK_INTEGRAL_ETYPE(adio_fh, count, datatype_size, myname, error_code);
MPIO_CHECK_READABLE(adio_fh, myname, error_code);
MPIO_CHECK_NOT_SEQUENTIAL_MODE(adio_fh, myname, error_code);
MPIO_CHECK_COUNT_SIZE(adio_fh, count, datatype_size, myname, error_code);
/* --END ERROR HANDLING-- */
xbuf = buf;
if (adio_fh->is_external32) {
MPI_Aint e32_size = 0;
error_code = MPIU_datatype_full_size(datatype, &e32_size);
if (error_code != MPI_SUCCESS)
goto fn_exit;
e32_buf = ADIOI_Malloc(e32_size*count);
xbuf = e32_buf;
}
ADIO_IreadStridedColl(adio_fh, xbuf, count, datatype, file_ptr_type,
offset, request, &error_code);
/* --BEGIN ERROR HANDLING-- */
if (error_code != MPI_SUCCESS)
error_code = MPIO_Err_return_file(adio_fh, error_code);
/* --END ERROR HANDLING-- */
if (e32_buf != NULL) {
error_code = MPIU_read_external32_conversion_fn(buf, datatype,
count, e32_buf);
ADIOI_Free(e32_buf);
}
fn_exit:
ROMIO_THREAD_CS_EXIT();
return error_code;
}
int MPIOI_File_iwrite(MPI_File mpi_fh,
MPI_Offset offset,
int file_ptr_type,
void *buf,
int count,
MPI_Datatype datatype,
char *myname,
MPI_Request *request)
{
int error_code, bufsize, buftype_is_contig, filetype_is_contig;
int datatype_size;
ADIO_Status status;
ADIO_Offset off;
ADIO_File fh;
MPI_Offset nbytes=0;
fh = MPIO_File_resolve(mpi_fh);
/* --BEGIN ERROR HANDLING-- */
MPIO_CHECK_FILE_HANDLE(fh, myname, error_code);
MPIO_CHECK_COUNT(fh, count, myname, error_code);
MPIO_CHECK_DATATYPE(fh, datatype, myname, error_code);
if (file_ptr_type == ADIO_EXPLICIT_OFFSET && offset < 0) {
error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_ARG,
"**iobadoffset", 0);
error_code = MPIO_Err_return_file(fh, error_code);
goto fn_exit;
}
/* --END ERROR HANDLING-- */
MPI_Type_size(datatype, &datatype_size);
/* --BEGIN ERROR HANDLING-- */
MPIO_CHECK_INTEGRAL_ETYPE(fh, count, datatype_size, myname, error_code);
MPIO_CHECK_WRITABLE(fh, myname, error_code);
MPIO_CHECK_NOT_SEQUENTIAL_MODE(fh, myname, error_code);
MPIO_CHECK_COUNT_SIZE(fh, count, datatype_size, myname, error_code);
/* --END ERROR HANDLING-- */
ADIOI_Datatype_iscontig(datatype, &buftype_is_contig);
ADIOI_Datatype_iscontig(fh->filetype, &filetype_is_contig);
ADIOI_TEST_DEFERRED(fh, myname, &error_code);
if (buftype_is_contig && filetype_is_contig) {
/* convert sizes to bytes */
bufsize = datatype_size * count;
if (file_ptr_type == ADIO_EXPLICIT_OFFSET) {
off = fh->disp + fh->etype_size * offset;
}
else {
off = fh->fp_ind;
}
if (!(fh->atomicity)) {
ADIO_IwriteContig(fh, buf, count, datatype, file_ptr_type,
off, request, &error_code);
}
else {
/* to maintain strict atomicity semantics with other concurrent
operations, lock (exclusive) and call blocking routine */
if (ADIO_Feature(fh, ADIO_LOCKS) )
{
ADIOI_WRITE_LOCK(fh, off, SEEK_SET, bufsize);
}
ADIO_WriteContig(fh, buf, count, datatype, file_ptr_type, off,
&status, &error_code);
if (ADIO_Feature(fh, ADIO_LOCKS) )
{
ADIOI_UNLOCK(fh, off, SEEK_SET, bufsize);
}
if (error_code == MPI_SUCCESS) {
nbytes = count * datatype_size;
}
MPIO_Completed_request_create(&fh, nbytes, &error_code, request);
}
}
else {
ADIO_IwriteStrided(fh, buf, count, datatype, file_ptr_type,
offset, request, &error_code);
}
fn_exit:
return error_code;
}
/*@
MPI_File_iread_shared - Nonblocking read using shared file pointer
Input Parameters:
. fh - file handle (handle)
. count - number of elements in buffer (nonnegative integer)
. datatype - datatype of each buffer element (handle)
Output Parameters:
. buf - initial address of buffer (choice)
. request - request object (handle)
.N fortran
@*/
int MPI_File_iread_shared(MPI_File fh, void *buf, int count,
MPI_Datatype datatype, MPI_Request *request)
{
int error_code, buftype_is_contig, filetype_is_contig;
ADIO_Offset bufsize;
ADIO_File adio_fh;
static char myname[] = "MPI_FILE_IREAD_SHARED";
MPI_Count datatype_size, incr;
MPI_Status status;
ADIO_Offset off, shared_fp;
MPI_Offset nbytes=0;
MPIU_THREAD_CS_ENTER(ALLFUNC,);
adio_fh = MPIO_File_resolve(fh);
/* --BEGIN ERROR HANDLING-- */
MPIO_CHECK_FILE_HANDLE(adio_fh, myname, error_code);
MPIO_CHECK_COUNT(adio_fh, count, myname, error_code);
MPIO_CHECK_DATATYPE(adio_fh, datatype, myname, error_code);
/* --END ERROR HANDLING-- */
MPI_Type_size_x(datatype, &datatype_size);
/* --BEGIN ERROR HANDLING-- */
MPIO_CHECK_INTEGRAL_ETYPE(adio_fh, count, datatype_size, myname, error_code);
MPIO_CHECK_FS_SUPPORTS_SHARED(adio_fh, myname, error_code);
MPIO_CHECK_COUNT_SIZE(adio_fh, count, datatype_size, myname, error_code);
/* --END ERROR HANDLING-- */
ADIOI_Datatype_iscontig(datatype, &buftype_is_contig);
ADIOI_Datatype_iscontig(adio_fh->filetype, &filetype_is_contig);
ADIOI_TEST_DEFERRED(adio_fh, myname, &error_code);
incr = (count*datatype_size)/adio_fh->etype_size;
ADIO_Get_shared_fp(adio_fh, incr, &shared_fp, &error_code);
/* --BEGIN ERROR HANDLING-- */
if (error_code != MPI_SUCCESS)
{
/* note: ADIO_Get_shared_fp should have set up error code already? */
MPIO_Err_return_file(adio_fh, error_code);
}
/* --END ERROR HANDLING-- */
if (buftype_is_contig && filetype_is_contig)
{
/* convert count and shared_fp to bytes */
bufsize = datatype_size * count;
off = adio_fh->disp + adio_fh->etype_size * shared_fp;
if (!(adio_fh->atomicity))
{
ADIO_IreadContig(adio_fh, buf, count, datatype, ADIO_EXPLICIT_OFFSET,
off, request, &error_code);
}
else
{
/* to maintain strict atomicity semantics with other concurrent
operations, lock (exclusive) and call blocking routine */
if (adio_fh->file_system != ADIO_NFS)
{
ADIOI_WRITE_LOCK(adio_fh, off, SEEK_SET, bufsize);
}
ADIO_ReadContig(adio_fh, buf, count, datatype, ADIO_EXPLICIT_OFFSET,
off, &status, &error_code);
if (adio_fh->file_system != ADIO_NFS)
{
ADIOI_UNLOCK(adio_fh, off, SEEK_SET, bufsize);
}
if (error_code == MPI_SUCCESS){
nbytes = count * datatype_size;
}
MPIO_Completed_request_create(&adio_fh, nbytes, &error_code, request);
}
}
else
{
ADIO_IreadStrided(adio_fh, buf, count, datatype, ADIO_EXPLICIT_OFFSET,
shared_fp, request, &error_code);
}
/* --BEGIN ERROR HANDLING-- */
if (error_code != MPI_SUCCESS)
error_code = MPIO_Err_return_file(adio_fh, error_code);
/* --END ERROR HANDLING-- */
fn_exit:
MPIU_THREAD_CS_EXIT(ALLFUNC,);
return error_code;
}