From e6fead13289e9e791e08c2cf162dffa6bf25bbeb Mon Sep 17 00:00:00 2001 From: Weikuan Yu Date: Sat, 24 Jul 2004 17:06:21 +0000 Subject: [PATCH] a) Commit romio wrapper functions b) Temorarily created a set of Makefile.am files to compile the module, for UFS and NFS support. c) The final goal is to integrate romio configure scripts into Open MPI configuration system without repeating the configuration operations and compilation hooks already provided in romio. d) Added a dummy file src/romioconf.h for the time being. Eventually it is to be generated from the the template adio/include/romioconf.h.in e) To test this with nightly builds and mpi_io test suite. This commit was SVN r1797. --- src/mca/io/romio/Makefile.am | 2 +- src/mca/io/romio/configure.params | 2 +- src/mca/io/romio/romio-dist/Makefile.am | 26 + src/mca/io/romio/romio-dist/adio/Makefile.am | 24 + .../romio/romio-dist/adio/ad_nfs/Makefile.am | 21 + .../romio/romio-dist/adio/ad_ufs/Makefile.am | 20 + .../romio/romio-dist/adio/common/Makefile.am | 23 + .../io/romio/romio-dist/include/Makefile.am | 9 + .../io/romio/romio-dist/mpi-io/Makefile.am | 38 ++ src/mca/io/romio/src/Makefile.am | 16 +- src/mca/io/romio/src/file_open.c | 486 ++++++++++++++++++ src/mca/io/romio/src/file_read.c | 404 +++++++++++++++ src/mca/io/romio/src/file_request.c | 57 ++ src/mca/io/romio/src/file_write.c | 390 ++++++++++++++ src/mca/io/romio/src/io_romio.h | 270 ++++++++++ src/mca/io/romio/src/io_romio_conv.h | 132 +++++ src/mca/io/romio/src/io_romio_global.c | 82 +++ src/mca/io/romio/src/io_romio_module.c | 68 +++ src/mca/io/romio/src/romioconf.h | 0 19 files changed, 2067 insertions(+), 3 deletions(-) create mode 100644 src/mca/io/romio/romio-dist/Makefile.am create mode 100644 src/mca/io/romio/romio-dist/adio/Makefile.am create mode 100644 src/mca/io/romio/romio-dist/adio/ad_nfs/Makefile.am create mode 100644 src/mca/io/romio/romio-dist/adio/ad_ufs/Makefile.am create mode 100644 src/mca/io/romio/romio-dist/adio/common/Makefile.am create mode 100644 src/mca/io/romio/romio-dist/include/Makefile.am create mode 100644 src/mca/io/romio/romio-dist/mpi-io/Makefile.am create mode 100644 src/mca/io/romio/src/file_open.c create mode 100644 src/mca/io/romio/src/file_read.c create mode 100644 src/mca/io/romio/src/file_request.c create mode 100644 src/mca/io/romio/src/file_write.c create mode 100644 src/mca/io/romio/src/io_romio.h create mode 100644 src/mca/io/romio/src/io_romio_conv.h create mode 100644 src/mca/io/romio/src/io_romio_global.c create mode 100644 src/mca/io/romio/src/io_romio_module.c create mode 100644 src/mca/io/romio/src/romioconf.h diff --git a/src/mca/io/romio/Makefile.am b/src/mca/io/romio/Makefile.am index fbea7a087e..ea3779d363 100644 --- a/src/mca/io/romio/Makefile.am +++ b/src/mca/io/romio/Makefile.am @@ -6,7 +6,7 @@ include $(top_ompi_srcdir)/config/Makefile.options -SUBDIRS = src +SUBDIRS = src romio-dist EXTRA_DIST = VERSION diff --git a/src/mca/io/romio/configure.params b/src/mca/io/romio/configure.params index 20af7fd52c..17ea07acb2 100644 --- a/src/mca/io/romio/configure.params +++ b/src/mca/io/romio/configure.params @@ -7,4 +7,4 @@ PARAM_INIT_FILE=src/io_romio_module.c PARAM_CONFIG_HEADER_FILE="src/romio_config.h" -PARAM_CONFIG_FILES="Makefile src/Makefile" +PARAM_CONFIG_FILES="Makefile src/Makefile romio-dist/Makefile romio-dist/include/Makefile romio-dist/adio/Makefile romio-dist/adio/common/Makefile romio-dist/adio/ad_ufs/Makefile romio-dist/adio/ad_nfs/Makefile romio-dist/mpi-io/Makefile" diff --git a/src/mca/io/romio/romio-dist/Makefile.am b/src/mca/io/romio/romio-dist/Makefile.am new file mode 100644 index 0000000000..4e5097a8ec --- /dev/null +++ b/src/mca/io/romio/romio-dist/Makefile.am @@ -0,0 +1,26 @@ +# +# $HEADER$ +# + +include $(top_srcdir)/config/Makefile.options + +# Source code files +headers = acconfig.h + +AM_CPPFLAGS = -DHAVE_MPI_INFO #-DMPIO_INCLUDE + +#SUBDIRS = include adio mpi2-other mpi-io util +SUBDIRS = include adio mpi-io + +noinst_LTLIBRARIES = libmca_io_romio_romio_dist.la + +libmca_io_romio_romio_dist_la_SOURCES = +libmca_io_romio_romio_dist_la_LIBADD = \ + adio/libmca_io_romio_romio_dist_adio.la \ + mpi-io/libmca_io_romio_romio_dist_mpi_io.la + $(MCA_io_romio_STATIC_LTLIBS) + +libmca_io_romio_romio_dist_la_DEPENDENCIES = \ + $(libmca_io_romio_romio_dist_la_LIBADD) + +libmca_io_romio_romio_dist_la_LDFLAGS = -module -avoid-version diff --git a/src/mca/io/romio/romio-dist/adio/Makefile.am b/src/mca/io/romio/romio-dist/adio/Makefile.am new file mode 100644 index 0000000000..ebf9af047a --- /dev/null +++ b/src/mca/io/romio/romio-dist/adio/Makefile.am @@ -0,0 +1,24 @@ +# +# $HEADER$ +# + +include $(top_srcdir)/config/Makefile.options + +AM_CPPFLAGS = -DHAVE_MPI_INFO \ + -I$(top_ompi_builddir)/src/include \ + -I$(top_ompi_srcdir)/src \ + -I$(top_ompi_srcdir)/src/include + +SUBDIRS = common ad_ufs ad_nfs #ad_pvfs ad_xfs + +# Library +noinst_LTLIBRARIES = libmca_io_romio_romio_dist_adio.la +libmca_io_romio_romio_dist_adio_la_SOURCES = +libmca_io_romio_romio_dist_adio_la_LIBADD = \ + common/libmca_io_romio_romio_dist_adio_common.la \ + ad_ufs/libmca_io_romio_romio_dist_adio_ad_ufs.la \ + ad_nfs/libmca_io_romio_romio_dist_adio_ad_nfs.la + +libmca_io_romio_romio_dist_adio_la_DEPENDENCIES = \ + $(libmca_io_romio_romio_dist_adio_la_LIBADD) + diff --git a/src/mca/io/romio/romio-dist/adio/ad_nfs/Makefile.am b/src/mca/io/romio/romio-dist/adio/ad_nfs/Makefile.am new file mode 100644 index 0000000000..2ae915bc69 --- /dev/null +++ b/src/mca/io/romio/romio-dist/adio/ad_nfs/Makefile.am @@ -0,0 +1,21 @@ +# -*- makefile -*- +# +# $HEADER$ +# + +include $(top_ompi_srcdir)/config/Makefile.options + +AM_CPPFLAGS = -DHAVE_MPI_INFO \ + -DNO_AIO -DNFS -I$(top_ompi_builddir)/src/include \ + -I$(top_ompi_srcdir)/src \ + -I$(top_ompi_srcdir)/src/include \ + -I../../adio/include -I../../include -I../../../src + +noinst_LTLIBRARIES = libmca_io_romio_romio_dist_adio_ad_nfs.la +libmca_io_romio_romio_dist_adio_ad_nfs_la_SOURCES = \ + ad_nfs.c ad_nfs_close.c ad_nfs_done.c ad_nfs_fcntl.c \ + ad_nfs_flush.c ad_nfs_getsh.c ad_nfs_hints.c ad_nfs_iread.c \ + ad_nfs_iwrite.c ad_nfs_open.c ad_nfs_rdcoll.c ad_nfs_read.c \ + ad_nfs_resize.c ad_nfs_seek.c ad_nfs_setsh.c ad_nfs_wait.c \ + ad_nfs_wrcoll.c ad_nfs_write.c + diff --git a/src/mca/io/romio/romio-dist/adio/ad_ufs/Makefile.am b/src/mca/io/romio/romio-dist/adio/ad_ufs/Makefile.am new file mode 100644 index 0000000000..3acfdcd113 --- /dev/null +++ b/src/mca/io/romio/romio-dist/adio/ad_ufs/Makefile.am @@ -0,0 +1,20 @@ +# -*- makefile -*- +# +# $HEADER$ +# + +include $(top_ompi_srcdir)/config/Makefile.options + +AM_CPPFLAGS = -DHAVE_MPI_INFO \ + -DNO_AIO -DUFS -I$(top_ompi_builddir)/src/include \ + -I$(top_ompi_srcdir)/src \ + -I$(top_ompi_srcdir)/src/include \ + -I../../adio/include -I../../include -I../../../src + +noinst_LTLIBRARIES = libmca_io_romio_romio_dist_adio_ad_ufs.la +libmca_io_romio_romio_dist_adio_ad_ufs_la_SOURCES = \ + ad_ufs.h ad_ufs_close.c ad_ufs_read.c \ + ad_ufs_open.c ad_ufs_write.c ad_ufs_done.c \ + ad_ufs_fcntl.c ad_ufs_iread.c ad_ufs_iwrite.c ad_ufs_wait.c \ + ad_ufs_resize.c ad_ufs.c + diff --git a/src/mca/io/romio/romio-dist/adio/common/Makefile.am b/src/mca/io/romio/romio-dist/adio/common/Makefile.am new file mode 100644 index 0000000000..6d79932215 --- /dev/null +++ b/src/mca/io/romio/romio-dist/adio/common/Makefile.am @@ -0,0 +1,23 @@ +# -*- makefile -*- +# +# $HEADER$ +# + +include $(top_ompi_srcdir)/config/Makefile.options + +AM_CPPFLAGS = -DHAVE_MPI_INFO \ + -DNO_AIO -I$(top_ompi_builddir)/src/include \ + -I$(top_ompi_srcdir)/src \ + -I$(top_ompi_srcdir)/src/include \ + -I../../adio/include -I../../include -I../../../src + +noinst_LTLIBRARIES = libmca_io_romio_romio_dist_adio_common.la +libmca_io_romio_romio_dist_adio_common_la_SOURCES = \ + ad_close.c ad_init.c ad_end.c ad_open.c setfn.c flatten.c \ + async_list.c req_malloc.c malloc.c ad_read_coll.c eof_offset.c \ + ad_write_coll.c lock.c ad_read_str.c ad_write_str.c iscontig.c \ + get_fp_posn.c ad_seek.c ad_delete.c ad_flush.c ad_hints.c error.c \ + ad_fstype.c ad_get_sh_fp.c ad_set_sh_fp.c shfp_fname.c \ + byte_offset.c status_setb.c ad_aggregate.c cb_config_list.c \ + ad_read_str_naive.c gencheck.c ad_set_view.c + diff --git a/src/mca/io/romio/romio-dist/include/Makefile.am b/src/mca/io/romio/romio-dist/include/Makefile.am new file mode 100644 index 0000000000..77ad841531 --- /dev/null +++ b/src/mca/io/romio/romio-dist/include/Makefile.am @@ -0,0 +1,9 @@ +# +# $HEADER$ +# + +include $(top_srcdir)/config/Makefile.options + +include_HEADERS = \ + mpio_def.h mpio.h + diff --git a/src/mca/io/romio/romio-dist/mpi-io/Makefile.am b/src/mca/io/romio/romio-dist/mpi-io/Makefile.am new file mode 100644 index 0000000000..ece156f33c --- /dev/null +++ b/src/mca/io/romio/romio-dist/mpi-io/Makefile.am @@ -0,0 +1,38 @@ +# +# $HEADER$ +# + +include $(top_srcdir)/config/Makefile.options + +AM_CPPFLAGS = -DHAVE_MPI_INFO \ + -DNO_AIO -I$(top_ompi_builddir)/src/include \ + -I$(top_ompi_srcdir)/src \ + -I$(top_ompi_srcdir)/src/include \ + -I../adio/include -I../include -I../../src + +#SUBDIRS = fortran + +noinst_LTLIBRARIES = libmca_io_romio_romio_dist_mpi_io.la + +libmca_io_romio_romio_dist_mpi_io_la_SOURCES = \ + mpioimpl.h mpioprof.h close.c read.c open.c write.c set_view.c \ + iread.c iwrite.c iotest.c iowait.c seek.c get_posn.c \ + delete.c read_all.c read_at.c \ + read_atall.c iread_at.c iwrite_at.c write_all.c get_bytoff.c \ + write_at.c write_atall.c get_view.c get_group.c get_amode.c \ + get_extent.c fsync.c get_atom.c set_atom.c \ + set_size.c get_size.c prealloc.c file_f2c.c file_c2f.c \ + ioreq_f2c.c ioreq_c2f.c set_info.c get_info.c \ + rd_atallb.c rd_atalle.c read_allb.c read_alle.c wr_atallb.c \ + wr_atalle.c write_allb.c write_alle.c \ + get_posn_sh.c iread_sh.c read_sh.c write_sh.c \ + iwrite_sh.c seek_sh.c read_ord.c read_orde.c write_ordb.c \ + read_ordb.c write_ord.c write_orde.c get_errh.c set_errh.c + +#libmca_io_romio_dist_mpi_io_la_LIBADD = \ +# fortran/libmca_io_romio_dist_mpio_fortran.la \ +#$(MCA_io_romio_STATIC_LTLIBS) +# +#libmca_io_romio_dist_mpi_io_la_DEPENDENCIES = \ +# $(libmca_io_romio_dist_mpi_io_la_LIBADD) + diff --git a/src/mca/io/romio/src/Makefile.am b/src/mca/io/romio/src/Makefile.am index 05c851954b..5c4bad6ad1 100644 --- a/src/mca/io/romio/src/Makefile.am +++ b/src/mca/io/romio/src/Makefile.am @@ -5,5 +5,19 @@ include $(top_ompi_srcdir)/config/Makefile.options +AM_CPPFLAGS = \ + -I$(top_ompi_builddir)/src/include \ + -I$(top_ompi_srcdir)/src \ + -I$(top_ompi_srcdir)/src/include + noinst_LTLIBRARIES = libmca_io_romio.la -libmca_io_romio_la_SOURCES = +libmca_io_romio_la_SOURCES = \ + io_romio.h \ + io_romio_conv.h \ + io_romio_global.c \ + io_romio_module.c \ + file_open.c \ + file_read.c \ + file_request.c \ + file_write.c + diff --git a/src/mca/io/romio/src/file_open.c b/src/mca/io/romio/src/file_open.c new file mode 100644 index 0000000000..517e63789c --- /dev/null +++ b/src/mca/io/romio/src/file_open.c @@ -0,0 +1,486 @@ +/* + * $HEADER$ + */ + +#include "mpi.h" +#include "file/file.h" +#include "io_romio.h" +#include "request/request.h" +#include + +int +mca_io_romio_File_open (MPI_Comm comm, + char *filename, + int amode, + MPI_Info info, + MPI_File * fh) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* create a new ompi_file_t */ + mca_romio_fh = malloc (sizeof (mca_io_romio_file_t)); + (*fh) = (ompi_file_t *) mca_romio_fh; + strncpy ((*fh)->f_name, filename, MPI_MAX_OBJECT_NAME); + (*fh)->ompi_io_version = OMPI_IO_1_0_0; + (*fh)->mca_io_functions.f_io = mca_io_romio_ops; + + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = + mca_io_romio_MPI_File_open (comm, filename, amode, info, + &romio_fh); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + +int +mca_io_romio_File_close (MPI_File * fh) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) (*fh); + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = mca_io_romio_MPI_File_close (&romio_fh); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + free (*fh); + + return ret; +} + + +int +mca_io_romio_File_delete (char *filename, + MPI_Info info) +{ + int ret; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = mca_io_romio_MPI_File_delete (filename, info); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + +int +mca_io_romio_File_set_size (MPI_File fh, + MPI_Offset size) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = mca_io_romio_MPI_File_set_size (romio_fh, size); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + +int +mca_io_romio_File_preallocate (MPI_File fh, + MPI_Offset size) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = mca_io_romio_MPI_File_preallocate (romio_fh, size); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + +int +mca_io_romio_File_get_size (MPI_File fh, + MPI_Offset * size) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = mca_io_romio_MPI_File_get_size (romio_fh, size); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + +int +mca_io_romio_File_get_group (MPI_File fh, + MPI_Group * group) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = mca_io_romio_MPI_File_get_group (romio_fh, group); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + +int +mca_io_romio_File_get_amode (MPI_File fh, + int *amode) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = mca_io_romio_MPI_File_get_amode (romio_fh, amode); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + +int +mca_io_romio_File_set_info (MPI_File fh, + MPI_Info info) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = mca_io_romio_MPI_File_set_info (romio_fh, info); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + +int +mca_io_romio_File_get_info (MPI_File fh, + MPI_Info * info_used) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = mca_io_romio_MPI_File_get_info (romio_fh, info_used); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + +int +mca_io_romio_File_set_view (MPI_File fh, + MPI_Offset disp, + MPI_Datatype etype, + MPI_Datatype filetype, + char *datarep, + MPI_Info info) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = + mca_io_romio_MPI_File_set_view (romio_fh, disp, etype, filetype, + datarep, info); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + +int +mca_io_romio_File_get_view (MPI_File fh, + MPI_Offset * disp, + MPI_Datatype * etype, + MPI_Datatype * filetype, + char *datarep) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = + mca_io_romio_MPI_File_get_view (romio_fh, disp, etype, filetype, + datarep); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; + +} + + +int +mca_io_romio_File_get_type_extent (MPI_File fh, + MPI_Datatype datatype, + MPI_Aint * extent) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = + mca_io_romio_MPI_File_get_type_extent (romio_fh, datatype, extent); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + +int +mca_io_romio_File_set_atomicity (MPI_File fh, + int flag) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = mca_io_romio_MPI_File_set_atomicity (romio_fh, flag); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + +int +mca_io_romio_File_get_atomicity (MPI_File fh, + int *flag) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = mca_io_romio_MPI_File_get_atomicity (romio_fh, flag); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + +int +mca_io_romio_File_sync (MPI_File fh) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = mca_io_romio_MPI_File_sync (romio_fh); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + +int +mca_io_romio_File_seek_shared (MPI_File fh, + MPI_Offset offset, + int whence) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = mca_io_romio_MPI_File_seek_shared (romio_fh, offset, whence); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + +int +mca_io_romio_File_get_position_shared (MPI_File fh, + MPI_Offset * offset) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = mca_io_romio_MPI_File_get_position_shared (romio_fh, offset); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + +int +mca_io_romio_File_seek (MPI_File fh, + MPI_Offset offset, + int whence) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = mca_io_romio_MPI_File_seek (romio_fh, offset, whence); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + +int +mca_io_romio_File_get_position (MPI_File fh, + MPI_Offset * offset) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = mca_io_romio_MPI_File_get_position (romio_fh, offset); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + +int +mca_io_romio_File_get_byte_offset (MPI_File fh, + MPI_Offset offset, + MPI_Offset * disp) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = mca_io_romio_MPI_File_get_byte_offset (romio_fh, offset, disp); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + +int +mca_io_romio_File_set_errhandler (MPI_File fh, + MPI_Errhandler eh) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = mca_io_romio_MPI_File_set_errhandler (romio_fh, eh); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + +int +mca_io_romio_File_get_errhandler (MPI_File fh, + MPI_Errhandler * eh) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = mca_io_romio_MPI_File_get_errhandler (romio_fh, eh); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} diff --git a/src/mca/io/romio/src/file_read.c b/src/mca/io/romio/src/file_read.c new file mode 100644 index 0000000000..eadd316177 --- /dev/null +++ b/src/mca/io/romio/src/file_read.c @@ -0,0 +1,404 @@ +/* + * $HEADER$ + */ + +#include "mpi.h" +#include "file/file.h" +#include "request/request.h" +#include "io_romio.h" + +int +mca_io_romio_File_read_at (MPI_File fh, + MPI_Offset offset, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Status * status) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = + mca_io_romio_MPI_File_read_at (romio_fh, offset, buf, count, + datatype, status); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + +int +mca_io_romio_File_read_at_all (MPI_File fh, + MPI_Offset offset, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Status * status) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = + mca_io_romio_MPI_File_read_at_all (romio_fh, offset, buf, count, + datatype, status); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + +int +mca_io_romio_File_iread_at (MPI_File fh, + MPI_Offset offset, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Request * request) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + mca_io_romio_request_t *rq; + mca_io_romio_MPIO_Request romio_rq; + + /* create MPI_request */ + rq = malloc (sizeof (mca_io_romio_request_t)); + (*request) = (ompi_request_t *) rq; + (*request)->req_type = OMPI_REQUEST_IO; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = + mca_io_romio_MPI_File_iread_at (romio_fh, offset, buf, count, + datatype, &romio_rq); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + +int +mca_io_romio_File_read (MPI_File fh, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Status * status) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = + mca_io_romio_MPI_File_read (romio_fh, buf, count, datatype, + status); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + +int +mca_io_romio_File_read_all (MPI_File fh, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Status * status) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = + mca_io_romio_MPI_File_read_all (romio_fh, buf, count, datatype, + status); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + +int +mca_io_romio_File_iread (MPI_File fh, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Request * request) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + mca_io_romio_request_t *rq; + mca_io_romio_MPIO_Request romio_rq; + + /* create MPI_request */ + rq = malloc (sizeof (mca_io_romio_request_t)); + (*request) = (ompi_request_t *) rq; + (*request)->req_type = OMPI_REQUEST_IO; + + /* extract the ROMIO request */ + romio_rq = rq->romio_rq; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = + mca_io_romio_MPI_File_iread (romio_fh, buf, count, datatype, + &romio_rq); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + +int +mca_io_romio_File_read_shared (MPI_File fh, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Status * status) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = + mca_io_romio_MPI_File_read_shared (romio_fh, buf, count, datatype, + status); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + +int +mca_io_romio_File_iread_shared (MPI_File fh, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Request * request) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + mca_io_romio_request_t *rq; + mca_io_romio_MPIO_Request romio_rq; + + /* create MPI_request */ + rq = malloc (sizeof (mca_io_romio_request_t)); + (*request) = (ompi_request_t *) rq; + (*request)->req_type = OMPI_REQUEST_IO; + + /* extract the ROMIO request */ + romio_rq = rq->romio_rq; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = + mca_io_romio_MPI_File_iread_shared (romio_fh, buf, count, datatype, + &romio_rq); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + +int +mca_io_romio_File_read_ordered (MPI_File fh, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Status * status) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = + mca_io_romio_MPI_File_read_ordered (romio_fh, buf, count, datatype, + status); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + +int +mca_io_romio_File_read_at_all_begin (MPI_File fh, + MPI_Offset offset, + void *buf, + int count, + MPI_Datatype datatype) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = + mca_io_romio_MPI_File_read_at_all_begin (romio_fh, offset, buf, + count, datatype); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + +int +mca_io_romio_File_read_at_all_end (MPI_File fh, + void *buf, + MPI_Status * status) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = mca_io_romio_MPI_File_read_at_all_end (romio_fh, buf, status); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + +int +mca_io_romio_File_read_all_begin (MPI_File fh, + void *buf, + int count, + MPI_Datatype datatype) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = + mca_io_romio_MPI_File_read_all_begin (romio_fh, buf, count, + datatype); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + +int +mca_io_romio_File_read_all_end (MPI_File fh, + void *buf, + MPI_Status * status) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = mca_io_romio_MPI_File_read_all_end (romio_fh, buf, status); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + +int +mca_io_romio_File_read_ordered_begin (MPI_File fh, + void *buf, + int count, + MPI_Datatype datatype) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = + mca_io_romio_MPI_File_read_ordered_begin (romio_fh, buf, count, + datatype); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + +int +mca_io_romio_File_read_ordered_end (MPI_File fh, + void *buf, + MPI_Status * status) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = mca_io_romio_MPI_File_read_ordered_end (romio_fh, buf, status); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} diff --git a/src/mca/io/romio/src/file_request.c b/src/mca/io/romio/src/file_request.c new file mode 100644 index 0000000000..42e952f5cd --- /dev/null +++ b/src/mca/io/romio/src/file_request.c @@ -0,0 +1,57 @@ +/* + * $HEADER$ + */ + +#include "mpi.h" +#include "file/file.h" +#include "io_romio.h" +#include "request/request.h" +#include + + +int +mca_io_romio_Test (MPI_Request * request, + int *flag, + MPI_Status * status) +{ + int ret; + mca_io_romio_request_t *rq; + mca_io_romio_MPIO_Request romio_rq; + + /* extract the ROMIO request */ + rq = (mca_io_romio_request_t *) (*request); + romio_rq = rq->romio_rq; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = mca_io_romio_MPIO_Test (&romio_rq, flag, status); + if (*flag) { + free (*request); + *request = MPI_REQUEST_NULL; + } + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + +int +mca_io_romio_Wait (MPI_Request * request, + MPI_Status * status) +{ + int ret; + mca_io_romio_request_t *rq; + mca_io_romio_MPIO_Request romio_rq; + + /* extract the ROMIO request */ + rq = (mca_io_romio_request_t *) (*request); + romio_rq = rq->romio_rq; + + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = mca_io_romio_MPIO_Wait (&romio_rq, status); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + free (*request); + *request = MPI_REQUEST_NULL; + return ret; +} diff --git a/src/mca/io/romio/src/file_write.c b/src/mca/io/romio/src/file_write.c new file mode 100644 index 0000000000..a986503f8f --- /dev/null +++ b/src/mca/io/romio/src/file_write.c @@ -0,0 +1,390 @@ +/* + * $HEADER$ + */ + +#include "mpi.h" +#include "file/file.h" +#include "io_romio.h" +#include "request/request.h" + + +int +mca_io_romio_File_write_at (MPI_File fh, + MPI_Offset offset, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Status * status) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = + mca_io_romio_MPI_File_write_at (romio_fh, offset, buf, count, + datatype, status); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + + +int +mca_io_romio_File_write_at_all (MPI_File fh, + MPI_Offset offset, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Status * status) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = + mca_io_romio_MPI_File_write_at_all (romio_fh, offset, buf, count, + datatype, status); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + + +int +mca_io_romio_File_iwrite_at (MPI_File fh, + MPI_Offset offset, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Request * request) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + mca_io_romio_request_t *rq; + mca_io_romio_MPIO_Request romio_rq; + + /* create MPI_request */ + rq = malloc (sizeof (mca_io_romio_request_t)); + (*request) = (ompi_request_t *) rq; + (*request)->req_type = OMPI_REQUEST_IO; + /* extract the ROMIO request */ + romio_rq = rq->romio_rq; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = + mca_io_romio_MPI_File_iwrite_at (romio_fh, offset, buf, count, + datatype, &romio_rq); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + + + + + +int +mca_io_romio_File_write (MPI_File fh, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Status * status) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = + mca_io_romio_MPI_File_write (romio_fh, buf, count, datatype, + status); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + +int +mca_io_romio_File_write_all (MPI_File fh, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Status * status) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = + mca_io_romio_MPI_File_write_all (romio_fh, buf, count, datatype, + status); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + +int +mca_io_romio_File_iwrite (MPI_File fh, + void *buf, + int count, + MPI_Datatype datatype, + ompi_request_t ** request) +{ + mca_io_romio_request_t *rq; + mca_io_romio_MPIO_Request romio_rq; + mca_io_romio_MPI_File romio_fh; + int ret; + + /* create MPI_request */ + rq = malloc (sizeof (mca_io_romio_request_t)); + *request = (ompi_request_t *) rq; + (*request)->req_type = OMPI_REQUEST_IO; + /* extract the ROMIO request */ + romio_rq = rq->romio_rq; + + romio_fh = ((mca_io_romio_file_t *) fh)->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = + mca_io_romio_MPI_File_iwrite (romio_fh, buf, count, datatype, + &romio_rq); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + return ret; +} + + +int +mca_io_romio_File_write_shared (MPI_File fh, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Status * status) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = + mca_io_romio_MPI_File_write_shared (romio_fh, buf, count, datatype, + status); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + +int +mca_io_romio_File_iwrite_shared (MPI_File fh, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Request * request) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + mca_io_romio_request_t *rq; + mca_io_romio_MPIO_Request romio_rq; + + /* create MPI_request */ + rq = malloc (sizeof (mca_io_romio_request_t)); + (*request) = (ompi_request_t *) rq; + (*request)->req_type = OMPI_REQUEST_IO; + /* extract the ROMIO request */ + romio_rq = rq->romio_rq; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = + mca_io_romio_MPI_File_iwrite_shared (romio_fh, buf, count, + datatype, &romio_rq); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + +int +mca_io_romio_File_write_ordered (MPI_File fh, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Status * status) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = + mca_io_romio_MPI_File_write_ordered (romio_fh, buf, count, + datatype, status); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + +int +mca_io_romio_File_write_at_all_begin (MPI_File fh, + MPI_Offset offset, + void *buf, + int count, + MPI_Datatype datatype) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = mca_io_romio_MPI_File_write_at_all_begin (romio_fh, offset, buf, + count, datatype); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + +int +mca_io_romio_File_write_at_all_end (MPI_File fh, + void *buf, + MPI_Status * status) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = mca_io_romio_MPI_File_write_at_all_end (romio_fh, buf, status); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + +int +mca_io_romio_File_write_all_begin (MPI_File fh, + void *buf, + int count, + MPI_Datatype datatype) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = mca_io_romio_MPI_File_write_all_begin (romio_fh, buf, count, + datatype); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + +int +mca_io_romio_File_write_all_end (MPI_File fh, + void *buf, + MPI_Status * status) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = mca_io_romio_MPI_File_write_all_end (romio_fh, buf, status); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + +int +mca_io_romio_File_write_ordered_begin (MPI_File fh, + void *buf, + int count, + MPI_Datatype datatype) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = mca_io_romio_MPI_File_write_ordered_begin (romio_fh, buf, + count, datatype); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} + +int +mca_io_romio_File_write_ordered_end (MPI_File fh, + void *buf, + MPI_Status * status) +{ + int ret; + mca_io_romio_MPI_File romio_fh; + mca_io_romio_file_t *mca_romio_fh; + + /* extract the ROMIO file handle: */ + mca_romio_fh = (mca_io_romio_file_t *) fh; + romio_fh = mca_romio_fh->romio_fh; + + OMPI_THREAD_LOCK (&mca_io_romio_mutex); + ret = mca_io_romio_MPI_File_write_ordered_end (romio_fh, buf, status); + OMPI_THREAD_UNLOCK (&mca_io_romio_mutex); + + return ret; +} diff --git a/src/mca/io/romio/src/io_romio.h b/src/mca/io/romio/src/io_romio.h new file mode 100644 index 0000000000..c27eb8642b --- /dev/null +++ b/src/mca/io/romio/src/io_romio.h @@ -0,0 +1,270 @@ +/* + * $HEADER + */ + +#ifndef MCA_IO_ROMIO_H +#define MCA_IO_ROMIO_H + +#include "request/request.h" +#include "file/file.h" +#include "threads/mutex.h" +#include "../romio-dist/include/mpio_def.h" + +/* global variables, instantiated in global.c */ +extern ompi_mutex_t mca_io_romio_mutex; +extern mca_io_1_0_0_t mca_io_romio_ops; + +/* + * MPI_Request: "inherit" the ompi_request, and add more stuff: + * (romio module will instantiate) + */ +struct mca_io_romio_request_t { + ompi_request_t super; + ROMIO_PREFIX (MPIO_Request) romio_rq; +}; +typedef struct mca_io_romio_request_t mca_io_romio_request_t; + +/* + * MPI_File: "inherit" the ompi_file_t, and add more stuff + * (romio module will instantiate) + */ +struct mca_io_romio_file_t { + ompi_file_t super; + ROMIO_PREFIX (MPI_File) romio_fh; +}; +typedef struct mca_io_romio_file_t mca_io_romio_file_t; + +/* function prototypes + * + * mca->ROMIO module routines: + * ROMIO_PREFIX(File_XXX) + * ROMIO operations names: + * ROMIO_PREFIX(MPI_File_XXX) + */ +/* Section 9.2 */ +int mca_io_romio_File_open (MPI_Comm comm, + char *filename, + int amode, + MPI_Info info, + MPI_File * fh); +int mca_io_romio_File_close (MPI_File * fh); +int mca_io_romio_File_delete (char *filename, + MPI_Info info); +int mca_io_romio_File_set_size (MPI_File fh, + MPI_Offset size); +int mca_io_romio_File_preallocate (MPI_File fh, + MPI_Offset size); +int mca_io_romio_File_get_size (MPI_File fh, + MPI_Offset * size); +int mca_io_romio_File_get_group (MPI_File fh, + MPI_Group * group); +int mca_io_romio_File_get_amode (MPI_File fh, + int *amode); +int mca_io_romio_File_set_info (MPI_File fh, + MPI_Info info); +int mca_io_romio_File_get_info (MPI_File fh, + MPI_Info * info_used); + +/* Section 9.3 */ +int mca_io_romio_File_set_view (MPI_File fh, + MPI_Offset disp, + MPI_Datatype etype, + MPI_Datatype filetype, + char *datarep, + MPI_Info info); +int mca_io_romio_File_get_view (MPI_File fh, + MPI_Offset * disp, + MPI_Datatype * etype, + MPI_Datatype * filetype, + char *datarep); + +/* Section 9.4.2 */ +int mca_io_romio_File_read_at (MPI_File fh, + MPI_Offset offset, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Status * status); +int mca_io_romio_File_read_at_all (MPI_File fh, + MPI_Offset offset, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Status * status); +int mca_io_romio_File_write_at (MPI_File fh, + MPI_Offset offset, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Status * status); +int mca_io_romio_File_write_at_all (MPI_File fh, + MPI_Offset offset, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Status * status); +int mca_io_romio_File_iread_at (MPI_File fh, + MPI_Offset offset, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Request * request); +int mca_io_romio_File_iwrite_at (MPI_File fh, + MPI_Offset offset, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Request * request); + +/* Section 9.4.3 */ +int mca_io_romio_File_read (MPI_File fh, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Status * status); +int mca_io_romio_File_read_all (MPI_File fh, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Status * status); +int mca_io_romio_File_write (MPI_File fh, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Status * status); +int mca_io_romio_File_write_all (MPI_File fh, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Status * status); +int mca_io_romio_File_iread (MPI_File fh, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Request * request); +int mca_io_romio_File_iwrite (MPI_File fh, + void *buf, + int count, + MPI_Datatype datatype, + ompi_request_t ** request); +int mca_io_romio_File_seek (MPI_File fh, + MPI_Offset offset, + int whence); +int mca_io_romio_File_get_position (MPI_File fh, + MPI_Offset * offset); +int mca_io_romio_File_get_byte_offset (MPI_File fh, + MPI_Offset offset, + MPI_Offset * disp); + +/* Section 9.4.4 */ +int mca_io_romio_File_read_shared (MPI_File fh, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Status * status); +int mca_io_romio_File_write_shared (MPI_File fh, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Status * status); +int mca_io_romio_File_iread_shared (MPI_File fh, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Request * request); +int mca_io_romio_File_iwrite_shared (MPI_File fh, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Request * request); +int mca_io_romio_File_read_ordered (MPI_File fh, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Status * status); +int mca_io_romio_File_write_ordered (MPI_File fh, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Status * status); +int mca_io_romio_File_seek_shared (MPI_File fh, + MPI_Offset offset, + int whence); +int mca_io_romio_File_get_position_shared (MPI_File fh, + MPI_Offset * offset); + +/* Section 9.4.5 */ +int mca_io_romio_File_read_at_all_begin (MPI_File fh, + MPI_Offset offset, + void *buf, + int count, + MPI_Datatype datatype); +int mca_io_romio_File_read_at_all_end (MPI_File fh, + void *buf, + MPI_Status * status); +int mca_io_romio_File_write_at_all_begin (MPI_File fh, + MPI_Offset offset, + void *buf, + int count, + MPI_Datatype datatype); +int mca_io_romio_File_write_at_all_end (MPI_File fh, + void *buf, + MPI_Status * status); +int mca_io_romio_File_read_all_begin (MPI_File fh, + void *buf, + int count, + MPI_Datatype datatype); +int mca_io_romio_File_read_all_end (MPI_File fh, + void *buf, + MPI_Status * status); +int mca_io_romio_File_write_all_begin (MPI_File fh, + void *buf, + int count, + MPI_Datatype datatype); +int mca_io_romio_File_write_all_end (MPI_File fh, + void *buf, + MPI_Status * status); +int mca_io_romio_File_read_ordered_begin (MPI_File fh, + void *buf, + int count, + MPI_Datatype datatype); +int mca_io_romio_File_read_ordered_end (MPI_File fh, + void *buf, + MPI_Status * status); +int mca_io_romio_File_write_ordered_begin (MPI_File fh, + void *buf, + int count, + MPI_Datatype datatype); +int mca_io_romio_File_write_ordered_end (MPI_File fh, + void *buf, + MPI_Status * status); + +/* Section 9.5.1 */ +int mca_io_romio_File_get_type_extent (MPI_File fh, + MPI_Datatype datatype, + MPI_Aint * extent); + +/* Section 9.6.1 */ +int mca_io_romio_File_set_atomicity (MPI_File fh, + int flag); +int mca_io_romio_File_get_atomicity (MPI_File fh, + int *flag); +int mca_io_romio_File_sync (MPI_File fh); + +/* Section 4.13.3 */ +int mca_io_romio_File_set_errhandler (MPI_File, + MPI_Errhandler); +int mca_io_romio_File_get_errhandler (MPI_File, + MPI_Errhandler *); +/* End Prototypes */ + +/* The funtions will not be called by users, but by OMPI's + * MPI_Test/Wait functions when they are called with an I/O request. + */ +int mca_io_romio_Test (MPI_Request * request, + int *flag, + MPI_Status * status); +int mca_io_romio_Wait (MPI_Request * request, + MPI_Status * status); + +#endif /* MCA_IO_ROMIO_H */ diff --git a/src/mca/io/romio/src/io_romio_conv.h b/src/mca/io/romio/src/io_romio_conv.h new file mode 100644 index 0000000000..bdd0698f1d --- /dev/null +++ b/src/mca/io/romio/src/io_romio_conv.h @@ -0,0 +1,132 @@ +#ifndef MCA_ROMIO_IO_H +#define MCA_ROMIO_IO_H + +/* Section 9.2 */ +/* Begin Prototypes */ +#define MPI_File_open ROMIO_PREFIX(MPI_File_open) +#define MPI_File_close ROMIO_PREFIX(MPI_File_close) +#define MPI_File_delete ROMIO_PREFIX(MPI_File_delete) +#define MPI_File_set_size ROMIO_PREFIX(MPI_File_set_size) +#define MPI_File_preallocate ROMIO_PREFIX(MPI_File_preallocate) +#define MPI_File_get_size ROMIO_PREFIX(MPI_File_get_size) +#define MPI_File_get_group ROMIO_PREFIX(MPI_File_get_group) +#define MPI_File_get_amode ROMIO_PREFIX(MPI_File_get_amode) +#define MPI_File_set_info ROMIO_PREFIX(MPI_File_set_info) +#define MPI_File_get_info ROMIO_PREFIX(MPI_File_get_info) + +/* Section 9.3 */ +#define MPI_File_set_view ROMIO_PREFIX(MPI_File_set_view) +#define MPI_File_get_view ROMIO_PREFIX(MPI_File_get_view) + +/* Section 9.4.2 */ +#define MPI_File_read_at ROMIO_PREFIX(MPI_File_read_at) +#define MPI_File_read_at_all ROMIO_PREFIX(MPI_File_read_at_all) +#define MPI_File_write_at ROMIO_PREFIX(MPI_File_write_at) +#define MPI_File_write_at_all ROMIO_PREFIX(MPI_File_write_at_all) +#define MPI_File_iread_at ROMIO_PREFIX(MPI_File_iread_at) +#define MPI_File_iwrite_at ROMIO_PREFIX(MPI_File_iwrite_at) + +/* Section 9.4.3 */ +#define MPI_File_read ROMIO_PREFIX(MPI_File_read) +#define MPI_File_read_all ROMIO_PREFIX(MPI_File_read_all) +#define MPI_File_write ROMIO_PREFIX(MPI_File_write) +#define MPI_File_write_all ROMIO_PREFIX(MPI_File_write_all) + +#define MPI_File_iread ROMIO_PREFIX(MPI_File_iread) +#define MPI_File_iwrite ROMIO_PREFIX(MPI_File_iwrite) + +#define MPI_File_seek ROMIO_PREFIX(MPI_File_seek) +#define MPI_File_get_position ROMIO_PREFIX(MPI_File_get_position) +#define MPI_File_get_byte_offset ROMIO_PREFIX(MPI_File_get_byte_offset) + +/* Section 9.4.4 */ +#define MPI_File_read_shared ROMIO_PREFIX(MPI_File_read_shared) +#define MPI_File_write_shared ROMIO_PREFIX(MPI_File_write_shared) +#define MPI_File_iread_shared ROMIO_PREFIX(MPI_File_iread_shared) +#define MPI_File_iwrite_shared ROMIO_PREFIX(MPI_File_iwrite_shared) +#define MPI_File_read_ordered ROMIO_PREFIX(MPI_File_read_ordered) +#define MPI_File_write_ordered ROMIO_PREFIX(MPI_File_write_ordered) +#define MPI_File_seek_shared ROMIO_PREFIX(MPI_File_seek_shared) +#define MPI_File_get_position_shared ROMIO_PREFIX(MPI_File_get_position_shared) + +/* Section 9.4.5 */ +#define MPI_File_read_at_all_begin ROMIO_PREFIX(MPI_File_read_at_all_begin) +#define MPI_File_read_at_all_end ROMIO_PREFIX(MPI_File_read_at_all_end) +#define MPI_File_write_at_all_begin ROMIO_PREFIX(MPI_File_write_at_all_begin) +#define MPI_File_write_at_all_end ROMIO_PREFIX(MPI_File_write_at_all_end) +#define MPI_File_read_all_begin ROMIO_PREFIX(MPI_File_read_all_begin) +#define MPI_File_read_all_end ROMIO_PREFIX(MPI_File_read_all_end) +#define MPI_File_write_all_begin ROMIO_PREFIX(MPI_File_write_all_begin) +#define MPI_File_write_all_end ROMIO_PREFIX(MPI_File_write_all_end) +#define MPI_File_read_ordered_begin ROMIO_PREFIX(MPI_File_read_ordered_begin) +#define MPI_File_read_ordered_end ROMIO_PREFIX(MPI_File_read_ordered_end) +#define MPI_File_write_ordered_begin ROMIO_PREFIX(MPI_File_write_ordered_begin) +#define MPI_File_write_ordered_end ROMIO_PREFIX(MPI_File_write_ordered_end) + +/* Section 9.5.1 */ +#define MPI_File_get_type_extent ROMIO_PREFIX(MPI_File_get_type_extent) + +/* Section 9.6.1 */ +#define MPI_File_set_atomicity ROMIO_PREFIX(MPI_File_set_atomicity) +#define MPI_File_get_atomicity ROMIO_PREFIX(MPI_File_get_atomicity) +#define MPI_File_sync ROMIO_PREFIX(MPI_File_sync) + +/* Section 4.13.3 */ +#define MPI_File_set_errhandler ROMIO_PREFIX(MPI_File_set_errhandler) +#define MPI_File_get_errhandler ROMIO_PREFIX(MPI_File_get_errhandler) +/* End Prototypes */ + +#if 0 +/* Section 4.14.4 */ +#define MPI_Type_create_subarray ROMIO_PREFIX(MPI_Type_create_subarray) + +/* Section 4.14.5 */ +#define MPI_Type_create_darray ROMIO_PREFIX(MPI_Type_create_darray) +#endif + +#define MPI_File_f2c ROMIO_PREFIX(MPI_File_f2c) +#define MPI_File_c2f ROMIO_PREFIX(MPI_File_c2f) + +#define MPIO_Test ROMIO_PREFIX(MPIO_Test) +#define MPIO_Wait ROMIO_PREFIX(MPIO_Wait) + +#define MPIO_Request_c2f ROMIO_PREFIX(MPIO_Request_c2f) +#define MPIO_Request_f2c ROMIO_PREFIX(MPIO_Request_f2c) + +/* Conversion of MPI_File and MPIO_Request */ +#define MPI_File ROMIO_PREFIX(MPI_File) +#define MPIO_Request ROMIO_PREFIX(MPIO_Request) + +/* info functions if not defined in the MPI implementation */ +#if 0 +#ifndef HAVE_MPI_INFO +int MPI_Info_create (MPI_Info * info); +int MPI_Info_set (MPI_Info info, + char *key, + char *value); +int MPI_Info_delete (MPI_Info info, + char *key); +int MPI_Info_get (MPI_Info info, + char *key, + int valuelen, + char *value, + int *flag); +int MPI_Info_get_valuelen (MPI_Info info, + char *key, + int *valuelen, + int *flag); +int MPI_Info_get_nkeys (MPI_Info info, + int *nkeys); +int MPI_Info_get_nthkey (MPI_Info info, + int n, + char *key); +int MPI_Info_dup (MPI_Info info, + MPI_Info * newinfo); +int MPI_Info_free (MPI_Info * info); + +MPI_Fint MPI_Info_c2f (MPI_Info info); +MPI_Info MPI_Info_f2c (MPI_Fint info); +#endif +#endif + +#endif diff --git a/src/mca/io/romio/src/io_romio_global.c b/src/mca/io/romio/src/io_romio_global.c new file mode 100644 index 0000000000..f05c590c11 --- /dev/null +++ b/src/mca/io/romio/src/io_romio_global.c @@ -0,0 +1,82 @@ +/* + * $HEADER + */ +#include "threads/mutex.h" +#include "io_romio.h" + +ompi_mutex_t mca_io_romio_mutex; + +mca_io_1_0_0_t mca_io_romio_ops = { + + /* manage functions */ + ROMIO_PREFIX (File_open), + ROMIO_PREFIX (File_close), + + ROMIO_PREFIX (File_delete), + ROMIO_PREFIX (File_set_size), + ROMIO_PREFIX (File_preallocate), + ROMIO_PREFIX (File_get_size), + ROMIO_PREFIX (File_get_group), + ROMIO_PREFIX (File_get_amode), + ROMIO_PREFIX (File_set_info), + ROMIO_PREFIX (File_get_info), + ROMIO_PREFIX (File_set_view), + ROMIO_PREFIX (File_get_view), + + /* Index IO operations */ + ROMIO_PREFIX (File_read_at), + ROMIO_PREFIX (File_read_at_all), + ROMIO_PREFIX (File_write_at), + ROMIO_PREFIX (File_write_at_all), + ROMIO_PREFIX (File_iread_at), + ROMIO_PREFIX (File_iwrite_at), + + /* non-indexed IO operations */ + ROMIO_PREFIX (File_read), + ROMIO_PREFIX (File_read_all), + ROMIO_PREFIX (File_write), + ROMIO_PREFIX (File_write_all), + ROMIO_PREFIX (File_iread), + ROMIO_PREFIX (File_iwrite), + + ROMIO_PREFIX (File_seek), + ROMIO_PREFIX (File_get_position), + ROMIO_PREFIX (File_get_byte_offset), + + ROMIO_PREFIX (File_read_shared), + ROMIO_PREFIX (File_write_shared), + ROMIO_PREFIX (File_iread_shared), + ROMIO_PREFIX (File_iwrite_shared), + ROMIO_PREFIX (File_read_ordered), + ROMIO_PREFIX (File_write_ordered), + ROMIO_PREFIX (File_seek_shared), + ROMIO_PREFIX (File_get_position_shared), + + /* Split IO operations */ + ROMIO_PREFIX (File_read_at_all_begin), + ROMIO_PREFIX (File_read_at_all_end), + ROMIO_PREFIX (File_write_at_all_begin), + ROMIO_PREFIX (File_write_at_all_end), + ROMIO_PREFIX (File_read_all_begin), + ROMIO_PREFIX (File_read_all_end), + ROMIO_PREFIX (File_write_all_begin), + ROMIO_PREFIX (File_write_all_end), + ROMIO_PREFIX (File_read_ordered_begin), + ROMIO_PREFIX (File_read_ordered_end), + ROMIO_PREFIX (File_write_ordered_begin), + ROMIO_PREFIX (File_write_ordered_end), + + ROMIO_PREFIX (File_get_type_extent), + + /* Sync/atomic IO operations */ + ROMIO_PREFIX (File_set_atomicity), + ROMIO_PREFIX (File_get_atomicity), + ROMIO_PREFIX (File_sync), + + ROMIO_PREFIX (File_set_errhandler), + ROMIO_PREFIX (File_get_errhandler), + + /* The following two are not add-on for MPI-IO implementations */ + ROMIO_PREFIX (Test), + ROMIO_PREFIX (Wait) +}; diff --git a/src/mca/io/romio/src/io_romio_module.c b/src/mca/io/romio/src/io_romio_module.c new file mode 100644 index 0000000000..2585ec918c --- /dev/null +++ b/src/mca/io/romio/src/io_romio_module.c @@ -0,0 +1,68 @@ +/* + * $HEADER$ + */ + +#include "mpi.h" +#include "mca/io/io.h" +#include "io_romio.h" + + +int mca_io_romio_module_open (void); +int mca_io_romio_module_close (void); +mca_io_1_0_0_t *mca_io_romio_module_init (int *priority, + int *min_thread, + int *max_thread); + +mca_io_base_module_1_0_0_t mca_io_romio_module = { + /* First, the mca_base_module_t struct containing meta information + about the module itself */ + + { + /* Indicate that we are a io v1.0.0 module (which also implies a + specific MCA version) */ + MCA_IO_BASE_VERSION_1_0_0, + "romio", /* MCA module name */ + 1, /* MCA module major version */ + 0, /* MCA module minor version */ + 0, /* MCA module release version */ + mca_io_romio_module_open, /* module open */ + mca_io_romio_module_close /* module close */ + }, + + /* Next the MCA v1.0.0 module meta data */ + + { + /* Whether the module is checkpointable or not */ + false + }, + + mca_io_romio_module_init /* module init */ +}; + + +int +mca_io_romio_module_open (void) +{ + return OMPI_SUCCESS; + /* register all mca parameters */ +} + + +int +mca_io_romio_module_close (void) +{ + return OMPI_SUCCESS; +} + + +mca_io_1_0_0_t * +mca_io_romio_module_init (int *priority, + int *min_thread, + int *max_thread) +{ + *priority = 10; + *min_thread = MPI_THREAD_SINGLE; + *max_thread = MPI_THREAD_SERIALIZED; + + return &mca_io_romio_ops; +} diff --git a/src/mca/io/romio/src/romioconf.h b/src/mca/io/romio/src/romioconf.h new file mode 100644 index 0000000000..e69de29bb2