dnl Process this file with autoconf to produce a configure script. AC_PREREQ(2.67) dnl dnl aclocal_cache.m4, included by sowing/confdb/aclocal.m4, fixes dnl bugs in autoconf caching. dnl dnl dnl Environment variables that affect behavior of the test configure dnl MPICH_FAST dnl dnl The file name here refers to a file in the source being configured dnl FIXME this is the old style, needs updating to new style dnl AC_INIT(include/mpitest.h) dnl FIXME duplication with VERSION variable below AC_INIT([mpich2-testsuite],[1.2]) AC_CONFIG_HEADER(include/mpitestconf.h) AH_TOP([/* -*- Mode: C; c-basic-offset:4 ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #ifndef MPITESTCONF_H_INCLUDED #define MPITESTCONF_H_INCLUDED ]) AH_BOTTOM([#endif]) # This version is the version of the test suite. # 1.0: Initial version (all versions) before independent release # 1.1: Initial version that is independent of MPICH2 11/08 # 1.2: Automake replaces simplemake VERSION=1.2 AC_SUBST(VERSION) AC_CONFIG_AUX_DIR([confdb]) AC_CONFIG_MACRO_DIR([confdb]) dnl echo "RUNNING CONFIGURE FOR MPI TESTS" AM_INIT_AUTOMAKE([-Wall -Werror foreign 1.12.3 silent-rules subdir-objects]) AM_MAINTAINER_MODE([enable]) # not using libtool for the test suite, so no LT_INIT AC_PROG_RANLIB AM_PROG_AR # Non-verbose make by default m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])]) if test -z "$mpich2_top_srcdir" ; then if test -z "$top_srcdir" ; then use_top_srcdir=$srcdir else use_top_srcdir=$top_srcdir fi case "$use_top_srcdir" in /*) ;; *) use_top_srcdir=`(cd $use_top_srcdir && pwd)` ;; esac if test -f $use_top_srcdir/../../maint/version.m4 ; then mpich2_top_srcdir=`cd $use_top_srcdir && cd ../.. && pwd` fi fi AC_SUBST(mpich2_top_srcdir) # these (in particular master_top_srcdir) are needed to regenerate # the f90 files from the f77 files AC_ARG_VAR([master_top_builddir],[path to the MPICH2 top-level build directory (if present)]) AC_ARG_VAR([master_top_srcdir],[path to the MPICH2 top-level source directory (if present)]) # Ensure that master_top_srcdir is set if maintainer mode for is set, # since some of the Makefile targets require it. if test "X$master_top_srcdir" = "X" -a "$USE_MAINTAINER_MODE" = "yes" ; then if test -z "$top_srcdir" ; then use_top_srcdir=$srcdir else use_top_srcdir=$top_srcdir fi # Make use_top_srcdir absolute case "$use_top_srcdir" in /*) ;; *) use_top_srcdir=`(cd $use_top_srcdir && pwd)` ;; esac # Now, see if we can find the f77tof90 routine if test -x $use_top_srcdir/../../maint/f77tof90 ; then master_top_srcdir=`cd $use_top_srcdir && cd ../.. && pwd` else AC_MSG_ERROR([Unable to find master source file - reconfigure using --disable-maintainer_mode]) fi fi AC_ARG_ENABLE(echo, [AC_HELP_STRING([--enable-echo],[Turn on strong echoing. The default is enable=no.])], [set -x]) AC_ARG_ENABLE(f77, [AC_HELP_STRING([--enable-f77],[Turn on Fortran 77 tests (default)])],,[enable_f77=yes]) AC_ARG_ENABLE(fc, [AC_HELP_STRING([--enable-fc],[Turn on Fortran 90 tests (if f90 available)])],, [enable_fc=yes]) AC_ARG_ENABLE(cxx, [AC_HELP_STRING([--enable-cxx],[Turn on C++ tests (default)])],,[enable_cxx=yes]) AC_ARG_ENABLE(romio, [AC_HELP_STRING([--enable-romio],[Enable ROMIO MPI I/O implementation])],, [enable_romio=yes]) AC_ARG_ENABLE(spawn, [AC_HELP_STRING([--enable-spawn], [Enable tests of the dynamic process parts of MPI-2 (default)])],, [enable_spawn=yes]) AC_ARG_ENABLE(rma, [AC_HELP_STRING([--enable-rma],[Enable tests of the one sided parts of MPI-2 (default)])],, [enable_rma=yes]) AC_ARG_ENABLE(long-double-complex, [AC_HELP_STRING([--enable-long-double-complex], [Enable tests involving MPI_LONG_DOUBLE_COMPLEX (default)])],, [enable_long_double_complex=yes]) AC_ARG_ENABLE(long-double, [AC_HELP_STRING([--enable-long-double-complex], [Enable tests involving MPI_LONG_DOUBLE and related types (default)])],, [enable_long_double=yes]) AC_ARG_ENABLE(checkerrors, [AC_HELP_STRING([--enable-checkerrors], [Add some tests for checking for errors in user programs])],, [enable_checkerrors=default]) AC_ARG_ENABLE(perftest, [AC_HELP_STRING([--enable-perftest], [Include tests for basic performance consistency (default)])],, [enable_perftest=yes]) AC_ARG_ENABLE(checkfaults, [AC_HELP_STRING([--enable-checkfaults], [Add some tests for checking on handling of faults in user programs])],, [enable_checkfaults=no]) AC_ARG_ENABLE(fast, [AC_HELP_STRING([--enable-fast], [Indicates that the MPI implementation may have been built for fastest operation, such as building without error checking. Has the effect of --enable-checkerrors=no])],,) AC_ARG_ENABLE(strictmpi, [AC_HELP_STRING([--enable-strictmpi], [Only test for operations specifically defined by the MPI standard. This turns off tests for some common extensions, including for combinations of predefined datatypes and predefined MPI_Op s.])],, [enable_strictmpi=no]) AC_ARG_ENABLE(threads, [--enable-threads=level - Specify the level of thread support expected from the MPI implementation. The following levels are supported. single - No threads (MPI_THREAD_SINGLE) funneled - Only the main thread calls MPI (MPI_THREAD_FUNNELED) serialized - User serializes calls to MPI (MPI_THREAD_SERIALIZED) multiple - Fully multi-threaded (MPI_THREAD_MULTIPLE) The default is funneled. If enabled and no level is specified, the level is set to multiple. If disabled, the level is set to single. If the environment variable MPICH_THREAD_LEVEL is set, that thread level is used (this is to let MPICH2 build for the correct thread support without requiring a specific --enable-threads argument.],, [enable_threads=default]) AC_ARG_WITH(mpi, [AC_HELP_STRING([--with-mpi=dir], [Use the selected MPI; compilation scripts for mpicc, mpif77 and mpicxx should be in dir/bin])],,) AC_ARG_WITH(config-args, [AC_HELP_STRING([--with-config-args=filename], [Specify configure argument file that contains the values of variables that configure reads, e.g. CC,CFLAGS,F77,FFLAGS,FC,FCFLAGS.... If the filename does not begin with / (absolute path), . or .. (relative path), the filename will be assumed to be $top_srcdir/configargs/.cfg.])],, [with_config_args=no]) if test "$with_config_args" != "no" ; then case "$with_config_args" in /*|../*|./*) config_args_file="$with_config_args" ;; *) config_args_file="$srcdir/configargs/$with_config_args.cfg" ;; esac if test -s "$config_args_file" ; then AC_MSG_RESULT([Reading the configure arguments in ${config_args_file}.]) . $config_args_file # Export all the variables in $config_args_file # i.e. CC,CFLAGS, F77/FFLAGS, FC/FCFLAGS, CXX/CXXFLAGS and friends... config_args_vars=`grep -v '^#' $config_args_file | sed -e 's/=.*//g'` for var in $config_args_vars ; do eval value=\$"$var" echo "Exporting $var=$value ..." export $var done else AC_MSG_WARN([Non-existent ${config_args_file}.]) fi fi # First, determine whether we are/can support the language bindings # # Since F90/F90FLAGS are replaced by FC/FCFLAGS, rather than silently # substituting them, i.e. FC=$F90 and FCFLAGS=$F90FLAGS, we choose to emit # an error message and abort to avoid any ambiguous/hidden bug in choosing # Fortran90 compilers. if test -n "$F90" -o -n "$F90FLAGS" ; then AC_MSG_ERROR([F90 and F90FLAGS are replaced by FC and FCFLAGS respectively in this configure, please unset F90/F90FLAGS and set FC/FCFLAGS instead and rerun configure again.]) fi # ------------------------------------------------------------------------ dnl use AC_ARG_VAR to mark FROM_MPICH2 as "precious" to autoconf so that dnl automatic re-runs of config.status preserve its value correctly AC_ARG_VAR([FROM_MPICH2],[should be set to "yes" if this configure script is being invoked by the main MPICH2 configure]) AC_ARG_VAR([MPICH_THREAD_LEVEL], [the MPI thread level supported by the enclosing MPICH2 build (when built within MPICH2)]) # ------------------------------------------------------------------------ if test "$enable_threads" = "yes" ; then enable_threads=multiple elif test "$enable_threads" = "no" ; then enable_threads=single elif test "$enable_threads" = default ; then if test -n "$MPICH_THREAD_LEVEL" ; then case $MPICH_THREAD_LEVEL in MPI_THREAD_MULTIPLE) enable_threads=multiple ;; MPI_THREAD_SERIALIZED) enable_threads=serialized ;; MPI_THREAD_FUNNELED) enable_threads=funneled ;; MPI_THREAD_SINGLE) enable_threads=single ;; esac else enable_threads=funneled fi fi if test "$enable_fast" = "yes" ; then if test "$enable_checkerrors" = "default" ; then enable_checkerrors=no fi fi # default for MPICH2 is to check error handling; for other cases it # is to only check correct programs. if test "$FROM_MPICH2" = "yes" ; then if test "$enable_checkerrors" = "default" -a "$MPICH_FAST" != "YES" ; then enable_checkerrors=yes else enable_checkerrors=no fi else if test "$enable_checkerrors" = "default" ; then enable_checkerrors=no fi fi # errordir is substituted into the testlist file as errors when the # tests should check error handling and as a comment (#) otherwise. errordir="#" if test "$enable_checkerrors" = "yes" ; then errordir=errors fi AC_SUBST(errordir) # The performance tests are not part of the MPI standard perfdir="perf" if test "$enable_strictmpi" = "yes" -o "$enable_perftest" = "no" ; then perfdir="#" fi AC_SUBST(perfdir) # # Only run the threads tests if multiple is specified if test "$enable_threads" = "multiple" -o "$enable_threads" = "runtime" ; then threadsdir="threads" fi PAC_LOAD_BASE_CACHE PAC_VPATH_CHECK() PAC_PROG_MAKE MPILIBLOC="" AC_SUBST(MPILIBLOC) # more variables that must be marked precious for proper re-configure operation AC_ARG_VAR([MPICH2_ENABLE_F77],["yes" if the enclosing MPICH2 build supports Fortran 77]) AC_ARG_VAR([MPICH2_ENABLE_FC],["yes" if the enclosing MPICH2 build supports modern Fortran]) AC_ARG_VAR([MPICH2_ENABLE_CXX],["yes" if the enclosing MPICH2 build supports C++]) # If we're building from MPICH2, check the MPICH2_ENABLE_xxx environment # variables for enable defaults if test "$FROM_MPICH2" = yes ; then if test -n "$MPICH2_ENABLE_F77" ; then enable_f77=$MPICH2_ENABLE_F77 fi if test -n "$MPICH2_ENABLE_FC" ; then enable_fc=$MPICH2_ENABLE_FC fi if test -n "$MPICH2_ENABLE_CXX" ; then enable_cxx=$MPICH2_ENABLE_CXX fi fi # Some MPI-2 implementations (including some of the MPICH2 shared-memory # channels and BG/L) leave out the dynamic process routines. This # allows tests to avoid reporting failure for these routines. # This can be controlled by either a --disable-spawn argument or by # setting the environment variable MPI_NO_SPAWN to yes. AC_ARG_VAR([MPI_NO_SPAWN],[set to "yes" to disable dynamic process tests]) if test "$enable_spawn" = "yes" -a "$MPI_NO_SPAWN" != "yes" ; then spawndir=spawn AC_DEFINE(HAVE_MPI_SPAWN,1,[Define if Dynamic Process functionality is available]) fi AC_SUBST(spawndir) # Also allow rma to be disabled AC_ARG_VAR([MPI_NO_RMA],[set to "yes" to disable one-sided tests]) rmadir=rma if test "$enable_rma" != yes ; then rmadir="#" elif test "$MPI_NO_RMA" = yes ; then rmadir="#" else AC_DEFINE(HAVE_MPI_WIN_CREATE,1,[Define if MPI_Win_create is available]) fi AC_SUBST(rmadir) faultsdir=# if test "$enable_checkfaults" = "yes" ; then faultsdir=faults fi AC_SUBST(faultsdir) # MPI_IS_STRICT=false AC_SUBST(MPI_IS_STRICT) if test "$enable_strictmpi" = "yes" ; then MPI_IS_STRICT=true AC_DEFINE(USE_STRICT_MPI,1,[Define if only operations defined in MPI should be tested]) fi # # At this writing, MPICH2 has many MPIX routines, and the test suite includes # them. As these are not MPI routines (yet), they are invalid and incorrect # when this test suite is used for other MPI implementations, including those # based on earlier versions of MPICH2. MPI_HAS_MPIX=no # # Hack to detect build from within MPICH2. Ensure strictmpi not selected. if test "$FROM_MPICH2" = "yes" -a "$enable_strictmpi" = "no" ; then MPI_HAS_MPIX=yes fi AC_SUBST(MPI_HAS_MPIX) # preserve these values across a reconfigure AC_ARG_VAR([WRAPPER_CFLAGS],[]) AC_ARG_VAR([WRAPPER_CPPFLAGS],[]) AC_ARG_VAR([WRAPPER_LDFLAGS],[]) AC_ARG_VAR([WRAPPER_LIBS],[]) AC_ARG_VAR([WRAPPER_FFLAGS],[]) AC_ARG_VAR([WRAPPER_FCFLAGS],[]) AC_ARG_VAR([WRAPPER_CXXFLAGS],[]) if test "$FROM_MPICH2" = "yes" ; then # perform configure tests with the normal compilers ($CC/$F77/etc), but use # the WRAPPER_xFLAGS computed by MPICH2 as our flags instead. Then at the # end of configure we will empty out these flags and set our compilers to # the installed compiler wrappers CFLAGS="$WRAPPER_CFLAGS" CPPFLAGS="$WRAPPER_CPPFLAGS" LDFLAGS="$WRAPPER_LDFLAGS" FFLAGS="$WRAPPER_FFLAGS" FCFLAGS="$WRAPPER_FCFLAGS" CXXFLAGS="$WRAPPER_CXXFLAGS" # WRAPPER_LIBS contains currently non-existent libs like "-lopa" and "-lmpl" # right now, so set LIBS to the user-specified libs for now. # FIXME Does this need to be an AC_ARG_VAR? LIBS="$MPICH2_LIBS" elif test -n "$with_mpi" ; then if test -z "$MPICC" ; then CC=$with_mpi/bin/mpicc else CC=$MPICC fi if test -z "$MPIF77" ; then F77=$with_mpi/bin/mpif77 else F77=$MPIF77 fi if test -z "$MPIFC" ; then FC=$with_mpi/bin/mpif90 else FC=$MPIFC fi if test -z "$MPICXX" ; then CXX=$with_mpi/bin/mpicxx else CXX=$MPICXX fi if test -z "$MPIEXEC" ; then MPIEXEC=$with_mpi/bin/mpiexec fi else # Try to use mpicc etc names if test -z "$MPICC" ; then AC_PATH_PROG(MPICC,mpicc mpcc) fi if test "x$MPICC" != "x" ; then CC=$MPICC fi if test -z "$MPIF77" ; then AC_PATH_PROG(MPIF77,mpif77 mpf77) fi if test "x$MPIF77" != "x" ; then F77=$MPIF77 fi if test -z "$MPIFC" ; then AC_PATH_PROG(MPIFC,mpif90 mpftn) fi if test "x$MPIFC" != "x" ; then FC=$MPIFC fi if test -z "$MPICXX" ; then # We left mpiCC off of this list because mpicc and mpiCC are the # same on Mac OSX systems. AC_PATH_PROG(MPICXX,mpicxx mpCC) fi if test "x$MPICXX" != "x" ; then CXX=$MPICXX fi if test -z "$MPIEXEC" ; then AC_PATH_PROG(MPIEXEC,mpiexec) fi fi # Running C compiler tests PAC_PROG_CC # Note that some versions of autoconf will insist that the compiler # produce executables at this point, which is why we must do something # special for building within MPICH2 # Ensure that we can compile an MPI program before we go any further # We don't use a cached value here because this is a sanity check # The exception is if we are executing this configure from within the # MPICH2 configure - in that case, the if test "$FROM_MPICH2" != "yes" ; then AC_MSG_CHECKING([whether we can compile and link MPI programs in C]) AC_LINK_IFELSE([ AC_LANG_PROGRAM([#include "mpi.h"],[MPI_Init(0,0);MPI_Finalize();]) ],[mpi_compile_works=yes],[mpi_compile_works=no]) AC_MSG_RESULT($mpi_compile_works) if test "$mpi_compile_works" != "yes" ; then AC_MSG_ERROR([Unable to compile and/or link an MPI program! Check config.log]) fi fi dnl We cannot use AC_C_LONG_DOUBLE dnl because it does not support cross-compilation. Instead, we use the dnl same test in the MPICH2 configure. # Check on support for long double and long long types. Do this before the # structure alignment test because it will test for including those # types as well # # If --disable-long-double is selected, then bypass this test. # Some MPI implementations may choose to not support long double because # their C compilers are inconsistent on the length of long double (this # is the case on the Cray, with Cray, PGI, and GNU not agreeing on the # size of long double) if test "$enable_long_double" = "yes" ; then AC_CACHE_CHECK([whether long double is supported],pac_cv_have_long_double,[ AC_COMPILE_IFELSE([ AC_LANG_PROGRAM([],[long double a;]) ],[pac_cv_have_long_double=yes],[pac_cv_have_long_double=no]) ]) if test "$pac_cv_have_long_double" = "yes" ; then AC_DEFINE(HAVE_LONG_DOUBLE,1,[Define if long double is supported]) fi fi AC_CACHE_CHECK([whether long long is supported],pac_cv_have_long_long,[ AC_COMPILE_IFELSE([ AC_LANG_PROGRAM([],[long long a;]) ],[pac_cv_have_long_long=yes],[pac_cv_have_long_long=no]) ]) if test "$pac_cv_have_long_long" = yes ; then AC_DEFINE(HAVE_LONG_LONG,1,[Define if compiler supports long long]) fi # # Check for const and restrict (used in some of the performance tests) AC_C_CONST AC_C_RESTRICT # Enable STRICT CFLAGS AC_ARG_ENABLE(stricttest, AC_HELP_STRING([--enable-stricttest], [Turn on strict GCC compilation])) dnl Initialize enable_strict_done so PAC_CC_STRICT won't exit right away dnl When it is configuring from within MPICH2, because enable_strict_done=yes dnl is set in the environment by MPICH2. enable_strict_done=no PAC_CC_STRICT($enable_stricttest) # -Wfloat-equal isn't meaningful in testsuite, # remove it if it is in strict flags. pac_cc_strict_flags="`echo $pac_cc_strict_flags | sed -e 's|-Wfloat-equal||g'`" CFLAGS="$CFLAGS $pac_cc_strict_flags" # General headers AC_HEADER_STDC dnl AC_CHECK_HEADERS(stdarg.h unistd.h string.h stdlib.h memory.h stdint.h) dnl unistd.h string.h stdlib.h memory.h stdint.h are checked by AC_PROG_CC. AC_CHECK_HEADERS(stdarg.h sys/time.h sys/resource.h) # Check for fixed width types AC_TYPE_INT8_T AC_TYPE_INT16_T AC_TYPE_INT32_T AC_TYPE_INT64_T AC_TYPE_UINT8_T AC_TYPE_UINT16_T AC_TYPE_UINT32_T AC_TYPE_UINT64_T # Check for availability of C99 types AC_CHECK_TYPES([_Bool, float _Complex, double _Complex, long double _Complex]) # Only run the long double complex tests if that type is available if test "$enable_long_double_complex" != "no" -a \ "x$ac_cv_type_long_double__Complex" = "xyes" ; then AC_DEFINE(USE_LONG_DOUBLE_COMPLEX,1,[Define if tests with long double complex should be included]) fi # Headers needed for threads tests if test "$threadsdir" = "threads" ; then # Check for needed threads headers and needed and optional routines AC_CHECK_HEADERS(pthread.h) # we shouldn't actually need to do this, but we are dodging the chicken/egg # problem b/c we don't have a working mpicc yet and we temporarily discarded # the MPICH2-set LIBS (probably the wrong thing to do) AC_SEARCH_LIBS([pthread_create],[pthread]) AC_SEARCH_LIBS([pthread_barrier_init],[pthread]) AC_CHECK_FUNCS(pthread_create pthread_yield pthread_barrier_init pthread_barrier_wait) if test "$FROM_MPICH2" != yes ; then AC_CHECK_FUNCS(MPI_Init_thread) fi fi # Check for h_addr or h_addr_list. This is needed for the singjoin test # in manual/singjoin.c AC_CACHE_CHECK([whether struct hostent contains h_addr_list], dnl Use Double quote LANG_PROGRAM dnl so [] in h_addr_list[0] won't be ignored by IFELSE. pac_cv_have_haddr_list,[ AC_COMPILE_IFELSE([ AC_LANG_PROGRAM([#include ],[[ struct hostent hp; hp.h_addr_list[0]=0; ]]) ],[pac_cv_have_haddr_list=yes],[pac_cv_have_haddr_list=no]) ]) if test "$pac_cv_have_haddr_list" = "yes" ; then AC_DEFINE(HAVE_H_ADDR_LIST,1,[Define if struct hostent contains h_addr_list]) fi AC_CHECK_FUNCS(getrusage) # Check for the MPI Version. This test assumes at least MPI 2.0. For # some tests, we need to know if we are MPI 2.1 or MPI 2.2, # particularly for new routines in Fortran if test "$FROM_MPICH2" != "yes" ; then AC_CACHE_CHECK([that MPI program can be compiled],pac_cv_mpi_compile_ok,[ AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include "mpi.h"],[MPI_Init(0,0);MPI_Finalize();])],pac_cv_mpi_compile_ok=yes,pac_cv_mpi_compile_ok=no)]) if test "$pac_cv_mpi_compile_ok" != yes ; then AC_MSG_ERROR([Unable to compile an MPI program containing mpi.h!]) fi AC_CACHE_CHECK([for major version of MPI],pac_cv_mpi_major_version,[ for pac_cv_mpi_major_version in 3 2 1 unknown ; do AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include "mpi.h"],[ #if MPI_VERSION == $pac_cv_mpi_major_version ''' force failure ''' #endif])],,break) done ]) AC_CACHE_CHECK([for minor version of MPI],pac_cv_mpi_minor_version,[ for pac_cv_mpi_minor_version in 4 3 2 1 0 unknown ; do AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include "mpi.h"],[ #if MPI_SUBVERSION == $pac_cv_mpi_minor_version ''' force failure ''' #endif])],,break) done ]) MPI_VERSION=$pac_cv_mpi_major_version MPI_SUBVERSION=$pac_cv_mpi_minor_version else # We are within the MPICH2 build. Extract the MPI versions from # mpi.h.in if test ! -f $mpich2_top_srcdir/src/include/mpi.h.in ; then AC_MSG_ERROR([Could not find the required mpi.h.in file!]) fi MPI_VERSION=`grep MPI_VERSION $mpich2_top_srcdir/src/include/mpi.h.in | \ sed -e 's/#define *MPI_VERSION *\([0-4]\).*/\1/g'` MPI_SUBVERSION=`grep MPI_SUBVERSION $mpich2_top_srcdir/src/include/mpi.h.in | \ sed -e 's/#define *MPI_SUBVERSION *\([0-9]\).*/\1/g'` fi AC_SUBST(MPI_VERSION) AC_SUBST(MPI_SUBVERSION) # Running Fortran 77 compiler tests PAC_PROG_F77 if test "$enable_f77" = yes ; then # If there is no working F77, then set enable_f77 to no if test -z "$F77" ; then enable_f77=no fi fi # Simple tests for which other languages we can handle. # Use these only when configuring separate from an MPICH2 build f77dir="#" AC_SUBST(f77dir) buildingF77=no if test "$FROM_MPICH2" = yes ; then if test "$enable_f77" = yes ; then # Assume success otherlangs="$otherlangs f77" f77dir=f77 buildingF77=yes fi elif test "$enable_f77" = yes ; then AC_MSG_CHECKING([that we can build MPI programs with Fortran 77]) AC_LANG_PUSH([Fortran 77]) AC_LINK_IFELSE([ AC_LANG_SOURCE([ program main include 'mpif.h' integer ierr call mpi_init(ierr) call mpi_finalize(ierr) end ]) ],[ AC_MSG_RESULT(yes) otherlangs="$otherlangs f77" f77dir=f77 buildingF77=yes ],[ AC_MSG_RESULT(no) ]) AC_LANG_POP([Fortran 77]) fi # # At least one test (C++ test of C and Fortran datatypes) needs to # know if Fortran is supported if test "$f77dir" = "f77" ; then AC_DEFINE(HAVE_FORTRAN_BINDING,1,[Define if Fortran is supported]) fi AM_CONDITIONAL([BUILD_F77_TESTS],[test "X$f77dir" = "f77"]) AC_ARG_VAR([MPI_SIZEOF_AINT],[if set, force MPI_Aint to a width of this many bytes]) AC_ARG_VAR([MPI_SIZEOF_OFFSET],[if set, force MPI_Offset to a width of this many bytes]) # Common tests for F77 if test "$buildingF77" = "yes" ; then # Match integer types to the MPI types for MPI_Aint and MPI_Offset # FIXME: Add a test to see if the environment is importing the # necessary information. # Get the sizes of the MPI types. We use the following: # MPI_SIZEOF_OFFSET and MPI_SIZEOF_AINT if test -z "$MPI_SIZEOF_AINT" ; then # Aint should be an address-sized integer, the same as void* # We use a test on the size of void * to avoid any complications # in dealing with running programs containing MPI headers (e.g., # the IBM MPI changes the main entry point so that MPI # programs cannot be run on the host node) AC_CHECK_SIZEOF(void *) MPI_SIZEOF_AINT=$ac_cv_sizeof_void_p fi if test -z "$MPI_SIZEOF_OFFSET" ; then # We have to try and get the size of offset anyway, since # it is not the same as void * (it depends on the available # file systems). Since we want to avoid using the MPI linker, # we could do the following: # Use the mpi compiler to compile the file, using the mpi # header but no MPI calls # Use the regular C linker to link the program # However, we do this only if the environment variable BASECC # has been provided. Else we can try the following: # use # sed -n 's/typedef \(.*\) MPI_Offset *;/\1/p' mpi.h # to extract the type corresponding to MPI_Offset and then # just use that. dnl AC_CACHE_CHECK([the sizeof MPI_Offset],ac_cv_sizeof_MPI_Offset,[ dnl ac_cv_sizeof_MPI_Offset=unknown dnl rm -f conftest* dnl cat >>conftest.c < dnl int main( int argc, char **argv ) dnl { dnl MPI_Offset a; dnl FILE *f = fopen("conftestval", "w" ); dnl if (! f) exit(1); dnl fprintf( f, "%ld\n", (long)sizeof(MPI_Offset) ); dnl fclose(f); dnl return 0; dnl } dnl EOF dnl # FIXME. Check for BASECC dnl # Note: This assumes that CC has been set to the C compiler for dnl # MPI Programs, and that either any necessary include paths are dnl # already set or they are in CPPFLAGS (prefered) or CFLAGS. dnl if AC_TRY_EVAL(ac_link) && test -s conftest$ac_exeext ; then dnl if ./conftest$ac_exeext ; then dnl #success dnl ac_cv_sizeof_MPI_Offset=`cat conftestval` dnl else dnl # failure dnl AC_MSG_WARN([Unable to run the program to determine the size of MPI_Offset]) dnl echo "configure: failed program was:" >&AC_FD_CC dnl cat conftest.c >&AC_FD_CC dnl fi dnl else dnl # failure dnl AC_MSG_WARN([Unable to build the program to determine the size of MPI_Offset]) dnl echo "configure: failed program was:" >&AC_FD_CC dnl cat conftest.c >&AC_FD_CC dnl fi dnl rm -f conftest* dnl ]) AC_CHECK_SIZEOF([MPI_Offset],[],[#include "mpi.h"]) if test "$ac_cv_sizeof_MPI_Offset" = "unknown" \ -o "$ac_cv_sizeof_MPI_Offset" -eq 0 ; then AC_MSG_WARN([Using 8 for the size of MPI_Offset]) MPI_SIZEOF_OFFSET=8 else MPI_SIZEOF_OFFSET=$ac_cv_sizeof_MPI_Offset fi fi AC_LANG_PUSH([Fortran 77]) AC_CACHE_CHECK([whether integer*4 is supported],pac_cv_fort_integer4,[ AC_COMPILE_IFELSE([AC_LANG_PROGRAM(,[ integer*4 i])], pac_cv_fort_integer4=yes, pac_cv_fort_integer4=no)]) AC_CACHE_CHECK([whether integer*8 is supported],pac_cv_fort_integer8,[ AC_COMPILE_IFELSE([AC_LANG_PROGRAM(,[ integer*8 i])], pac_cv_fort_integer8=yes, pac_cv_fort_integer8=no)]) AC_CACHE_CHECK([whether integer*16 is supported],pac_cv_fort_integer16,[ AC_COMPILE_IFELSE([AC_LANG_PROGRAM(,[ integer*16 i])], pac_cv_fort_integer16=yes, pac_cv_fort_integer16=no)]) AC_LANG_POP([Fortran 77]) # Determine Aint and Offset for len in 4 8 16 ; do eval testval=\$"pac_cv_fort_integer$len" if test "$testval" = no ; then continue ; fi testval=$len if test $len = "$MPI_SIZEOF_AINT" ; then F77_MPI_ADDRESS="integer*$len" fi if test $len = "$MPI_SIZEOF_OFFSET" ; then F77_MPI_OFFSET="integer*$len" fi done # At this point, we could create a test program that would confirm that # the values in Fortran matched the values in C. # Note that we must make this an MPI program because the compiler for # MPI programs may require that the programs be run with mpiexec or # something similar (this is true for the IBM MPI, for example). rm -f f77/init/checksizes.c # If it is a VPATH build, f77/init may not be there. if test ! -d f77/init ; then mkdir f77 mkdir f77/init fi cat > f77/init/checksizes.c < int main( int argc, char **argv ) { int fsizeof_aint = $MPI_SIZEOF_AINT; int fsizeof_offset = $MPI_SIZEOF_OFFSET; int err = 0, rc = 0; MPI_Init( &argc, &argv ); if (sizeof(MPI_Aint) != fsizeof_aint) { printf( "Sizeof MPI_Aint is %d but Fortran thinks it is %d\n", (int)sizeof(MPI_Aint), fsizeof_aint ); err++; } if (sizeof(MPI_Offset) != fsizeof_offset) { printf( "Sizeof MPI_Offset is %d but Fortran thinks it is %d\n", (int)sizeof(MPI_Offset), fsizeof_offset ); err++; } MPI_Finalize( ); if (err > 0) rc = 1; return rc; } EOF # Check for name mapping so that we can do the handle conversion tests # This test needs both the base c and fortran compilers AC_LANG_FORTRAN77 PAC_PROG_F77_NAME_MANGLE # Check that the Fortran compiler will allow us to pass arguments # of different types (e.g., for MPI_Send) # Any strict Fortran compiler will require that the arguments be # the same type - currently, the NAG Fortran compiler (nagfor) is known # to enforce this. # We could set the FFLAGS/FCFLAGS values with the option that disables # this check (if we found one), but because that may affect other tests, # instead we tell the user and exit. PAC_PROG_F77_MISMATCHED_ARGS(addarg,yes) if test "X$addarg" != "X" ; then # We could add the names of all of the MPI routines that # accept different types. Instead, we fail cleanly. # Some Fortran compilers allow you to turn off checking for # mismatched arguments for *all* routines. Adding an argument # that turns off checking for *everything* is not something that # configure should do - if the user wants this, they can follow # the instructions in the following error message. AC_MSG_ERROR([The Fortran compiler $F77 does not accept programs that call the same routine with arguments of different types without the option $addarg. Rerun configure with FFLAGS=$addarg]) fi # Check whether we need -lU77 to get iargc and getarg, which # are used for a few of the tests in spawn (U77 was needed with # the native compilers on HPUX. See the aclocal_f77(old).m4 file, # which has a much more complete set of tests. # # FIXME: if we can't figure out how to get iargc/getarg, then # we should really turn off those spawn tests # Even better is to limit this to the F200x version, where there is # an interface to the command line. F77SPAWNARGTEST="" AC_MSG_CHECKING([for Fortran libraries needed for getarg]) AC_LANG_CONFTEST([ AC_LANG_PROGRAM([],[ character*64 s integer i i = iargc() call getarg(i,s) ]) ]) AC_LINK_IFELSE([],[ pac_cv_getarg_needs_u77=no ],[ pac_cv_getarg_needs_u77=unknown ]) if test "$pac_cv_getarg_needs_u77" != "no" ; then # Try again with -lU77 saveLIBS="$LIBS" LIBS="$LIBS -lU77" AC_LINK_IFELSE([],[ pac_cv_getarg_needs_u77=yes ],[ pac_cv_getarg_needs_u77=unavailable ]) LIBS="$saveLIBS" if test "$pac_cv_getarg_needs_u77" = "yes" ; then F77_GETARG_LIBS=-lU77 fi fi rm -f conftest$ac_exeext if test -n "$F77_GETARG_LIBS" ; then AC_MSG_RESULT($F77_GETARG_LIBS) else if test "$pac_cv_getarg_needs_u77" = "unavailable" ; then AC_MSG_RESULT([getarg and/or iargc are not available. Some spawn tests will fail to link]) F77SPAWNARGTEST="#" else AC_MSG_RESULT([none needed]) fi fi AC_SUBST(F77_GETARG_LIBS) # FIXME: Currently, we hope that FC accepts the same library FC_GETARG_LIBS="$F77_GETARG_LIBS" AC_SUBST(FC_GETARG_LIBS) # F77SPAWNARGTEST is set to "#" to comment out tests in # f77/spawn/testlist.in that require non-standard extensions to # access the commandline AC_SUBST(F77SPAWNARGTEST) # ALLOCMEMF is set in f77/ext/testlist if we can try this # Fortran extension ALLOCMEMF="" PAC_PROG_F77_CRAY_POINTER([ ALLOCMEMF="allocmemf 1" FFLAGS="$FFLAGS $CRAYPTR_FFLAGS" ]) AC_SUBST(ALLOCMEMF) # See the f90 block of code for the Fortran 90 version of ALLOCMEMF, # i.e. ALLOCMEMFC. fi # Set a default for the Fortran 77 version of MPI_Offset. if test -z "$F77_MPI_OFFSET" ; then F77_MPI_OFFSET="integer*8" AC_MSG_WARN([Selecting integer*8 as the Fortran type for MPI_Offset]) fi AC_SUBST(F77_MPI_OFFSET) # FIXME: Find a way to get the correct value if test -z "$F77_MPI_ADDRESS" ; then F77_MPI_ADDRESS="integer" AC_MSG_WARN([Selecting integer as the Fortran type for MPI_Aint]) fi AC_SUBST(F77_MPI_ADDRESS) # Running Fortran 90+ compiler tests PAC_PROG_FC if test "$enable_fc" = yes ; then # Work around feature in autoconf that adds -g -O2 to FCFLAGS saveFCFLAGS="$FCFLAGS" FCFLAGS="$saveFCFLAGS" # If there is no working FC, then set enable_fc to no if test -z "$FC" ; then enable_fc=no fi fi f90dir="#" AC_SUBST(f90dir) # First, see if we have an f90 compiler. This uses code similar to that # in the MPICH2 top-level configure if test "$enable_fc" = yes -a "$enable_f77" = yes ; then PAC_PROG_FC_WORKS if test -z "$FC" -o "$pac_cv_prog_fc_works" != yes ; then enable_fc=no fi fi dnl If enable_fc=yes up to this point then enable_f77=yes also dnl PAC_PROG_FC and PAC_PROG_FC_WORKS return OK if test "$enable_fc" = yes ; then # Make sure that the compilers are compatible. This # will also make sure that the program named in FC is # a working Fortran 90 compiler # Only check if we're *not* building within MPICH2 # (MPICH2 will have made the test) # FIXME: Do we want to check only simple routine names # (those without an underscore?) if test "$FROM_MPICH2" != yes ; then PAC_FC_AND_F77_COMPATIBLE(enable_fc=yes,enable_fc=no) fi fi if test "$enable_fc" = yes ; then if test "$ac_fc_srcext" != "f90" ; then AC_LANG_PUSH([Fortran]) AC_FC_SRCEXT([f90],[ FCFLAGS="$FCFLAGS $FCFLAGS_f90" ],[ AC_MSG_WARN([Fortran 90 test being disabled because the $FC compiler does not accept a .f90 extension]) f90dir=# enable_fc=no ]) AC_LANG_POP([Fortran]) fi # The Fortran90 tests rely on free-form input which needs to be tested # before any test that may modify FCFLAGS, e.g. the cray-pointer test. # The order of the tests is important in compiler like g95. AC_FC_FREEFORM # See if the compiler supports the Cray-style pointers ALLOCMEMFC="" PAC_PROG_FC_CRAY_POINTER([ ALLOCMEMFC="allocmemf90 1" FCFLAGS="$FCFLAGS $CRAYPTR_FCFLAGS" ]) AC_SUBST(ALLOCMEMFC) # Check for the new command line routines used in one of the spawn tests AC_LANG_PUSH([Fortran]) F03SPAWNARGTEST="" AC_MSG_CHECKING([whether $FC supports the Fortran 2003 routines to access the commandline]) AC_LINK_IFELSE([AC_LANG_PROGRAM([],[ character*64 s integer i i = command_argument_count() call get_command_argument(i,s) ])],[pac_cv_fc_has_args=yes],[pac_cv_fc_has_args=no]) AC_MSG_RESULT($pac_cv_fc_has_args) if test "$pac_cv_fc_has_args" != "yes" ; then F03SPAWNARGTEST="#" fi # F03SPAWNARGTEST is set to "#" to comment out tests in # f90/spawn/testlist.in that require Fortran 2003 features to # access the commandline AC_SUBST(F03SPAWNARGTEST) AC_LANG_POP([Fortran]) if test -f f77/init/checksizes.c ; then # If it is a VPATH build, f90/init may not be there. if test ! -d f90/init ; then mkdir f90 mkdir f90/init fi cp f77/init/checksizes.c f90/init fi fi # if test "$FROM_MPICH2" = yes ; then if test "$enable_fc" = yes ; then otherlangs="$otherlangs f90" f90dir=f90 fi elif test "$enable_fc" = yes ; then AC_MSG_CHECKING([that we can build MPI programs with Fortran 90]) AC_LANG_PUSH([Fortran]) AC_LINK_IFELSE([ AC_LANG_SOURCE([ program main use mpi integer ierr call mpi_init(ierr) call mpi_finalize(ierr) end ]) ],[ AC_MSG_RESULT(yes) otherlangs="$otherlangs f90" f90dir=f90 ],[ AC_MSG_RESULT(no) ]) AC_LANG_POP([Fortran]) fi AM_CONDITIONAL([BUILD_F90_TESTS],[test "X$f90dir" = "f90"]) # Running C++ compiler tests PAC_PROG_CXX if test "$enable_cxx" = yes ; then if test -z "$CXX" ; then enable_cxx=no fi fi # Simple tests for which other languages we can handle cxxdir="#" AC_SUBST(cxxdir) if test "$FROM_MPICH2" = yes ; then if test "$enable_cxx" = yes ; then otherlangs="$otherlangs cxx" cxxdir=cxx fi elif test "$enable_cxx" = yes ; then AC_MSG_CHECKING([that we can build MPI programs with C++]) AC_LANG_PUSH([C++]) AC_LINK_IFELSE([ AC_LANG_PROGRAM([ #include "mpi.h" ],[ MPI::Init(); MPI::Finalize(); ]) ],[ AC_MSG_RESULT(yes) otherlangs="$otherlangs cxx" cxxdir=cxx ],[ AC_MSG_RESULT(no) ]) AC_LANG_POP([C++]) fi if test "$enable_cxx" = yes ; then AC_CACHE_CHECK([whether available],pac_cv_cxx_has_iostream,[ AC_LANG_PUSH([C++]) AC_COMPILE_IFELSE([ AC_LANG_PROGRAM([#include ],[using namespace std;]) ],[pac_cv_cxx_has_iostream=yes],[pac_cv_cxx_has_iostream=no]) ]) if test "$pac_cv_cxx_has_iostream" = yes ; then AC_DEFINE(HAVE_IOSTREAM,1,[Define if iostream is available]) else # Look for iostream.h (in C++ mode, we need the full name) AC_CHECK_HEADERS(iostream.h) if test "$ac_cv_header_iostream_h" != yes ; then AC_MSG_ERROR([C++ compiler $CXX $CXXFLAGS has neither iostream nor iostream.h.]) fi # Warning: the autoconf macros will fall back onto /lib/cpp for # C and C++ preprocessing *without* checking that /lib/cpp even # exists. if test "$CXXCPP" = "/lib/cpp" ; then if test ! -x "/lib/cpp" ; then AC_MSG_WARN([Warning: Autoconf error, could not find a C++ Preprocessor. Using false for the preprocessor so that tests will continue.]) CXXCPP=false fi fi fi AX_CXX_NAMESPACE_STD if test "$ac_cv_cxx_namespaces" != yes ; then AC_MSG_WARN([The compiler $CXX does not support C++ namespaces. This may cause problems for the tests]) fi AC_LANG_POP([C++]) fi AM_CONDITIONAL([BUILD_CXX_TESTS],[test "X$cxxdir" = "cxx"]) AC_LANG_C # IO iodir="#" if test "$enable_romio" != no ; then iodir=io AC_DEFINE(HAVE_MPI_IO,1,[Define if MPI-IO (really ROMIO) is included]) if test "$FROM_MPICH2" = yes ; then # MPICH2 no longer uses and MPIO_Request pac_cv_have_mpio_request=no else AC_CACHE_CHECK([whether MPIO_Request is defined for MPI IO], pac_cv_have_mpio_request,[ AC_COMPILE_IFELSE([ AC_LANG_PROGRAM([#include "mpi.h"],[MPIO_Request r;]) ],[pac_cv_have_mpio_request=yes],[pac_cv_have_mpio_request=no]) ]) fi if test "$pac_cv_have_mpio_request" = no ; then AC_DEFINE(MPIO_USES_MPI_REQUEST,,[Define if MPI IO uses MPI_Request]) fi fi AC_SUBST(iodir) # # MPI_INTEGER16 is mentioned in only one place in MPI 2.1, and some # implementations may have missed it. Check to see if it is available in # C. if test "$FROM_MPICH2" = yes ; then # MPICH2 correctly includes this type. pac_cv_have_mpi_integer16=yes else AC_CACHE_CHECK([whether MPI_INTEGER16 is available], pac_cv_have_mpi_integer16,[ AC_COMPILE_IFELSE([ AC_LANG_PROGRAM([#include "mpi.h"],[ MPI_Datatype t = MPI_INTEGER16; ]) ],[pac_cv_have_mpi_integer16=yes],[pac_cv_have_mpi_integer16=no]) ]) fi if test "$pac_cv_have_mpi_integer16" = yes ; then AC_DEFINE(HAVE_MPI_INTEGER16,1,[Define if MPI_INTEGER16 is available]) fi AC_CACHE_CHECK([whether MPI_2DOUBLE_COMPLEX is available], pac_cv_have_mpi_2double_complex,[ AC_COMPILE_IFELSE([ AC_LANG_PROGRAM([#include "mpi.h"],[ MPI_Datatype t = MPI_2DOUBLE_COMPLEX; ]) ],[ pac_cv_have_mpi_2double_complex=yes ],[ pac_cv_have_mpi_2double_complex=no ]) ]) if test "$pac_cv_have_mpi_2double_complex" = yes ; then AC_DEFINE(HAVE_MPI_2DOUBLE_COMPLEX,1,[Define if MPI_2DOUBLE_COMPLEX is available]) fi # 2COMPLEX was in MPI 1.0 and removed after that. This allows us to # test 2COMPLEX if it is present AC_CACHE_CHECK([whether MPI_2COMPLEX is available], pac_cv_have_mpi_2complex,[ AC_COMPILE_IFELSE([ AC_LANG_PROGRAM([#include "mpi.h"],[ MPI_Datatype t = MPI_2COMPLEX; ]) ],[ pac_cv_have_mpi_2complex=yes ],[ pac_cv_have_mpi_2complex=no ]) ]) if test "$pac_cv_have_mpi_2complex" = yes ; then AC_DEFINE(HAVE_MPI_2COMPLEX,1,[Define if MPI_2COMPLEX is available]) fi # MPI_Aint was intended as an address-sized int. However, MPI didn't # specify this - MPI_Aint must be large enough to hold an address-sized # integer, but it can be larger. To get clean compilation in some places, # we need a pointer-sized integer. The following code looks for one. # Make sure we are using the local C compiler (if the local # machine is different that the system that MPICC is for, then # set the cross-compilation feature) AC_CHECK_SIZEOF(void *) AC_CHECK_SIZEOF(int) AC_CHECK_SIZEOF(long) AC_CHECK_SIZEOF(long long) AC_CHECK_SIZEOF(short) POINTERINT=MPI_Aint AC_MSG_CHECKING([for C integer type of address size]) for type in int long long_long short ; do eval len=\$ac_cv_sizeof_$type if test "$len" = "$ac_cv_sizeof_void_p" ; then POINTERINT=`echo $type | sed -e 's/_/ /'` break fi done AC_MSG_RESULT($POINTERINT) AC_DEFINE_UNQUOTED(POINTERINT_t,$POINTERINT,[POINTERINT_t is a pointer-sized integer]) # Find perl; used to create some of the tests from template and # defintion files AC_PATH_PROG(PERL,perl) AC_SUBST(PERL) AC_SUBST(otherlangs) AC_SUBST(threadsdir) AC_SUBST(MPIEXEC) AC_SUBST(MAKE) if test -z "$MPILIBNAME" ; then MPILIBNAME=mpich ; fi AC_SUBST(MPILIBNAME) dnl MPI_SOURCE may be set as an environment variable giving the location dnl of the MPI implementation. This is used only in runtests to include dnl the location of the source of the MPI implementation into the XML dnl summary file AC_SUBST(MPI_SOURCE) if test "$FROM_MPICH2" = yes ; then # Set compilers/flags to be substituted in output files, e.g. Makefiles. LDFLAGS="$saveLDFLAGS" # note that the default definition of bindir is # '${exec_prefix}/bin' # so even if prefix is set, exec prefix is not until # the very last moment (i.e., not here). if test "X$exec_prefix" = "XNONE" ; then saveExec_prefix=$exec_prefix if test "X$prefix" = "XNONE" ; then # Use the default exec_prefix=$ac_default_prefix else exec_prefix=$prefix fi # Evaluate with the current setting of exec_prefix eval mpibindir=${bindir} exec_prefix=$saveExec_prefix else eval mpibindir=${bindir} fi # we did our tests with the base compilers, now point the make system at the # installed compiler wrappers for actually building the tests CC=$mpibindir/mpicc F77=$mpibindir/mpif77 FC=$mpibindir/mpif90 CXX=$mpibindir/mpicxx MPIEXEC=$mpibindir/mpiexec # Zero out the flags, since they are already contained in the compiler # wrapper scripts. Note that this will kill any flags that have been added # to the xFLAGS only in this script. # # The only real flags we seem to add in this script relate to cray # pointer support in Fortran, so we include that var here where # appropriate. # # The other case are the performance tests - for datatype performance, # compiling with optimization is important. CFLAGS="" CPPFLAGS="" LDFLAGS="" LIBS="" FFLAGS="$CRAYPTR_FFLAGS" FCFLAGS="$CRAYPTR_FCFLAGS" CXXFLAGS="" else # We need either mpiexec or mpirun. If we don't find them, # the user will need to determine how to run a program AC_PATH_PROG(MPIEXEC,mpiexec) fi AC_OUTPUT_COMMANDS([chmod a+x maint/testmerge]) AC_OUTPUT_COMMANDS([chmod a+x runtests checktests]) AC_OUTPUT_COMMANDS([chmod a+x manual/manyconnect]) dnl Note that this format for AC_OUTPUT can cause problems for autoconf dnl run under cygwin AC_OUTPUT(maint/testmerge \ runtests \ checktests \ Makefile \ basic/Makefile \ attr/Makefile \ util/Makefile \ coll/Makefile \ comm/Makefile \ datatype/Makefile \ errhan/Makefile \ group/Makefile \ info/Makefile \ init/Makefile \ pt2pt/Makefile \ rma/Makefile \ spawn/Makefile \ topo/Makefile \ io/Makefile \ f77/Makefile \ f77/attr/Makefile \ f77/attr/attraints.h \ f77/pt2pt/attr1aints.h \ f77/ext/add1size.h \ f77/datatype/Makefile \ f77/datatype/typeaints.h \ f77/util/Makefile \ f77/coll/Makefile \ f77/comm/Makefile \ f77/topo/Makefile \ f77/init/Makefile \ f77/rma/addsize.h \ f77/pt2pt/Makefile \ f77/info/Makefile \ f77/spawn/Makefile \ f77/spawn/testlist \ f77/spawn/type1aint.h \ f77/rma/Makefile \ f77/ext/Makefile \ f77/ext/testlist \ f77/io/Makefile \ f77/io/iooffset.h \ f77/io/iodisp.h \ f77/io/ioaint.h \ f90/Makefile \ f90/attr/Makefile \ f90/datatype/Makefile \ f90/f90types/Makefile \ f90/util/Makefile \ f90/coll/Makefile \ f90/comm/Makefile \ f90/topo/Makefile \ f90/init/Makefile \ f90/pt2pt/Makefile \ f90/rma/Makefile \ f90/info/Makefile \ f90/spawn/Makefile \ f90/spawn/testlist \ f90/timer/Makefile \ f90/ext/Makefile \ f90/ext/testlist \ f90/io/Makefile \ f90/misc/Makefile \ cxx/Makefile \ cxx/util/Makefile \ cxx/attr/Makefile \ cxx/pt2pt/Makefile \ cxx/comm/Makefile \ cxx/coll/Makefile \ cxx/errhan/Makefile \ cxx/info/Makefile \ cxx/datatype/Makefile \ cxx/io/Makefile \ cxx/init/Makefile \ cxx/rma/Makefile \ cxx/spawn/Makefile \ threads/Makefile \ threads/pt2pt/Makefile \ threads/util/Makefile \ threads/comm/Makefile \ threads/init/Makefile \ threads/spawn/Makefile \ errors/Makefile \ errors/attr/Makefile \ errors/basic/Makefile \ errors/coll/Makefile \ errors/comm/Makefile \ errors/datatype/Makefile \ errors/faults/Makefile \ errors/group/Makefile \ errors/pt2pt/Makefile \ errors/rma/Makefile \ errors/spawn/Makefile \ errors/topo/Makefile \ errors/io/Makefile \ errors/cxx/Makefile \ errors/cxx/errhan/Makefile \ errors/cxx/io/Makefile \ errors/f77/Makefile \ errors/f90/Makefile \ manual/Makefile \ manual/manyconnect \ perf/Makefile \ testlist \ cxx/testlist \ f77/testlist \ f90/testlist \ threads/testlist \ errors/testlist \ errors/cxx/testlist \ )