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

@@ -6,7 +6,7 @@
 
 include $(top_ompi_srcdir)/config/Makefile.options
 
-SUBDIRS = src
+SUBDIRS = src romio-dist
 
 EXTRA_DIST = VERSION
 

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"

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

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)
+

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
+

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
+

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
+

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
+

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)
+

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       
+

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 <string.h>
+
+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;
+}

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;
+}

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 <string.h>
+
+
+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;
+}

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;
+}

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 */

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

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)
+};

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;
+}