diff --git a/.github/workflows/end_to_end_regression.yml b/.github/workflows/end_to_end_regression.yml index b2de5ee89..ef34f9023 100644 --- a/.github/workflows/end_to_end_regression.yml +++ b/.github/workflows/end_to_end_regression.yml @@ -8,6 +8,9 @@ on: branches: - main +env: + MPICH_VERSION: 4.3.1 + jobs: end_to_end_regression: strategy: @@ -22,16 +25,16 @@ jobs: sudo apt-get install -y gfortran bc - name: Install MPICH run: | + echo "Install MPICH ${MPICH_VERSION} in ${PWD}/mpich_install" mkdir mpich_install export MPICH_INSTALL_PATH=$PWD/mpich_install - wget https://www.mpich.org/static/downloads/3.2.1/mpich-3.2.1.tar.gz - tar -xzvf mpich-3.2.1.tar.gz - cd mpich-3.2.1 + wget -q https://www.mpich.org/static/downloads/${MPICH_VERSION}/mpich-${MPICH_VERSION}.tar.gz + tar -xzvf mpich-${MPICH_VERSION}.tar.gz + cd mpich-${MPICH_VERSION} mkdir build cd build FFLAGS="-w -fallow-argument-mismatch" ../configure --disable-dependency-tracking --prefix=$MPICH_INSTALL_PATH - make - make install + make -j8 install - name: Install Darshan run: | git submodule update --init diff --git a/.github/workflows/mpich_openmpi.yml b/.github/workflows/mpich_openmpi.yml new file mode 100644 index 000000000..58b0cd9ee --- /dev/null +++ b/.github/workflows/mpich_openmpi.yml @@ -0,0 +1,132 @@ +name: Test MPICH and OpenMPI + +on: + push: + branches: + - main + pull_request: + branches: + - main + +env: + MPICH_VERSION: 4.3.1 + OPENMPI_VERSION: 5.0.8 + +jobs: + build: + strategy: + matrix: + platform: [ubuntu-latest] + runs-on: ${{ matrix.platform }} + steps: + - uses: actions/checkout@v4 + - name: Install dependencies + run: | + sudo apt-get update -y + - name: Build MPICH + run: | + cd ${GITHUB_WORKSPACE} + echo "Install MPICH ${MPICH_VERSION} in ${GITHUB_WORKSPACE}/MPICH" + rm -rf MPICH ; mkdir MPICH ; cd MPICH + wget -q https://www.mpich.org/static/downloads/${MPICH_VERSION}/mpich-${MPICH_VERSION}.tar.gz + gzip -dc mpich-${MPICH_VERSION}.tar.gz | tar -xf - + cd mpich-${MPICH_VERSION} + ./configure --prefix=${GITHUB_WORKSPACE}/MPICH \ + --silent \ + --enable-romio \ + --with-file-system=ufs \ + --with-device=ch3:sock \ + --disable-fortran \ + CC=gcc + make -s LIBTOOLFLAGS=--silent V=1 -j 8 install > qout 2>&1 + make -s -j 8 distclean >> qout 2>&1 + - name: Build OPENMPI + run: | + cd ${GITHUB_WORKSPACE} + echo "Install OPENMPI ${OPENMPI_VERSION} in ${GITHUB_WORKSPACE}/OPENMPI" + rm -rf OPENMPI ; mkdir OPENMPI ; cd OPENMPI + VER_MAJOR=${OPENMPI_VERSION%.*} + wget -q https://download.open-mpi.org/release/open-mpi/v${VER_MAJOR}/openmpi-${OPENMPI_VERSION}.tar.gz + gzip -dc openmpi-${OPENMPI_VERSION}.tar.gz | tar -xf - + cd openmpi-${OPENMPI_VERSION} + ./configure --prefix=${GITHUB_WORKSPACE}/OPENMPI \ + --silent \ + --with-io-romio-flags="--with-file-system=ufs" \ + --disable-mpi-cxx --disable-mpi-fortran \ + CC=gcc + make -s LIBTOOLFLAGS=--silent V=1 -j 8 install > qout 2>&1 + make -s -j 8 distclean >> qout 2>&1 + - name: Initialize Darshan + run: | + git submodule update --init + autoreconf -i + - name: Build Darshan using MPICH + run: | + export PATH="${GITHUB_WORKSPACE}/MPICH/bin:${PATH}" + export DARSHAN_ROOT="${GITHUB_WORKSPACE}" + export DARSHAN_LOG_PATH="${GITHUB_WORKSPACE}/LOGS" + export DARSHAN_INSTALL="${GITHUB_WORKSPACE}/INSTALL" + export DARSHAN_BUILD="${GITHUB_WORKSPACE}/BUILD" + rm -rf ${DARSHAN_LOG_PATH} ${DARSHAN_BUILD} ${DARSHAN_INSTALL} + mkdir -p ${DARSHAN_LOG_PATH} ${DARSHAN_BUILD} + cd ${DARSHAN_BUILD} + $DARSHAN_ROOT/configure --prefix=${DARSHAN_INSTALL} \ + --with-log-path=${DARSHAN_LOG_PATH} \ + --with-jobid-env=NONE \ + CC=mpicc RUNTIME_CC=mpicc UTIL_CC=gcc + make -s LIBTOOLFLAGS=--silent V=1 -j8 + make -s install + - name: make check (MPICH) + run: | + export PATH="${GITHUB_WORKSPACE}/MPICH/bin:${PATH}" + cd ${GITHUB_WORKSPACE}/BUILD + make check + - name: Print test log files (MPICH) + if: ${{ always() }} + run: | + cat ${GITHUB_WORKSPACE}/BUILD/darshan-runtime/test/tst_runs.log + - name: make check (MPICH) running 4 processes + run: | + export PATH="${GITHUB_WORKSPACE}/MPICH/bin:${PATH}" + cd ${GITHUB_WORKSPACE}/BUILD + make check NP=4 + - name: Print test log files (MPICH) running 4 processes + if: ${{ always() }} + run: | + cat ${GITHUB_WORKSPACE}/BUILD/darshan-runtime/test/tst_runs.log + + - name: Build Darshan using OpenMPI + run: | + export PATH="${GITHUB_WORKSPACE}/OPENMPI/bin:${PATH}" + export DARSHAN_ROOT="${GITHUB_WORKSPACE}" + export DARSHAN_LOG_PATH="${GITHUB_WORKSPACE}/LOGS" + export DARSHAN_INSTALL="${GITHUB_WORKSPACE}/INSTALL" + export DARSHAN_BUILD="${GITHUB_WORKSPACE}/BUILD" + rm -rf ${DARSHAN_LOG_PATH} ${DARSHAN_BUILD} ${DARSHAN_INSTALL} + mkdir -p ${DARSHAN_LOG_PATH} ${DARSHAN_BUILD} + cd ${DARSHAN_BUILD} + $DARSHAN_ROOT/configure --prefix=${DARSHAN_INSTALL} \ + --with-log-path=${DARSHAN_LOG_PATH} \ + --with-jobid-env=NONE \ + CC=mpicc RUNTIME_CC=mpicc UTIL_CC=gcc + make -s LIBTOOLFLAGS=--silent V=1 -j8 + make -s install + - name: make check (OpenMPI) + run: | + export PATH="${GITHUB_WORKSPACE}/OPENMPI/bin:${PATH}" + cd ${GITHUB_WORKSPACE}/BUILD + make check + - name: Print test log files (OpenMPI) + if: ${{ always() }} + run: | + cat ${GITHUB_WORKSPACE}/BUILD/darshan-runtime/test/tst_runs.log + - name: make check (OpenMPI) running 4 processes + run: | + export PATH="${GITHUB_WORKSPACE}/OPENMPI/bin:${PATH}" + cd ${GITHUB_WORKSPACE}/BUILD + make check NP=4 + - name: Print test log files (OpenMPI) running 4 processes + if: ${{ always() }} + run: | + cat ${GITHUB_WORKSPACE}/BUILD/darshan-runtime/test/tst_runs.log + diff --git a/darshan-runtime/Makefile.am b/darshan-runtime/Makefile.am index 4a779e9a7..cdc4527b3 100644 --- a/darshan-runtime/Makefile.am +++ b/darshan-runtime/Makefile.am @@ -5,7 +5,7 @@ ACLOCAL_AMFLAGS = -I ../maint/config -SUBDIRS = lib pkgconfig share +SUBDIRS = lib pkgconfig share test bin_SCRIPTS = darshan-config \ darshan-gen-cc.pl \ diff --git a/darshan-runtime/configure.ac b/darshan-runtime/configure.ac index 54b22c0b4..b36444c8a 100644 --- a/darshan-runtime/configure.ac +++ b/darshan-runtime/configure.ac @@ -690,8 +690,11 @@ if test "x$enable_darshan_runtime" = xyes ; then #error OPENMPI FOUND #endif ])], - [], - [AC_DEFINE(HAVE_OPEN_MPI, 1, Define if OpenMPI is being used)]) + [is_ompi=0], [is_ompi=1]) + + if test "x$is_ompi" = x1 ; then + AC_DEFINE(HAVE_OPEN_MPI, 1, [Define if OpenMPI is being used]) + fi # determine if the MPI library includes MPI-IO functions or not AC_MSG_CHECKING(for MPI-IO support in MPI) @@ -770,6 +773,55 @@ if test "x$enable_darshan_runtime" = xyes ; then [AC_MSG_RESULT(yes)], [AC_MSG_RESULT(no)])], [AC_MSG_RESULT(no)] ) + + dnl MPI_Count was first introduced in MPI 3.0. Check MPI-IOfunctions that make + dnl use of MPI_Count. + AC_CHECK_FUNCS([MPI_File_read_c \ + MPI_File_read_all_c \ + MPI_File_read_all_begin_c \ + MPI_File_read_at_c \ + MPI_File_read_at_all_c \ + MPI_File_read_at_all_begin_c \ + MPI_File_read_ordered_c \ + MPI_File_read_ordered_begin_c \ + MPI_File_read_shared_c \ + MPI_File_write_c \ + MPI_File_write_all_c \ + MPI_File_write_all_begin_c \ + MPI_File_write_at_c \ + MPI_File_write_at_all_c \ + MPI_File_write_at_all_begin_c \ + MPI_File_write_ordered_c \ + MPI_File_write_ordered_begin_c \ + MPI_File_write_shared_c \ + MPI_File_iread_c \ + MPI_File_iread_all_c \ + MPI_File_iread_at_c \ + MPI_File_iread_at_all_c \ + MPI_File_iread_shared_c \ + MPI_File_iwrite_c \ + MPI_File_iwrite_all_c \ + MPI_File_iwrite_at_c \ + MPI_File_iwrite_at_all_c \ + MPI_File_iwrite_shared_c], + [have_mpi_io_large_count_apis=yes], + [have_mpi_io_large_count_apis=no]) + + if test "x$have_mpi_io_large_count_apis" = "xyes" ; then + AC_DEFINE(HAVE_MPI_LARGE_COUNT, 1, + [Define if MPI-IO support large count feature]) + AC_SUBST(HAVE_MPI_LARGE_COUNT, [1]) + fi + + ac_mpi_path=`AS_DIRNAME(["$CC"])` + if test "x$ac_mpi_path" = "x." ; then + AC_PATH_PROGS(mpicc_path, ${CC}) + ac_mpi_path=`AS_DIRNAME(["$mpicc_path"])` + fi + AC_PATH_PROGS(TESTMPIRUN, mpiexec mpirun, [], [$ac_mpi_path]) + AC_SUBST(TESTMPIRUN) + else + have_mpi_io_large_count_apis=no fi # @@ -833,6 +885,8 @@ else enable_ldms_mod=no with_log_path= with_jobid_env= + have_mpi_io_large_count_apis=no + is_ompi=0 fi AC_SUBST(ENABLE_LD_PRELOAD, ["$enable_ld_preload"]) @@ -868,6 +922,7 @@ AC_SUBST(HDF5_PATH, ["$with_hdf5"]) AC_SUBST(PNETCDF_PATH, ["$with_pnetcdf"]) AC_SUBST(DAOS_PATH, ["$with_daos"]) AC_SUBST(LDMS_PATH, ["$LDMS_HOME"]) +AC_SUBST(HAVE_OPEN_MPI, ["$is_ompi"]) AM_CONDITIONAL(ENABLE_MMAP_LOGS, [test "x$enable_mmap_logs" = xyes]) AM_CONDITIONAL(ENABLE_LDPRELOAD, [test "x$enable_ld_preload" = xyes]) @@ -895,6 +950,7 @@ AC_CONFIG_FILES(Makefile \ darshan-gen-cxx.pl \ darshan-gen-fortran.pl \ lib/Makefile \ + test/Makefile \ pkgconfig/Makefile \ pkgconfig/darshan-runtime.pc \ share/Makefile \ @@ -972,5 +1028,6 @@ if test "x$enable_darshan_runtime" = xyes ; then Log file env variables - $__log_path_by_env Location of Darshan log files - $__log_path Job ID env variable - $with_jobid_env - MPI-IO hints - $__DARSHAN_LOG_HINTS" + MPI-IO hints - $__DARSHAN_LOG_HINTS + MPI-IO large-count support - $have_mpi_io_large_count_apis" fi diff --git a/darshan-runtime/lib/darshan-dynamic.h b/darshan-runtime/lib/darshan-dynamic.h index db370324c..12397d182 100644 --- a/darshan-runtime/lib/darshan-dynamic.h +++ b/darshan-runtime/lib/darshan-dynamic.h @@ -148,6 +148,39 @@ DARSHAN_EXTERN_DECL(PMPI_Gather, int, (const void *sendbuf, int sendcount, MPI_D DARSHAN_EXTERN_DECL(PMPI_Gather, int, (void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf, int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm)); #endif DARSHAN_EXTERN_DECL(PMPI_Barrier, int, (MPI_Comm comm)); + +/* If MPI-IO supports large-count feature */ +#ifdef HAVE_MPI_LARGE_COUNT +DARSHAN_EXTERN_DECL(PMPI_File_iread_all_c, int, (MPI_File fh, void *buf, MPI_Count count, MPI_Datatype datatype, __D_MPI_REQUEST *request)); +DARSHAN_EXTERN_DECL(PMPI_File_iread_at_all_c, int, (MPI_File fh, MPI_Offset offset, void *buf, MPI_Count count, MPI_Datatype datatype, __D_MPI_REQUEST *request)); +DARSHAN_EXTERN_DECL(PMPI_File_iread_at_c, int, (MPI_File fh, MPI_Offset offset, void *buf, MPI_Count count, MPI_Datatype datatype, __D_MPI_REQUEST *request)); +DARSHAN_EXTERN_DECL(PMPI_File_iread_c, int, (MPI_File fh, void *buf, MPI_Count count, MPI_Datatype datatype, __D_MPI_REQUEST *request)); +DARSHAN_EXTERN_DECL(PMPI_File_iread_shared_c, int, (MPI_File fh, void *buf, MPI_Count count, MPI_Datatype datatype, __D_MPI_REQUEST *request)); +DARSHAN_EXTERN_DECL(PMPI_File_iwrite_all_c, int, (MPI_File fh, const void *buf, MPI_Count count, MPI_Datatype datatype, __D_MPI_REQUEST *request)); +DARSHAN_EXTERN_DECL(PMPI_File_iwrite_at_all_c, int, (MPI_File fh, MPI_Offset offset, const void *buf, MPI_Count count, MPI_Datatype datatype, __D_MPI_REQUEST *request)); +DARSHAN_EXTERN_DECL(PMPI_File_iwrite_at_c, int, (MPI_File fh, MPI_Offset offset, const void *buf, MPI_Count count, MPI_Datatype datatype, __D_MPI_REQUEST *request)); +DARSHAN_EXTERN_DECL(PMPI_File_iwrite_c, int, (MPI_File fh, const void *buf, MPI_Count count, MPI_Datatype datatype, __D_MPI_REQUEST *request)); +DARSHAN_EXTERN_DECL(PMPI_File_iwrite_shared_c, int, (MPI_File fh, const void *buf, MPI_Count count, MPI_Datatype datatype, __D_MPI_REQUEST *request)); +DARSHAN_EXTERN_DECL(PMPI_File_read_all_begin_c, int, (MPI_File fh, void *buf, MPI_Count count, MPI_Datatype datatype)); +DARSHAN_EXTERN_DECL(PMPI_File_read_all_c, int, (MPI_File fh, void *buf, MPI_Count count, MPI_Datatype datatype, MPI_Status *status)); +DARSHAN_EXTERN_DECL(PMPI_File_read_at_all_begin_c, int, (MPI_File fh, MPI_Offset offset, void *buf, MPI_Count count, MPI_Datatype datatype)); +DARSHAN_EXTERN_DECL(PMPI_File_read_at_all_c, int, (MPI_File fh, MPI_Offset offset, void *buf, MPI_Count count, MPI_Datatype datatype, MPI_Status *status)); +DARSHAN_EXTERN_DECL(PMPI_File_read_at_c, int, (MPI_File fh, MPI_Offset offset, void *buf, MPI_Count count, MPI_Datatype datatype, MPI_Status *status)); +DARSHAN_EXTERN_DECL(PMPI_File_read_c, int, (MPI_File fh, void *buf, MPI_Count count, MPI_Datatype datatype, MPI_Status *status)); +DARSHAN_EXTERN_DECL(PMPI_File_read_ordered_begin_c, int, (MPI_File fh, void *buf, MPI_Count count, MPI_Datatype datatype)); +DARSHAN_EXTERN_DECL(PMPI_File_read_ordered_c, int, (MPI_File fh, void *buf, MPI_Count count, MPI_Datatype datatype, MPI_Status *status)); +DARSHAN_EXTERN_DECL(PMPI_File_read_shared_c, int, (MPI_File fh, void *buf, MPI_Count count, MPI_Datatype datatype, MPI_Status *status)); +DARSHAN_EXTERN_DECL(PMPI_File_write_all_begin_c, int, (MPI_File fh, const void *buf, MPI_Count count, MPI_Datatype datatype)); +DARSHAN_EXTERN_DECL(PMPI_File_write_all_c, int, (MPI_File fh, const void *buf, MPI_Count count, MPI_Datatype datatype, MPI_Status *status)); +DARSHAN_EXTERN_DECL(PMPI_File_write_at_all_begin_c, int, (MPI_File fh, MPI_Offset offset, const void *buf, MPI_Count count, MPI_Datatype datatype)); +DARSHAN_EXTERN_DECL(PMPI_File_write_at_all_c, int, (MPI_File fh, MPI_Offset offset, const void *buf, MPI_Count count, MPI_Datatype datatype, MPI_Status *status)); +DARSHAN_EXTERN_DECL(PMPI_File_write_at_c, int, (MPI_File fh, MPI_Offset offset, const void *buf, MPI_Count count, MPI_Datatype datatype, MPI_Status *status)); +DARSHAN_EXTERN_DECL(PMPI_File_write_c, int, (MPI_File fh, const void *buf, MPI_Count count, MPI_Datatype datatype, MPI_Status *status)); +DARSHAN_EXTERN_DECL(PMPI_File_write_ordered_begin_c, int, (MPI_File fh, const void *buf, MPI_Count count, MPI_Datatype datatype)); +DARSHAN_EXTERN_DECL(PMPI_File_write_ordered_c, int, (MPI_File fh, const void *buf, MPI_Count count, MPI_Datatype datatype, MPI_Status *status)); +DARSHAN_EXTERN_DECL(PMPI_File_write_shared_c, int, (MPI_File fh, const void *buf, MPI_Count count, MPI_Datatype datatype, MPI_Status *status)); +#endif + #endif /* HAVE_MPI */ #endif diff --git a/darshan-runtime/lib/darshan-mpiio.c b/darshan-runtime/lib/darshan-mpiio.c index de8bc1414..18f4fd807 100644 --- a/darshan-runtime/lib/darshan-mpiio.c +++ b/darshan-runtime/lib/darshan-mpiio.c @@ -46,8 +46,10 @@ DARSHAN_FORWARD_DECL(PMPI_File_iwrite_at_all, int, (MPI_File fh, MPI_Offset offs #endif #ifdef HAVE_MPI_CONST DARSHAN_FORWARD_DECL(PMPI_File_iwrite, int, (MPI_File fh, const void *buf, int count, MPI_Datatype datatype, __D_MPI_REQUEST *request)); +DARSHAN_FORWARD_DECL(PMPI_File_iwrite_all, int, (MPI_File fh, const void *buf, int count, MPI_Datatype datatype, __D_MPI_REQUEST *request)); #else DARSHAN_FORWARD_DECL(PMPI_File_iwrite, int, (MPI_File fh, void *buf, int count, MPI_Datatype datatype, __D_MPI_REQUEST *request)); +DARSHAN_FORWARD_DECL(PMPI_File_iwrite_all, int, (MPI_File fh, void *buf, int count, MPI_Datatype datatype, __D_MPI_REQUEST *request)); #endif #ifdef HAVE_MPI_CONST DARSHAN_FORWARD_DECL(PMPI_File_iwrite_shared, int, (MPI_File fh, const void *buf, int count, MPI_Datatype datatype, __D_MPI_REQUEST *request)); @@ -987,6 +989,41 @@ DARSHAN_WRAPPER_MAP(PMPI_File_iwrite, int, (MPI_File fh, void * buf, int count, MPI_File_iwrite) #endif +#ifdef HAVE_MPI_CONST +int DARSHAN_DECL(MPI_File_iwrite_all)(MPI_File fh, const void * buf, int count, + MPI_Datatype datatype, __D_MPI_REQUEST * request) +#else +int DARSHAN_DECL(MPI_File_iwrite_all)(MPI_File fh, void * buf, int count, + MPI_Datatype datatype, __D_MPI_REQUEST * request) +#endif +{ + int ret; + double tm1, tm2; + MPI_Offset offset; + + MAP_OR_FAIL(PMPI_File_iwrite_all); + + MPI_File_get_position(fh, &offset); + tm1 = MPIIO_WTIME(); + ret = __real_PMPI_File_iwrite_all(fh, buf, count, datatype, request); + tm2 = MPIIO_WTIME(); + + MPIIO_PRE_RECORD(); + MPIIO_RECORD_WRITE(ret, fh, count, datatype, offset, MPIIO_NB_WRITES, tm1, tm2); + MPIIO_POST_RECORD(); + + return(ret); +} +#ifdef HAVE_MPI_CONST +DARSHAN_WRAPPER_MAP(PMPI_File_iwrite_all, int, (MPI_File fh, const void * buf, int count, + MPI_Datatype datatype, __D_MPI_REQUEST * request), + MPI_File_iwrite_all) +#else +DARSHAN_WRAPPER_MAP(PMPI_File_iwrite_all, int, (MPI_File fh, void * buf, int count, + MPI_Datatype datatype, __D_MPI_REQUEST * request), + MPI_File_iwrite_all) +#endif + int DARSHAN_DECL(MPI_File_iread_at)(MPI_File fh, MPI_Offset offset, void * buf, int count, MPI_Datatype datatype, __D_MPI_REQUEST *request) { @@ -1899,6 +1936,688 @@ static void mpiio_cleanup() return; } +#ifdef HAVE_MPI_LARGE_COUNT +/* MPI-IO large-count APIs */ + +DARSHAN_FORWARD_DECL(PMPI_File_iread_all_c, int, (MPI_File fh, void *buf, MPI_Count count, MPI_Datatype datatype, __D_MPI_REQUEST *request)); +DARSHAN_FORWARD_DECL(PMPI_File_iread_at_all_c, int, (MPI_File fh, MPI_Offset offset, void *buf, MPI_Count count, MPI_Datatype datatype, __D_MPI_REQUEST *request)); +DARSHAN_FORWARD_DECL(PMPI_File_iread_at_c, int, (MPI_File fh, MPI_Offset offset, void *buf, MPI_Count count, MPI_Datatype datatype, __D_MPI_REQUEST *request)); +DARSHAN_FORWARD_DECL(PMPI_File_iread_c, int, (MPI_File fh, void *buf, MPI_Count count, MPI_Datatype datatype, __D_MPI_REQUEST *request)); +DARSHAN_FORWARD_DECL(PMPI_File_iread_shared_c, int, (MPI_File fh, void *buf, MPI_Count count, MPI_Datatype datatype, __D_MPI_REQUEST *request)); +DARSHAN_FORWARD_DECL(PMPI_File_iwrite_all_c, int, (MPI_File fh, const void *buf, MPI_Count count, MPI_Datatype datatype, __D_MPI_REQUEST *request)); +DARSHAN_FORWARD_DECL(PMPI_File_iwrite_at_all_c, int, (MPI_File fh, MPI_Offset offset, const void *buf, MPI_Count count, MPI_Datatype datatype, __D_MPI_REQUEST *request)); +DARSHAN_FORWARD_DECL(PMPI_File_iwrite_at_c, int, (MPI_File fh, MPI_Offset offset, const void *buf, MPI_Count count, MPI_Datatype datatype, __D_MPI_REQUEST *request)); +DARSHAN_FORWARD_DECL(PMPI_File_iwrite_c, int, (MPI_File fh, const void *buf, MPI_Count count, MPI_Datatype datatype, __D_MPI_REQUEST *request)); +DARSHAN_FORWARD_DECL(PMPI_File_iwrite_shared_c, int, (MPI_File fh, const void *buf, MPI_Count count, MPI_Datatype datatype, __D_MPI_REQUEST *request)); +DARSHAN_FORWARD_DECL(PMPI_File_read_all_begin_c, int, (MPI_File fh, void *buf, MPI_Count count, MPI_Datatype datatype)); +DARSHAN_FORWARD_DECL(PMPI_File_read_all_c, int, (MPI_File fh, void *buf, MPI_Count count, MPI_Datatype datatype, MPI_Status *status)); +DARSHAN_FORWARD_DECL(PMPI_File_read_at_all_begin_c, int, (MPI_File fh, MPI_Offset offset, void *buf, MPI_Count count, MPI_Datatype datatype)); +DARSHAN_FORWARD_DECL(PMPI_File_read_at_all_c, int, (MPI_File fh, MPI_Offset offset, void *buf, MPI_Count count, MPI_Datatype datatype, MPI_Status *status)); +DARSHAN_FORWARD_DECL(PMPI_File_read_at_c, int, (MPI_File fh, MPI_Offset offset, void *buf, MPI_Count count, MPI_Datatype datatype, MPI_Status *status)); +DARSHAN_FORWARD_DECL(PMPI_File_read_c, int, (MPI_File fh, void *buf, MPI_Count count, MPI_Datatype datatype, MPI_Status *status)); +DARSHAN_FORWARD_DECL(PMPI_File_read_ordered_begin_c, int, (MPI_File fh, void *buf, MPI_Count count, MPI_Datatype datatype)); +DARSHAN_FORWARD_DECL(PMPI_File_read_ordered_c, int, (MPI_File fh, void *buf, MPI_Count count, MPI_Datatype datatype, MPI_Status *status)); +DARSHAN_FORWARD_DECL(PMPI_File_read_shared_c, int, (MPI_File fh, void *buf, MPI_Count count, MPI_Datatype datatype, MPI_Status *status)); +DARSHAN_FORWARD_DECL(PMPI_File_write_all_begin_c, int, (MPI_File fh, const void *buf, MPI_Count count, MPI_Datatype datatype)); +DARSHAN_FORWARD_DECL(PMPI_File_write_all_c, int, (MPI_File fh, const void *buf, MPI_Count count, MPI_Datatype datatype, MPI_Status *status)); +DARSHAN_FORWARD_DECL(PMPI_File_write_at_all_begin_c, int, (MPI_File fh, MPI_Offset offset, const void *buf, MPI_Count count, MPI_Datatype datatype)); +DARSHAN_FORWARD_DECL(PMPI_File_write_at_all_c, int, (MPI_File fh, MPI_Offset offset, const void *buf, MPI_Count count, MPI_Datatype datatype, MPI_Status *status)); +DARSHAN_FORWARD_DECL(PMPI_File_write_at_c, int, (MPI_File fh, MPI_Offset offset, const void *buf, MPI_Count count, MPI_Datatype datatype, MPI_Status *status)); +DARSHAN_FORWARD_DECL(PMPI_File_write_c, int, (MPI_File fh, const void *buf, MPI_Count count, MPI_Datatype datatype, MPI_Status *status)); +DARSHAN_FORWARD_DECL(PMPI_File_write_ordered_begin_c, int, (MPI_File fh, const void *buf, MPI_Count count, MPI_Datatype datatype)); +DARSHAN_FORWARD_DECL(PMPI_File_write_ordered_c, int, (MPI_File fh, const void *buf, MPI_Count count, MPI_Datatype datatype, MPI_Status *status)); +DARSHAN_FORWARD_DECL(PMPI_File_write_shared_c, int, (MPI_File fh, const void *buf, MPI_Count count, MPI_Datatype datatype, MPI_Status *status)); + + +int DARSHAN_DECL(MPI_File_iread_all_c)(MPI_File fh, void * buf, MPI_Count count, MPI_Datatype datatype, __D_MPI_REQUEST * request) +{ + int ret; + double tm1, tm2; + MPI_Offset offset; + + MAP_OR_FAIL(PMPI_File_iread_all_c); + + MPI_File_get_position(fh, &offset); + tm1 = MPIIO_WTIME(); + ret = __real_PMPI_File_iread_all_c(fh, buf, count, datatype, request); + tm2 = MPIIO_WTIME(); + + MPIIO_PRE_RECORD(); + MPIIO_RECORD_READ(ret, fh, count, datatype, offset, MPIIO_NB_READS, tm1, tm2); + MPIIO_POST_RECORD(); + + return(ret); +} +DARSHAN_WRAPPER_MAP(PMPI_File_iread_all_c, int, (MPI_File fh, void * buf, MPI_Count count, MPI_Datatype datatype, __D_MPI_REQUEST * request), + MPI_File_iread_all_c) + +int DARSHAN_DECL(MPI_File_iread_at_all_c)(MPI_File fh, MPI_Offset offset, void * buf, + MPI_Count count, MPI_Datatype datatype, __D_MPI_REQUEST *request) +{ + int ret; + double tm1, tm2; + + MAP_OR_FAIL(PMPI_File_iread_at_all_c); + + tm1 = MPIIO_WTIME(); + ret = __real_PMPI_File_iread_at_all_c(fh, offset, buf, count, + datatype, request); + tm2 = MPIIO_WTIME(); + + MPIIO_PRE_RECORD(); + MPIIO_RECORD_READ(ret, fh, count, datatype, offset, MPIIO_NB_READS, tm1, tm2); + MPIIO_POST_RECORD(); + + return(ret); +} +DARSHAN_WRAPPER_MAP(PMPI_File_iread_at_all_c, int, (MPI_File fh, MPI_Offset offset, void * buf, + MPI_Count count, MPI_Datatype datatype, __D_MPI_REQUEST *request), + MPI_File_iread_at_all_c) + +int DARSHAN_DECL(MPI_File_iread_at_c)(MPI_File fh, MPI_Offset offset, void * buf, + MPI_Count count, MPI_Datatype datatype, __D_MPI_REQUEST *request) +{ + int ret; + double tm1, tm2; + + MAP_OR_FAIL(PMPI_File_iread_at_c); + + tm1 = MPIIO_WTIME(); + ret = __real_PMPI_File_iread_at_c(fh, offset, buf, count, + datatype, request); + tm2 = MPIIO_WTIME(); + + MPIIO_PRE_RECORD(); + MPIIO_RECORD_READ(ret, fh, count, datatype, offset, MPIIO_NB_READS, tm1, tm2); + MPIIO_POST_RECORD(); + + return(ret); +} +DARSHAN_WRAPPER_MAP(PMPI_File_iread_at_c, int, (MPI_File fh, MPI_Offset offset, void * buf, + MPI_Count count, MPI_Datatype datatype, __D_MPI_REQUEST *request), + MPI_File_iread_at_c) + +int DARSHAN_DECL(MPI_File_iread_c)(MPI_File fh, void * buf, MPI_Count count, MPI_Datatype datatype, __D_MPI_REQUEST * request) +{ + int ret; + double tm1, tm2; + MPI_Offset offset; + + MAP_OR_FAIL(PMPI_File_iread_c); + + MPI_File_get_position(fh, &offset); + tm1 = MPIIO_WTIME(); + ret = __real_PMPI_File_iread_c(fh, buf, count, datatype, request); + tm2 = MPIIO_WTIME(); + + MPIIO_PRE_RECORD(); + MPIIO_RECORD_READ(ret, fh, count, datatype, offset, MPIIO_NB_READS, tm1, tm2); + MPIIO_POST_RECORD(); + + return(ret); +} +DARSHAN_WRAPPER_MAP(PMPI_File_iread_c, int, (MPI_File fh, void * buf, MPI_Count count, MPI_Datatype datatype, __D_MPI_REQUEST * request), + MPI_File_iread_c) + +int DARSHAN_DECL(MPI_File_iread_shared_c)(MPI_File fh, void * buf, MPI_Count count, + MPI_Datatype datatype, __D_MPI_REQUEST * request) +{ + int ret; + double tm1, tm2; + MPI_Offset offset; + + MAP_OR_FAIL(PMPI_File_iread_shared_c); + + MPI_File_get_position_shared(fh, &offset); + tm1 = MPIIO_WTIME(); + ret = __real_PMPI_File_iread_shared_c(fh, buf, count, + datatype, request); + tm2 = MPIIO_WTIME(); + + MPIIO_PRE_RECORD(); + MPIIO_RECORD_READ(ret, fh, count, datatype, offset, MPIIO_NB_READS, tm1, tm2); + MPIIO_POST_RECORD(); + + return(ret); +} +DARSHAN_WRAPPER_MAP(PMPI_File_iread_shared_c, int, (MPI_File fh, void * buf, MPI_Count count, + MPI_Datatype datatype, __D_MPI_REQUEST * request), + MPI_File_iread_shared_c) + +int DARSHAN_DECL(MPI_File_iwrite_all_c)(MPI_File fh, const void * buf, MPI_Count count, + MPI_Datatype datatype, __D_MPI_REQUEST * request) +{ + int ret; + double tm1, tm2; + MPI_Offset offset; + + MAP_OR_FAIL(PMPI_File_iwrite_all_c); + + MPI_File_get_position(fh, &offset); + tm1 = MPIIO_WTIME(); + ret = __real_PMPI_File_iwrite_all_c(fh, buf, count, datatype, request); + tm2 = MPIIO_WTIME(); + + MPIIO_PRE_RECORD(); + MPIIO_RECORD_WRITE(ret, fh, count, datatype, offset, MPIIO_NB_WRITES, tm1, tm2); + MPIIO_POST_RECORD(); + + return(ret); +} +DARSHAN_WRAPPER_MAP(PMPI_File_iwrite_all_c, int, (MPI_File fh, const void * buf, MPI_Count count, + MPI_Datatype datatype, __D_MPI_REQUEST * request), + MPI_File_iwrite_all_c) + +int DARSHAN_DECL(MPI_File_iwrite_at_all_c)(MPI_File fh, MPI_Offset offset, const void * buf, + MPI_Count count, MPI_Datatype datatype, __D_MPI_REQUEST *request) +{ + int ret; + double tm1, tm2; + + MAP_OR_FAIL(PMPI_File_iwrite_at_all_c); + + tm1 = MPIIO_WTIME(); + ret = __real_PMPI_File_iwrite_at_all_c(fh, offset, buf, + count, datatype, request); + tm2 = MPIIO_WTIME(); + + MPIIO_PRE_RECORD(); + MPIIO_RECORD_WRITE(ret, fh, count, datatype, offset, MPIIO_NB_WRITES, tm1, tm2); + MPIIO_POST_RECORD(); + + return(ret); +} +DARSHAN_WRAPPER_MAP(PMPI_File_iwrite_at_all_c, int, (MPI_File fh, MPI_Offset offset, const void * buf, + MPI_Count count, MPI_Datatype datatype, __D_MPI_REQUEST *request), + MPI_File_iwrite_at_all_c) + +int DARSHAN_DECL(MPI_File_iwrite_at_c)(MPI_File fh, MPI_Offset offset, const void * buf, + MPI_Count count, MPI_Datatype datatype, __D_MPI_REQUEST *request) +{ + int ret; + double tm1, tm2; + + MAP_OR_FAIL(PMPI_File_iwrite_at_c); + + tm1 = MPIIO_WTIME(); + ret = __real_PMPI_File_iwrite_at_c(fh, offset, buf, + count, datatype, request); + tm2 = MPIIO_WTIME(); + + MPIIO_PRE_RECORD(); + MPIIO_RECORD_WRITE(ret, fh, count, datatype, offset, MPIIO_NB_WRITES, tm1, tm2); + MPIIO_POST_RECORD(); + + return(ret); +} +DARSHAN_WRAPPER_MAP(PMPI_File_iwrite_at_c, int, (MPI_File fh, MPI_Offset offset, const void * buf, + MPI_Count count, MPI_Datatype datatype, __D_MPI_REQUEST *request), + MPI_File_iwrite_at_c) + +int DARSHAN_DECL(MPI_File_iwrite_c)(MPI_File fh, const void * buf, MPI_Count count, + MPI_Datatype datatype, __D_MPI_REQUEST * request) +{ + int ret; + double tm1, tm2; + MPI_Offset offset; + + MAP_OR_FAIL(PMPI_File_iwrite_c); + + MPI_File_get_position(fh, &offset); + tm1 = MPIIO_WTIME(); + ret = __real_PMPI_File_iwrite_c(fh, buf, count, datatype, request); + tm2 = MPIIO_WTIME(); + + MPIIO_PRE_RECORD(); + MPIIO_RECORD_WRITE(ret, fh, count, datatype, offset, MPIIO_NB_WRITES, tm1, tm2); + MPIIO_POST_RECORD(); + + return(ret); +} +DARSHAN_WRAPPER_MAP(PMPI_File_iwrite_c, int, (MPI_File fh, const void * buf, MPI_Count count, + MPI_Datatype datatype, __D_MPI_REQUEST * request), + MPI_File_iwrite_c) + +int DARSHAN_DECL(MPI_File_iwrite_shared_c)(MPI_File fh, const void * buf, MPI_Count count, + MPI_Datatype datatype, __D_MPI_REQUEST * request) +{ + int ret; + double tm1, tm2; + MPI_Offset offset; + + MAP_OR_FAIL(PMPI_File_iwrite_shared_c); + + MPI_File_get_position_shared(fh, &offset); + tm1 = MPIIO_WTIME(); + ret = __real_PMPI_File_iwrite_shared_c(fh, buf, count, + datatype, request); + tm2 = MPIIO_WTIME(); + + MPIIO_PRE_RECORD(); + MPIIO_RECORD_WRITE(ret, fh, count, datatype, offset, MPIIO_NB_WRITES, tm1, tm2); + MPIIO_POST_RECORD(); + + return(ret); +} +DARSHAN_WRAPPER_MAP(PMPI_File_iwrite_shared_c, int, (MPI_File fh, const void * buf, MPI_Count count, + MPI_Datatype datatype, __D_MPI_REQUEST * request), + MPI_File_iwrite_shared_c) + +int DARSHAN_DECL(MPI_File_read_all_begin_c)(MPI_File fh, void * buf, MPI_Count count, MPI_Datatype datatype) +{ + int ret; + double tm1, tm2; + MPI_Offset offset; + + MAP_OR_FAIL(PMPI_File_read_all_begin_c); + + MPI_File_get_position(fh, &offset); + tm1 = MPIIO_WTIME(); + ret = __real_PMPI_File_read_all_begin_c(fh, buf, count, datatype); + tm2 = MPIIO_WTIME(); + + MPIIO_PRE_RECORD(); + MPIIO_RECORD_READ(ret, fh, count, datatype, offset, MPIIO_SPLIT_READS, tm1, tm2); + MPIIO_POST_RECORD(); + + return(ret); +} +DARSHAN_WRAPPER_MAP(PMPI_File_read_all_begin_c, int, (MPI_File fh, void * buf, MPI_Count count, MPI_Datatype datatype), + MPI_File_read_all_begin_c) + +int DARSHAN_DECL(MPI_File_read_all_c)(MPI_File fh, void * buf, MPI_Count count, MPI_Datatype datatype, MPI_Status *status) +{ + int ret; + double tm1, tm2; + MPI_Offset offset; + + MAP_OR_FAIL(PMPI_File_read_all_c); + + MPI_File_get_position(fh, &offset); + tm1 = MPIIO_WTIME(); + ret = __real_PMPI_File_read_all_c(fh, buf, count, + datatype, status); + tm2 = MPIIO_WTIME(); + + MPIIO_PRE_RECORD(); + MPIIO_RECORD_READ(ret, fh, count, datatype, offset, MPIIO_COLL_READS, tm1, tm2); + MPIIO_POST_RECORD(); + + return(ret); +} +DARSHAN_WRAPPER_MAP(PMPI_File_read_all_c, int, (MPI_File fh, void * buf, MPI_Count count, MPI_Datatype datatype, MPI_Status *status), + MPI_File_read_all_c) + +int DARSHAN_DECL(MPI_File_read_at_all_begin_c)(MPI_File fh, MPI_Offset offset, void * buf, + MPI_Count count, MPI_Datatype datatype) +{ + int ret; + double tm1, tm2; + + MAP_OR_FAIL(PMPI_File_read_at_all_begin_c); + + tm1 = MPIIO_WTIME(); + ret = __real_PMPI_File_read_at_all_begin_c(fh, offset, buf, + count, datatype); + tm2 = MPIIO_WTIME(); + + MPIIO_PRE_RECORD(); + MPIIO_RECORD_READ(ret, fh, count, datatype, offset, MPIIO_SPLIT_READS, tm1, tm2); + MPIIO_POST_RECORD(); + + return(ret); +} +DARSHAN_WRAPPER_MAP(PMPI_File_read_at_all_begin_c, int, (MPI_File fh, MPI_Offset offset, void * buf, + MPI_Count count, MPI_Datatype datatype), MPI_File_read_at_all_begin_c) + +int DARSHAN_DECL(MPI_File_read_at_all_c)(MPI_File fh, MPI_Offset offset, void * buf, + MPI_Count count, MPI_Datatype datatype, MPI_Status * status) +{ + int ret; + double tm1, tm2; + + MAP_OR_FAIL(PMPI_File_read_at_all_c); + + tm1 = MPIIO_WTIME(); + ret = __real_PMPI_File_read_at_all_c(fh, offset, buf, + count, datatype, status); + tm2 = MPIIO_WTIME(); + + MPIIO_PRE_RECORD(); + MPIIO_RECORD_READ(ret, fh, count, datatype, offset, MPIIO_COLL_READS, tm1, tm2); + MPIIO_POST_RECORD(); + + return(ret); +} +DARSHAN_WRAPPER_MAP(PMPI_File_read_at_all_c, int, (MPI_File fh, MPI_Offset offset, void * buf, + MPI_Count count, MPI_Datatype datatype, MPI_Status * status), + MPI_File_read_at_all_c) + +int DARSHAN_DECL(MPI_File_read_at_c)(MPI_File fh, MPI_Offset offset, void *buf, + MPI_Count count, MPI_Datatype datatype, MPI_Status *status) +{ + int ret; + double tm1, tm2; + + MAP_OR_FAIL(PMPI_File_read_at_c); + + tm1 = MPIIO_WTIME(); + ret = __real_PMPI_File_read_at_c(fh, offset, buf, + count, datatype, status); + tm2 = MPIIO_WTIME(); + + MPIIO_PRE_RECORD(); + MPIIO_RECORD_READ(ret, fh, count, datatype, offset, MPIIO_INDEP_READS, tm1, tm2); + MPIIO_POST_RECORD(); + + return(ret); +} +DARSHAN_WRAPPER_MAP(PMPI_File_read_at_c, int, (MPI_File fh, MPI_Offset offset, void *buf, + MPI_Count count, MPI_Datatype datatype, MPI_Status *status), MPI_File_read_at_c) + +int DARSHAN_DECL(MPI_File_read_c)(MPI_File fh, void *buf, MPI_Count count, + MPI_Datatype datatype, MPI_Status *status) +{ + int ret; + double tm1, tm2; + MPI_Offset offset; + + MAP_OR_FAIL(PMPI_File_read_c); + + MPI_File_get_position(fh, &offset); + tm1 = MPIIO_WTIME(); + ret = __real_PMPI_File_read_c(fh, buf, count, datatype, status); + tm2 = MPIIO_WTIME(); + + MPIIO_PRE_RECORD(); + MPIIO_RECORD_READ(ret, fh, count, datatype, offset, MPIIO_INDEP_READS, tm1, tm2); + MPIIO_POST_RECORD(); + + return(ret); +} +DARSHAN_WRAPPER_MAP(PMPI_File_read_c, int, (MPI_File fh, void *buf, MPI_Count count, + MPI_Datatype datatype, MPI_Status *status), MPI_File_read_c) + +int DARSHAN_DECL(MPI_File_read_ordered_begin_c)(MPI_File fh, void * buf, MPI_Count count, MPI_Datatype datatype) +{ + int ret; + double tm1, tm2; + MPI_Offset offset; + + MAP_OR_FAIL(PMPI_File_read_ordered_begin_c); + + MPI_File_get_position_shared(fh, &offset); + tm1 = MPIIO_WTIME(); + ret = __real_PMPI_File_read_ordered_begin_c(fh, buf, count, + datatype); + tm2 = MPIIO_WTIME(); + + MPIIO_PRE_RECORD(); + MPIIO_RECORD_READ(ret, fh, count, datatype, offset, MPIIO_SPLIT_READS, tm1, tm2); + MPIIO_POST_RECORD(); + + return(ret); +} +DARSHAN_WRAPPER_MAP(PMPI_File_read_ordered_begin_c, int, (MPI_File fh, void * buf, MPI_Count count, MPI_Datatype datatype), + MPI_File_read_ordered_begin_c) + +int DARSHAN_DECL(MPI_File_read_ordered_c)(MPI_File fh, void * buf, MPI_Count count, + MPI_Datatype datatype, MPI_Status * status) +{ + int ret; + double tm1, tm2; + MPI_Offset offset; + + MAP_OR_FAIL(PMPI_File_read_ordered_c); + + MPI_File_get_position_shared(fh, &offset); + tm1 = MPIIO_WTIME(); + ret = __real_PMPI_File_read_ordered_c(fh, buf, count, + datatype, status); + tm2 = MPIIO_WTIME(); + + MPIIO_PRE_RECORD(); + MPIIO_RECORD_READ(ret, fh, count, datatype, offset, MPIIO_COLL_READS, tm1, tm2); + MPIIO_POST_RECORD(); + + return(ret); +} +DARSHAN_WRAPPER_MAP(PMPI_File_read_ordered_c, int, (MPI_File fh, void * buf, MPI_Count count, + MPI_Datatype datatype, MPI_Status * status), + MPI_File_read_ordered_c) + +int DARSHAN_DECL(MPI_File_read_shared_c)(MPI_File fh, void * buf, MPI_Count count, MPI_Datatype datatype, MPI_Status *status) +{ + int ret; + double tm1, tm2; + MPI_Offset offset; + + MAP_OR_FAIL(PMPI_File_read_shared_c); + + MPI_File_get_position_shared(fh, &offset); + tm1 = MPIIO_WTIME(); + ret = __real_PMPI_File_read_shared_c(fh, buf, count, + datatype, status); + tm2 = MPIIO_WTIME(); + + MPIIO_PRE_RECORD(); + MPIIO_RECORD_READ(ret, fh, count, datatype, offset, MPIIO_INDEP_READS, tm1, tm2); + MPIIO_POST_RECORD(); + + return(ret); +} +DARSHAN_WRAPPER_MAP(PMPI_File_read_shared_c, int, (MPI_File fh, void * buf, MPI_Count count, MPI_Datatype datatype, MPI_Status *status), + MPI_File_read_shared_c) + +int DARSHAN_DECL(MPI_File_write_all_begin_c)(MPI_File fh, const void * buf, MPI_Count count, MPI_Datatype datatype) +{ + int ret; + double tm1, tm2; + MPI_Offset offset; + + MAP_OR_FAIL(PMPI_File_write_all_begin_c); + + MPI_File_get_position(fh, &offset); + + tm1 = MPIIO_WTIME(); + ret = __real_PMPI_File_write_all_begin_c(fh, buf, count, datatype); + tm2 = MPIIO_WTIME(); + + MPIIO_PRE_RECORD(); + MPIIO_RECORD_WRITE(ret, fh, count, datatype, offset, MPIIO_SPLIT_WRITES, tm1, tm2); + MPIIO_POST_RECORD(); + + return(ret); +} +DARSHAN_WRAPPER_MAP(PMPI_File_write_all_begin_c, int, (MPI_File fh, const void * buf, MPI_Count count, MPI_Datatype datatype), + MPI_File_write_all_begin_c) + +int DARSHAN_DECL(MPI_File_write_all_c)(MPI_File fh, const void * buf, MPI_Count count, MPI_Datatype datatype, MPI_Status *status) +{ + int ret; + double tm1, tm2; + MPI_Offset offset; + + MAP_OR_FAIL(PMPI_File_write_all_c); + + MPI_File_get_position(fh, &offset); + tm1 = MPIIO_WTIME(); + ret = __real_PMPI_File_write_all_c(fh, buf, count, + datatype, status); + tm2 = MPIIO_WTIME(); + + MPIIO_PRE_RECORD(); + MPIIO_RECORD_WRITE(ret, fh, count, datatype, offset, MPIIO_COLL_WRITES, tm1, tm2); + MPIIO_POST_RECORD(); + + return(ret); +} +DARSHAN_WRAPPER_MAP(PMPI_File_write_all_c, int, (MPI_File fh, const void * buf, MPI_Count count, MPI_Datatype datatype, MPI_Status *status), + MPI_File_write_all_c) + +int DARSHAN_DECL(MPI_File_write_at_all_begin_c)(MPI_File fh, MPI_Offset offset, const void * buf, + MPI_Count count, MPI_Datatype datatype) +{ + int ret; + double tm1, tm2; + + MAP_OR_FAIL(PMPI_File_write_at_all_begin_c); + + tm1 = MPIIO_WTIME(); + ret = __real_PMPI_File_write_at_all_begin_c(fh, offset, + buf, count, datatype); + tm2 = MPIIO_WTIME(); + + MPIIO_PRE_RECORD(); + MPIIO_RECORD_WRITE(ret, fh, count, datatype, offset, MPIIO_SPLIT_WRITES, tm1, tm2); + MPIIO_POST_RECORD(); + + return(ret); +} +DARSHAN_WRAPPER_MAP(PMPI_File_write_at_all_begin_c, int, (MPI_File fh, MPI_Offset offset, const void * buf, + MPI_Count count, MPI_Datatype datatype), MPI_File_write_at_all_begin_c) + +int DARSHAN_DECL(MPI_File_write_at_all_c)(MPI_File fh, MPI_Offset offset, const void * buf, + MPI_Count count, MPI_Datatype datatype, MPI_Status * status) +{ + int ret; + double tm1, tm2; + + MAP_OR_FAIL(PMPI_File_write_at_all_c); + + tm1 = MPIIO_WTIME(); + ret = __real_PMPI_File_write_at_all_c(fh, offset, buf, + count, datatype, status); + tm2 = MPIIO_WTIME(); + + MPIIO_PRE_RECORD(); + MPIIO_RECORD_WRITE(ret, fh, count, datatype, offset, MPIIO_COLL_WRITES, tm1, tm2); + MPIIO_POST_RECORD(); + + return(ret); +} +DARSHAN_WRAPPER_MAP(PMPI_File_write_at_all_c, int, (MPI_File fh, MPI_Offset offset, const void * buf, + MPI_Count count, MPI_Datatype datatype, MPI_Status * status), + MPI_File_write_at_all_c) + +int DARSHAN_DECL(MPI_File_write_at_c)(MPI_File fh, MPI_Offset offset, const void *buf, + MPI_Count count, MPI_Datatype datatype, MPI_Status *status) +{ + int ret; + double tm1, tm2; + + MAP_OR_FAIL(PMPI_File_write_at_c); + + tm1 = MPIIO_WTIME(); + ret = __real_PMPI_File_write_at_c(fh, offset, buf, + count, datatype, status); + tm2 = MPIIO_WTIME(); + + MPIIO_PRE_RECORD(); + MPIIO_RECORD_WRITE(ret, fh, count, datatype, offset, MPIIO_INDEP_WRITES, tm1, tm2); + MPIIO_POST_RECORD(); + + return(ret); +} +DARSHAN_WRAPPER_MAP(PMPI_File_write_at_c, int, (MPI_File fh, MPI_Offset offset, const void *buf, + MPI_Count count, MPI_Datatype datatype, MPI_Status *status), MPI_File_write_at_c) + +int DARSHAN_DECL(MPI_File_write_c)(MPI_File fh, const void *buf, MPI_Count count, + MPI_Datatype datatype, MPI_Status *status) +{ + int ret; + double tm1, tm2; + MPI_Offset offset; + + MAP_OR_FAIL(PMPI_File_write_c); + + MPI_File_get_position(fh, &offset); + tm1 = MPIIO_WTIME(); + ret = __real_PMPI_File_write_c(fh, buf, count, datatype, status); + tm2 = MPIIO_WTIME(); + + MPIIO_PRE_RECORD(); + MPIIO_RECORD_WRITE(ret, fh, count, datatype, offset, MPIIO_INDEP_WRITES, tm1, tm2); + MPIIO_POST_RECORD(); + + return(ret); +} +DARSHAN_WRAPPER_MAP(PMPI_File_write_c, int, (MPI_File fh, const void *buf, MPI_Count count, + MPI_Datatype datatype, MPI_Status *status), MPI_File_write_c) + +int DARSHAN_DECL(MPI_File_write_ordered_begin_c)(MPI_File fh, const void * buf, MPI_Count count, MPI_Datatype datatype) +{ + int ret; + double tm1, tm2; + MPI_Offset offset; + + MAP_OR_FAIL(PMPI_File_write_ordered_begin_c); + + MPI_File_get_position_shared(fh, &offset); + tm1 = MPIIO_WTIME(); + ret = __real_PMPI_File_write_ordered_begin_c(fh, buf, count, + datatype); + tm2 = MPIIO_WTIME(); + + MPIIO_PRE_RECORD(); + MPIIO_RECORD_WRITE(ret, fh, count, datatype, offset, MPIIO_SPLIT_WRITES, tm1, tm2); + MPIIO_POST_RECORD(); + + return(ret); +} +DARSHAN_WRAPPER_MAP(PMPI_File_write_ordered_begin_c, int, (MPI_File fh, const void * buf, MPI_Count count, MPI_Datatype datatype), + MPI_File_write_ordered_begin_c) + +int DARSHAN_DECL(MPI_File_write_ordered_c)(MPI_File fh, const void * buf, MPI_Count count, + MPI_Datatype datatype, MPI_Status * status) +{ + int ret; + double tm1, tm2; + MPI_Offset offset; + + MAP_OR_FAIL(PMPI_File_write_ordered_c); + MPI_File_get_position_shared(fh, &offset); + + tm1 = MPIIO_WTIME(); + ret = __real_PMPI_File_write_ordered_c(fh, buf, count, + datatype, status); + tm2 = MPIIO_WTIME(); + + MPIIO_PRE_RECORD(); + MPIIO_RECORD_WRITE(ret, fh, count, datatype, offset, MPIIO_COLL_WRITES, tm1, tm2); + MPIIO_POST_RECORD(); + + return(ret); +} +DARSHAN_WRAPPER_MAP(PMPI_File_write_ordered_c, int, (MPI_File fh, const void * buf, MPI_Count count, + MPI_Datatype datatype, MPI_Status * status), + MPI_File_write_ordered_c) + +int DARSHAN_DECL(MPI_File_write_shared_c)(MPI_File fh, const void * buf, MPI_Count count, MPI_Datatype datatype, MPI_Status *status) +{ + int ret; + double tm1, tm2; + MPI_Offset offset; + + MAP_OR_FAIL(PMPI_File_write_shared_c); + + MPI_File_get_position_shared(fh, &offset); + tm1 = MPIIO_WTIME(); + ret = __real_PMPI_File_write_shared_c(fh, buf, count, + datatype, status); + tm2 = MPIIO_WTIME(); + + MPIIO_PRE_RECORD(); + MPIIO_RECORD_WRITE(ret, fh, count, datatype, offset, MPIIO_INDEP_WRITES, tm1, tm2); + MPIIO_POST_RECORD(); + + return(ret); +} +DARSHAN_WRAPPER_MAP(PMPI_File_write_shared_c, int, (MPI_File fh, const void * buf, MPI_Count count, MPI_Datatype datatype, MPI_Status *status), + MPI_File_write_shared_c) + +#endif + /* * Local variables: * c-indent-level: 4 diff --git a/darshan-runtime/share/ld-opts/darshan-mpiio-ld-opts b/darshan-runtime/share/ld-opts/darshan-mpiio-ld-opts index 84828335d..97ac77db9 100644 --- a/darshan-runtime/share/ld-opts/darshan-mpiio-ld-opts +++ b/darshan-runtime/share/ld-opts/darshan-mpiio-ld-opts @@ -62,3 +62,59 @@ --wrap=PMPI_File_write_ordered --wrap=PMPI_File_write_ordered_begin --wrap=PMPI_File_write_shared +--wrap=MPI_File_iread_c +--wrap=MPI_File_iread_all_c +--wrap=MPI_File_iread_at_c +--wrap=MPI_File_iread_at_all_c +--wrap=MPI_File_iread_shared_c +--wrap=MPI_File_read_c +--wrap=MPI_File_read_all_c +--wrap=MPI_File_read_all_begin_c +--wrap=MPI_File_read_at_c +--wrap=MPI_File_read_at_all_c +--wrap=MPI_File_read_at_all_begin_c +--wrap=MPI_File_read_ordered_c +--wrap=MPI_File_read_ordered_begin_c +--wrap=MPI_File_read_shared_c +--wrap=MPI_File_iwrite_c +--wrap=MPI_File_iwrite_all_c +--wrap=MPI_File_iwrite_at_c +--wrap=MPI_File_iwrite_at_all_c +--wrap=MPI_File_iwrite_shared_c +--wrap=MPI_File_write_c +--wrap=MPI_File_write_all_c +--wrap=MPI_File_write_all_begin_c +--wrap=MPI_File_write_at_c +--wrap=MPI_File_write_at_all_c +--wrap=MPI_File_write_at_all_begin_c +--wrap=MPI_File_write_ordered_c +--wrap=MPI_File_write_ordered_begin_c +--wrap=MPI_File_write_shared_c +--wrap=PMPI_File_iread_c +--wrap=PMPI_File_iread_all_c +--wrap=PMPI_File_iread_at_c +--wrap=PMPI_File_iread_at_all_c +--wrap=PMPI_File_iread_shared_c +--wrap=PMPI_File_read_c +--wrap=PMPI_File_read_all_c +--wrap=PMPI_File_read_all_begin_c +--wrap=PMPI_File_read_at_c +--wrap=PMPI_File_read_at_all_c +--wrap=PMPI_File_read_at_all_begin_c +--wrap=PMPI_File_read_ordered_c +--wrap=PMPI_File_read_ordered_begin_c +--wrap=PMPI_File_read_shared_c +--wrap=PMPI_File_iwrite_c +--wrap=PMPI_File_iwrite_all_c +--wrap=PMPI_File_iwrite_at_c +--wrap=PMPI_File_iwrite_at_all_c +--wrap=PMPI_File_iwrite_shared_c +--wrap=PMPI_File_write_c +--wrap=PMPI_File_write_all_c +--wrap=PMPI_File_write_all_begin_c +--wrap=PMPI_File_write_at_c +--wrap=PMPI_File_write_at_all_c +--wrap=PMPI_File_write_at_all_begin_c +--wrap=PMPI_File_write_ordered_c +--wrap=PMPI_File_write_ordered_begin_c +--wrap=PMPI_File_write_shared_c diff --git a/darshan-runtime/test/Makefile.am b/darshan-runtime/test/Makefile.am new file mode 100644 index 000000000..4e15d25e0 --- /dev/null +++ b/darshan-runtime/test/Makefile.am @@ -0,0 +1,27 @@ +# +# See COPYRIGHT notice in top-level directory. +# +# @configure_input@ + +AM_CPPFLAGS = -I$(top_builddir) + +check_PROGRAMS = + +if BUILD_MPIIO_MODULE + check_PROGRAMS += tst_mpi_io + tst_mpi_io_SOURCES = tst_mpi_io.c +endif + +AM_TESTS_ENVIRONMENT = export TESTMPIRUN="$(TESTMPIRUN)"; +AM_TESTS_ENVIRONMENT += export TST_DARSHAN_LOG_PATH="$(__DARSHAN_LOG_PATH)"; +AM_TESTS_ENVIRONMENT += export DARSHAN_INSTALL_DIR="$(prefix)"; +AM_TESTS_ENVIRONMENT += export USERNAME_ENV="$(USERNAME_ENV)"; +AM_TESTS_ENVIRONMENT += export HAVE_MPI_LARGE_COUNT="$(HAVE_MPI_LARGE_COUNT)"; +AM_TESTS_ENVIRONMENT += export HAVE_OPEN_MPI="$(HAVE_OPEN_MPI)"; +AM_TESTS_ENVIRONMENT += export check_PROGRAMS="$(check_PROGRAMS)"; + +TESTS = tst_runs.sh +TEST_EXTENSIONS = .sh + +EXTRA_DIST = tst_runs.sh + diff --git a/darshan-runtime/test/tst_mpi_io.c b/darshan-runtime/test/tst_mpi_io.c new file mode 100644 index 000000000..ef6ef1011 --- /dev/null +++ b/darshan-runtime/test/tst_mpi_io.c @@ -0,0 +1,537 @@ +#ifdef HAVE_CONFIG_H +#include /* output of 'configure' */ +#endif + +#include +#include +#include +#include /* unlink() */ +#include + +#define CHECK_ERROR(fnc) { \ + if (rank == 0 && verbose && strcmp(fnc, "MPI_File_open") \ + && strcmp(fnc, "MPI_File_close") \ + && strcmp(fnc, "MPI_File_seek") \ + && strcmp(fnc, "MPI_Waitall") \ + && strcmp(fnc, "MPI_File_write_all_end") \ + && strcmp(fnc, "MPI_File_write_at_all_end") \ + && strcmp(fnc, "MPI_File_write_ordered_end") \ + && strcmp(fnc, "MPI_File_read_all_end") \ + && strcmp(fnc, "MPI_File_read_at_all_end") \ + && strcmp(fnc, "MPI_File_read_ordered_end")) \ + printf("---- testing %s\n",fnc); \ + if (err != MPI_SUCCESS) { \ + int errorStringLen; \ + char errorString[MPI_MAX_ERROR_STRING]; \ + MPI_Error_string(err, errorString, &errorStringLen); \ + printf("Error at line %d when calling %s: %s\n",__LINE__,fnc,errorString); \ + } \ +} + +static void +usage(char *argv0) +{ + char *help = + "Usage: %s [OPTIONS]\n" + " [-h] print this help\n" + " [-q] quiet mode\n" + " [-i] test read API\n" + " [-c] test collective API\n" + " [-a] test asynchonous API\n" + " [-s] test shared API\n" + " [-p] test split API\n" + " [-o] test ordered API\n" + " [-x] test explicit offset API\n" + " [-l] test large-count API\n"; + fprintf(stderr, help, argv0); +} + +#define NELEMS 8 + +/*----< main() >------------------------------------------------------------*/ +int main(int argc, char **argv) +{ + extern int optind; + extern char *optarg; + char filename[512], buf[NELEMS]; + int i, err, rank, np, verbose, omode; + int test_read, test_collective, test_async, test_shared; + int test_split, test_order, test_at, test_large_count; + MPI_Offset offset; + MPI_Count nbytes; + MPI_File fh; + MPI_Request req; + MPI_Status status; + + MPI_Init(&argc, &argv); + MPI_Comm_rank(MPI_COMM_WORLD, &rank); + MPI_Comm_size(MPI_COMM_WORLD, &np); + + verbose = 1; + test_read = 0; + test_collective = 0; + test_async = 0; + test_shared = 0; + test_split = 0; + test_order = 0; + test_at = 0; + test_large_count = 0; + + while ((i = getopt(argc, argv, "hqdicaspoxl")) != EOF) + switch(i) { + case 'q': verbose = 0; + break; + case 'i': test_read = 1; + break; + case 'c': test_collective = 1; + break; + case 'a': test_async = 1; + break; + case 's': test_shared = 1; + break; + case 'p': test_split = 1; + break; + case 'o': test_order = 1; + break; + case 'x': test_at = 1; + break; + case 'l': test_large_count = 1; + break; + case 'h': + default: if (rank==0) usage(argv[0]); + MPI_Finalize(); + return 1; + } + +#ifndef HAVE_MPI_LARGE_COUNT + if (test_large_count == 1) { + printf("The underlying MPI-IO does not support large-count feature... skip\n"); + MPI_Finalize(); + return 0; + } +#endif + + if (argv[optind] == NULL) strcpy(filename, "testfile.dat"); + else snprintf(filename, 512, "%s", argv[optind]); + + offset = rank * NELEMS; + nbytes = NELEMS; + for (i=0; i