AC_PREREQ(2.63)

# 

# (C) 2006 by Argonne National Laboratory.

#     See COPYRIGHT in top-level directory.

#

dnl Process this file with autoconf to produce a configure script.

dnl

dnl aclocal_cache.m4, included by sowing/confdb/aclocal.m4, fixes 

dnl bugs in autoconf caching.

dnl

dnl This is a large configure script and it is important to keep it

dnl clearly organized.  In addition, this script must coordinate with 

dnl the other modules that can be used to construct MPICH, such as

dnl the communication device and the process manager.  Each of these

dnl may have special features or limitations that other modules or

dnl this configure may need to take into account.  To handle this, there

dnl are xx major steps in this configure script:

dnl

dnl 1. Identify major modules and source any prerequisite scripts

dnl 2. Determine compiler characteristics 

dnl 3. Setup and configure the other modules

dnl 4. Determine MPI features and characteristics (such as datatype values)

dnl

dnl Each of these is described in more detail below.

dnl

dnl 1. Identify the modules (most are specified by 

dnl --with-<modulename>=instance,

dnl for example, --with-pm=hydra or --with-device=ch3:nemesis).

dnl For each module, source the file mpichprereq if present (in the

dnl module's top-level directory).  This

dnl must be a bourne (sh) shell script; it can access any of the variables

dnl in the configure script.  In addition, there are a few variables that

dnl are defined and provided to allow the modules to communicate their 

dnl needs or limitations to the other modules.  These are:

dnl    MPID_MAX_THREAD_LEVEL - thread level supported by device.

dnl                            if unset, is MPI_THREAD_FUNNELED

dnl    MPID_NO_LONG_LONG     - if yes, the device does not support the 

dnl                            long long integer type

dnl    MPID_NO_LONG_DOUBLE   - if yes, the device does not support the

dnl                            long double type

dnl    MPID_PM_NAMESERVER    - if set, provides the name of the nameserver

dnl                            that the process manager supports.

dnl                            This name server will be used if the

dnl                            default name server is selected.

dnl    MPID_NO_PM            - If yes, the device does not require any

dnl                            PM implementation.  

dnl    MPID_MAX_PROCESSOR_NAME - The maximum number of character in a processor

dnl                            name.  If not set, 128 will be used.

dnl    MPID_MAX_ERROR_STRING - The maximum number of character in an error

dnl                            string.  If not set, 1024 will be used.

dnl    PM_REQUIRES_PMI       - if set, provides the name of the PMI 

dnl                            interface implementation.  If not set,

dnl                            the "simple" PMI implementation is used.

dnl                            A process manager that needs a particular

dnl                            process manager should check that this is

dnl                            not set to an incompatible value.

dnl    MPID_NO_SPAWN         - if yes, the device does not support the

dnl                            dynamic process routines (spawn, connect

dnl                            attach, join, plus port and publish 

dnl                            routines).  The major effect of this

dnl                            is to let the test codes know that

dnl                            spawn is not implemented.

dnl    MPID_NO_RMA           - if yes, the device does not support the

dnl                            MPI RMA routines (MPI_Win_create and 

dnl                            MPI_Put etc.).  The major effect of this

dnl                            is to let the test codes know that 

dnl                            RMA is not implemented.

dnl

dnl Note that the meanings of these variables are defined so that an 

dnl undefined value gives the default.  This makes it easy to expand

dnl the set of such variables, since only modules that need the new

dnl variable will need to be changed.

dnl

dnl 2. Determine compiler characteristics

dnl Here is where features of the compilers are determined, including

dnl support for shared libraries and sizes of the basic datatype types.

dnl

dnl 3. Setup and configure the other modules

dnl Before each module configure is executed, the script setup_<module>

dnl is run if present.  This is a bourne (sh) shell script and may

dnl access configure variables.  It should not make any changes to the

dnl compiler name or flags (e.g., do not add -D_XOPEN_SOURCE to CFLAGS here,

dnl because that may invalidate the determination of the compiler 

dnl characteristics in the prior step).

dnl

dnl 4. Determine MPI features

dnl    

dnl

dnl Special environment variables

dnl To let other scripts and in particular the configure in test/mpi

dnl know that they are being invoked from within the MPICH configure,

dnl the following environment variables are set and exported:

dnl    FROM_MPICH

dnl    MPICH_ENABLE_F77

dnl    MPICH_ENABLE_FC

dnl    MPICH_ENABLE_CXX

dnl

dnl Note that no executable statements are allowed (and any are silently 

dnl dropped) before AC_INIT.

m4_include([maint/version.m4])

dnl 2nd arg is intentionally underquoted

AC_INIT([MPICH],

        MPICH_VERSION_m4,

        [discuss@mpich.org],

        [mpich],

        [http://www.mpich.org/])

if test "x$prefix" != "xNONE" && test -d "$prefix"; then 

    if test "x`(cd \"$prefix\"; echo \"$PWD\")`" = "x`(cd \"$srcdir\"; echo \"$PWD\")`" ||\

       test "x`(cd \"$prefix\"; echo \"$PWD\")`" = "x$PWD"  ; then

        AC_MSG_ERROR([The install directory (--prefix=) cannot be the same as the build or src directory.])

    fi

fi         

CONFIGURE_ARGS_CLEAN=`echo $* | tr '"' ' '`

AC_SUBST(CONFIGURE_ARGS_CLEAN)

# these values come from the m4_include above

MPICH_VERSION=MPICH_VERSION_m4

AC_SUBST([MPICH_VERSION])

MPICH_RELEASE_DATE="MPICH_RELEASE_DATE_m4"

AC_SUBST([MPICH_RELEASE_DATE])

libmpi_so_version="libmpi_so_version_m4"

AC_SUBST([libmpi_so_version])

if test -z "$MPICH_VERSION" ; then

    AC_MSG_ERROR([MPICH_VERSION is empty, check maint/version.m4 for errors])

fi

# Produce a numeric version assuming the following format:

# Version: [MAJ].[MIN].[REV][EXT][EXT_NUMBER]

# Example: 1.0.7rc1 has

#          MAJ = 1

#          MIN = 0

#          REV = 7

#          EXT = rc

#          EXT_NUMBER = 1

#

# Converting to numeric version will convert EXT to a format number:

#          ALPHA (a) = 0

#          BETA (b)  = 1

#          RC (rc)   = 2

#          PATCH (p) = 3

# Regular releases are treated as patch 0

#

# Numeric version will have 1 digit for MAJ, 2 digits for MIN,

# 2 digits for REV, 1 digit for EXT and 2 digits for EXT_NUMBER.

changequote(<<,>>)

V1=`expr $MPICH_VERSION : '\([0-9]*\)\.[0-9]*\.*[0-9]*[a-zA-Z]*[0-9]*'`

V2=`expr $MPICH_VERSION : '[0-9]*\.\([0-9]*\)\.*[0-9]*[a-zA-Z]*[0-9]*'`

V3=`expr $MPICH_VERSION : '[0-9]*\.[0-9]*\.*\([0-9]*\)[a-zA-Z]*[0-9]*'`

V4=`expr $MPICH_VERSION : '[0-9]*\.[0-9]*\.*[0-9]*\([a-zA-Z]*\)[0-9]*'`

V5=`expr $MPICH_VERSION : '[0-9]*\.[0-9]*\.*[0-9]*[a-zA-Z]*\([0-9]*\)'`

changequote([,])

if test "$V2" -le 9 ; then V2=0$V2 ; fi

if test "$V3" = "" ; then V3=0; fi

if test "$V3" -le 9 ; then V3=0$V3 ; fi

if test "$V4" = "a" ; then

    V4=0

elif test "$V4" = "b" ; then

    V4=1

elif test "$V4" = "rc" ; then

    V4=2

elif test "$V4" = "" ; then

    V4=3

    V5=0

elif test "$V4" = "p" ; then

    V4=3

fi

if test "$V5" -le 9 ; then V5=0$V5 ; fi

MPICH_NUMVERSION=`expr $V1$V2$V3$V4$V5 + 0`

AC_SUBST(MPICH_NUMVERSION)

AC_ARG_WITH(custom-version-string,

            AC_HELP_STRING([--with-custom-version-string], [Adds a user-specified value to the output of the mpichversion executable]),,with_custom_version_string="")

MPICH_CUSTOM_STRING=$with_custom_version_string

AC_SUBST(MPICH_CUSTOM_STRING)

# ABIVERSION is the name used by simplemake, so we reassign the

# libmpi_so_version number to it

ABIVERSION=${libmpi_so_version}

export ABIVERSION

export libmpi_so_version

AC_SUBST(ABIVERSION)

# Print out the configure options

CONFIGURE_ARGUMENTS="$ac_configure_args"

AC_SUBST(CONFIGURE_ARGUMENTS)

if test -n "$ac_configure_args" ; then

    echo "Configuring MPICH version $MPICH_VERSION with $ac_configure_args"

else 

    echo "Configuring MPICH version $MPICH_VERSION"

fi

# Add the information on the system:

echo "Running on system: `uname -a`"

dnl Definitions will be placed in this file rather than in the DEFS variable

AC_CONFIG_HEADER(src/include/mpichconf.h)

AH_TOP([/* -*- Mode: C; c-basic-offset:4 ; -*- */

/*

 *  (C) 2001 by Argonne National Laboratory.

 *      See COPYRIGHT in top-level directory.

 */

#ifndef MPICHCONF_H_INCLUDED

#define MPICHCONF_H_INCLUDED

])

# We use an #include strategy here because all of the alternative strategies for

# quashing these variables have various drawbacks.  The alternatives are listed

# here to avoid rediscovery of these problems by someone else in the future:

#

# 1) Strategy: Rewrite mpichconf.h.in with sed at autogen.sh time.

#    Problem: Automatic remaking of config.status and friends will re-run

#             autoheader and blow away our sed changes without an opportunity to

#             patch the resulting file again.

# 2) Strategy: Add literal "#undef PACKAGE" lines to the AH_BOTTOM text.

#    Problem: These lines get rewritten by config.status to be "#define" lines,

#             so the intended quashing never actually occurs.

# 3) Strategy: Use AC_CONFIG_COMMANDS to run a sed rewrite command on

#              mpichconf.h at config.status time.

#    Problem: Causes mpichconf.h to always be rewritten, first by the normal

#             config.status commands and then by sed.  This can cause

#             unnecessary remaking of object files since nearly every C source

#             file includes this header (see the Autoconf Manual, "Automatic

#             Remaking")

#

# The only other plausible strategy would seem to be rewriting config.status

# itself via AC_CONFIG_COMMANDS_POST, but that seems error prone.  The best

# solution would be to stop all subconfigures from including config.h headers

# from other packages.  Then all of this nonsense can be eliminated.

# [goodell@ 2011-08-26]

AH_BOTTOM([

/* Include nopackage.h to undef autoconf-defined macros that cause conflicts in

 * subpackages.  This should not be necessary, but some packages are too

 * tightly intertwined right now (such as ROMIO and the MPICH core) */

#include "nopackage.h"

#endif /* !defined(MPICHCONF_H_INCLUDED) */

])

dnl Set the directory that contains support scripts such as install-sh and

dnl config.guess

AC_CONFIG_AUX_DIR(confdb)

dnl our macro dir is the same as our aux dir

AC_CONFIG_MACRO_DIR([confdb])

# Set the FROM_MPICH variable to tell subconfigures that they are

# built from within MPICH

FROM_MPICH=yes

export FROM_MPICH

# Save a copy of precious flags as USER_* before any of these flags

# are being modified by configure tests.

PAC_PREFIX_ALL_FLAGS(USER)

# WRAPPER_xFLAGS are used by mpicc and friends.

#

# WRAPPER_CFLAGS and other compile flags are used for compile options

# that are added by MPICH, but should be used by applications (such

# as include paths).

#

# All libraries that are detected by MPICH as needed for some of its

# functionality (such as -lpthread) should be added to WRAPPER_LIBS

# so executables built within MPICH use them.  If inter-library

# dependencies are not supported on the platform, these libraries are

# added to the MPICH wrappers (mpicc and friends) as well.

PAC_PREFIX_ALL_FLAGS(WRAPPER)

# MPICH_MPIx_FLAGS are used by mpicc and friends.  They are like

# WRAPPER flags, but these are provided by the user.

AC_SUBST(MPICH_MPICC_CPPFLAGS)

AC_SUBST(MPICH_MPICC_CFLAGS)

AC_SUBST(MPICH_MPICC_LDFLAGS)

AC_SUBST(MPICH_MPICC_LIBS)

AC_SUBST(MPICH_MPICXX_CPPFLAGS)

AC_SUBST(MPICH_MPICXX_CXXFLAGS)

AC_SUBST(MPICH_MPICXX_LDFLAGS)

AC_SUBST(MPICH_MPICXX_LIBS)

AC_SUBST(MPICH_MPIF77_CPPFLAGS)

AC_SUBST(MPICH_MPIF77_FFLAGS)

AC_SUBST(MPICH_MPIF77_LDFLAGS)

AC_SUBST(MPICH_MPIF77_LIBS)

AC_SUBST(MPICH_MPIFORT_CPPFLAGS)

AC_SUBST(MPICH_MPIFORT_FCFLAGS)

AC_SUBST(MPICH_MPIFORT_LDFLAGS)

AC_SUBST(MPICH_MPIFORT_LIBS)

# Add MPICHLIB_* to the appropriate flags

AC_ARG_VAR(MPICHLIB_CFLAGS,

	[extra CFLAGS used in building MPICH libraries])

AC_ARG_VAR(MPICHLIB_CPPFLAGS,

	[extra CPPFLAGS used in building MPICH libraries])

AC_ARG_VAR(MPICHLIB_CXXFLAGS,

	[extra CXXFLAGS used in building MPICH libraries])

AC_ARG_VAR(MPICHLIB_FFLAGS,

	[extra FFLAGS used in building MPICH libraries])

AC_ARG_VAR(MPICHLIB_FCFLAGS,

	[extra FCFLAGS used in building MPICH libraries])

CFLAGS="$CFLAGS $MPICHLIB_CFLAGS"

CPPFLAGS="$CPPFLAGS $MPICHLIB_CPPFLAGS"

CXXFLAGS="$CXXFLAGS $MPICHLIB_CXXFLAGS"

FFLAGS="$FFLAGS $MPICHLIB_FFLAGS"

FCFLAGS="$FCFLAGS $MPICHLIB_FCFLAGS"

dnl include all subsystem m4 fragments now that the core autoconf functionality

dnl has been setup.  No fragment should do anything except define

dnl PAC_SUBCFG_{PREREQ,BODY} macros which will be expanded later as

dnl appropriate

# begin subsys includes

m4_include([subsys_include.m4])

# end subsys includes

dnl ----------------------------------------------------------------------------

dnl setup top-level argument handling

AC_ARG_ENABLE(echo, 

	AC_HELP_STRING([--enable-echo], [Turn on strong echoing. The default is enable=no.]),

	set -x)

AC_ARG_ENABLE(error-checking,

[  --enable-error-checking=level

      Control the amount of error checking.  

        no        - no error checking

        runtime   - error checking controllable at runtime through environment 

                    variables

        all       - error checking always enabled (default)

],,enable_error_checking=all)

AC_ARG_ENABLE(error-messages,

[  --enable-error-messages=level - Control the amount of detail in error messages.

        all       - Maximum amount of information

        generic   - Only generic messages (no information about the specific

                    instance)

        class     - One message per MPI error class

        none      - No messages

],,enable_error_messages=all)

AC_ARG_ENABLE(tag-error-bits,

[  --enable-tag-error-bits=yes|no - Control whether bits are taken from the user tag for error handling.

        yes       - Two bits are taken from the user tag to support error propagation.

        no        - No bits are taken from the user tag (this could cause deadlock if an error is detected during a collective).

],,enable_tag_error_bits=yes)

AC_ARG_ENABLE(timing,

[  --enable-timing=level - Control the amount of timing information

                           collected by the MPICH implementation.

        none    - Collect no data (default)

        all     - Collect lots of data

        runtime - Runtime control of data collected

],,enable_timing=default)

AC_ARG_ENABLE(g,

[  --enable-g=option - Control the level of debugging support in the

                       MPICH implementation.  "option" is a list of comma

                       separated names including.  Default is "most".

        none     - No debugging

        handle   - Trace handle operations

        handlealloc - Trace handle allocations

        dbg      - Add compiler flag, -g, to all internal

                   compiler flags, i.e. MPICHLIB_CFLAGS, MPICHLIB_CXXFLAGS,

                   MPICHLIB_FFLAGS, and MPICHLIB_FCFLAGS.

        debug    - Synonym for dbg

        mem      - Memory usage tracing

        meminit  - Preinitialize memory associated structures and unions to

                   eliminate access warnings from programs like valgrind

        memarena - Check for overwrite errors in memory allocation arena

        mutex    - Enable error checking on pthread mutexes

        mutexnesting - Check for non-nesting of mutexes

        most     - Most of the above options, excluding some with severe

                   performance impacts.  Recommended for typical development.

        yes      - synonym for "most" (*not* "all")

        all      - All of the above choices

],,enable_g=none)

AC_ARG_ENABLE([mpit-pvars],

[  --enable-mpit-pvars=list - Selectively enable MPI_T performance variables in

                      modules. list is a comma-separated module names,

                      including (Default is "none"):

        none     - No performance info recorded

        recvq    - All message queue-related

        nem      - All nemesis-related

        rma      - All rma-related

        all      - All variables above

],[],[enable_mpit_pvars=none])

dnl We may want to force MPI_Aint to be the same size as MPI_Offset, 

dnl particularly on 32 bit systems with large (64 bit) file systems.

AC_ARG_WITH(aint-size,

	AC_HELP_STRING([--with-aint-size], [Override the size of MPI_AINT (in bytes)]),,

	with_aint_size=0)

AC_ARG_ENABLE(fast,

[  --enable-fast=option - Control the level of fast execution in the

                         MPICH implementation.  option is a list of

                         comma separated names including

        O<n>     - Appends default optimization flags, -O<n>, to all internal

                   compiler flags, i.e. MPICHLIB_CFLAGS, MPICHLIB_CXXFLAGS,

                   MPICHLIB_FFLAGS, and MPICHLIB_FCFLAGS. (default is -O2)

        ndebug   - Appends -DNDEBUG to MPICHLIB_CFLAGS.

        all|yes  - "O2" and "ndebug" are enabled

        none     - None of above options, i.e. --disable-fast

],,enable_fast=O2)

AC_ARG_ENABLE(interlib-deps,

	[AC_HELP_STRING([--enable-interlib-deps - Enable interlibrary dependencies])],,enable_interlib_deps=yes)

AC_ARG_ENABLE(check-compiler-flags,

	AC_HELP_STRING([--enable-check-compiler-flags], [enable the checks for all compiler

                       options, xxxFLAGS, MPICH_xxxFLAGS. Default is on.]),,

		       enable_check_compiler_flags=yes)

dnl We enable f77 and fc if we can find compilers for them.

dnl In addition, we check whether f77 and fc can work together.

AC_ARG_ENABLE(fortran,

[  --enable-fortran=option - Control the level of Fortran support in the MPICH implementation.

	yes|all   - Enable all available Fortran implementations (F77, F90+)

	f77       - Enable Fortran 77 support

	fc        - Enable Fortran 90 and 2008 support

	no|none   - No Fortran support

],,[enable_fortran=all])

AC_ARG_ENABLE(f77,

	AC_HELP_STRING([--enable-f77],

		[DEPRECATED: Use --enable-fortran or --disable-fortran instead]),,[enable_f77=yes])

AC_ARG_ENABLE(fc,

	AC_HELP_STRING([--enable-fc],

		[DEPRECATED: Use --enable-fortran or --disable-fortran instead]),,[enable_fc=yes])

AC_ARG_ENABLE(cxx,

	AC_HELP_STRING([--enable-cxx], [Enable C++ bindings]),,enable_cxx=yes)

AC_ARG_ENABLE(romio,

	AC_HELP_STRING([--enable-romio], [Enable ROMIO MPI I/O implementation]),,

	enable_romio=yes)

AC_ARG_ENABLE(debuginfo,

	AC_HELP_STRING([--enable-debuginfo], [Enable support for debuggers]),,

	enable_debuginfo=no)

## Enable creation of libtool-style versioning or no versioning

AC_ARG_ENABLE(versioning,

        [AC_HELP_STRING([--enable-versioning],[Enable library versioning])],,

        [enable_versioning=yes])

if test "$enable_versioning" = "yes" ; then

   ABIVERSIONFLAGS="-version-info \$(ABIVERSION)"

else

   ABIVERSIONFLAGS="-avoid-version"

fi

export ABIVERSIONFLAGS

AC_SUBST(ABIVERSIONFLAGS)

dnl The environment variable MPICH_DEBUGLIBNAME may be used to

dnl override the default name of the library that the debugger will

dnl load to access the MPICH internal data structures.

dnl "default" is a special device that allows MPICH to choose one

dnl based on the environment.

AC_ARG_WITH(device,

	AC_HELP_STRING([--with-device=name], [Specify the communication device for MPICH]),,

	with_device=default)

AC_ARG_WITH(pmi,

	AC_HELP_STRING([--with-pmi=name], [Specify the pmi interface for MPICH]),,

	with_pmi=default)

AC_ARG_WITH(pm, 

	AC_HELP_STRING([--with-pm=name],

		[Specify the process manager for MPICH.  "no" or "none" are

                 valid values.  Multiple process managers may be specified as

                 long as they all use the same pmi interface by separating them

                 with colons.  The mpiexec for the first named process manager

                 will be installed.  Example: "--with-pm=hydra:gforker"

                 builds the two process managers hydra, and gforker;

                 only the mpiexec from hydra is installed into the bin

                 directory.]),,with_pm=default)

AC_ARG_WITH(logging,

	AC_HELP_STRING([--with-logging=name], [Specify the logging library for MPICH]),

	[if test -z "$withval" ; then with_logging=rlog ; fi],with_logging=none)

AC_ARG_ENABLE(threads,

[  --enable-threads=level - Control the level of thread support in the 

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

        runtime         - Alias to "multiple"

        See also the --enable-thread-cs option for controlling the granularity of

        the concurrency inside of the library

],,enable_threads=default)

AC_ARG_ENABLE(thread-cs,

	AC_HELP_STRING([--enable-thread-cs=type],

			[Choose the method used for critical sections

                         and other atomic updates when multiple

                         threads are present.  Values may be global

                         (default), per-object, per-vni, lock-free]),,enable_thread_cs=global)

AC_ARG_ENABLE(mdta,

    AC_HELP_STRING([--enable-mdta],

            [Optimize global granularity using message-driven thread activation.

                         Only available for ch4 device with --enable-thread-cs=global]),

    AC_DEFINE(MPICH_THREAD_USE_MDTA,1,[Define to enable message-driven thread activation]))

AC_ARG_ENABLE(refcount,

	AC_HELP_STRING([--enable-refcount=type],

			[Choose the method for ensuring atomic updates

                         to the reference counts for MPI objects.

                         Values may be lock-free or none.  The

                         default depends on the thread-cs choice; for

                         global it is none (because none is required),

                         for per-object, per-vni, and lock-free, lock-free]),,

                         enable_refcount=default)

AC_ARG_ENABLE(mutex-timing,

	AC_HELP_STRING([--enable-mutex-timing], [calculate the time spent waiting on mutexes]),

	AC_DEFINE(MPIU_MUTEX_WAIT_TIME,1,[Define to enable timing mutexes]))

AC_ARG_ENABLE([predefined-refcount],

	AS_HELP_STRING([--enable-predefined-refcount],

                       [control whether predefined objects like

		       MPI_COMM_WORLD are reference counted (default

		       depends on --enable-thread-cs choice)]),[],

              [enable_predefined_refcount=default])

AC_ARG_ENABLE(weak-symbols,

	AC_HELP_STRING([--enable-weak-symbols],

			[Use weak symbols to implement PMPI routines (default)]),,

		enable_weak_symbols=yes)

AC_ARG_ENABLE([two-level-namespace],

              [AS_HELP_STRING([--enable-two-level-namespace],

                              [(Darwin only) Build shared libraries and programs

                               built with the mpicc/mpifort/etc. compiler

                               wrappers with '-Wl,-commons,use_dylibs' and

                               without '-Wl,-flat_namespace'.  This may make the

                               MPICH installation and MPI programs more

                               compatible with other libraries.  Only enable

                               this option if you really know what these linker

                               options imply.])],

              [],

              [enable_two_level_namespace=no])

AC_ARG_ENABLE(multi-aliases,

	AC_HELP_STRING([--enable-multi-aliases],

		[Multiple aliasing to support multiple fortran compilers (default)]),,

		enable_multi_aliases=yes)

AC_ARG_ENABLE([wrapper-rpath],

              [AC_HELP_STRING([--enable-wrapper-rpath],

                              [Determine whether the rpath is set when programs

                               are linked by mpicc compiler wrappers.  This only

                               applies when shared libraries are built.  The

                               default is yes; use --disable-wrapper-rpath to

                               turn this feature off.  In that case, shared

                               libraries will be found according to the rules

                               for your system (e.g., in LD_LIBRARY_PATH)])],

              [],[enable_wrapper_rpath=yes])

AC_SUBST([enable_wrapper_rpath])

AC_ARG_ENABLE([long-double],

              [AC_HELP_STRING([--disable-long-double],

                              [Pass --disable-long-double to prevent the MPI

                               library from supporting the C "long double" type,

                               even if the C compiler supports it.  "long

                               double" support is enabled by default, provided

                               the compiler supports it.])],

              [],

              [enable_long_double=yes])

AC_ARG_WITH(cross,

	AC_HELP_STRING([--with-cross=file],

		[Specify the values of variables that configure cannot

                 determine in a cross-compilation environment]),,

		 with_cross=$MPID_DEFAULT_CROSS_FILE)

AC_ARG_WITH(namepublisher,

[  --with-namepublisher=name   Choose the system that will support 

                              MPI_PUBLISH_NAME and MPI_LOOKUP_NAME.  Options

                              include

                                   pmi (default)

			           file[:directory] (optional directory)

                                   no (no service available)],,with_namepublisher=default)

AC_ARG_WITH(name-publisher,

    [],

    with_namepublisher=$with_name_publisher,)

AC_ARG_ENABLE(dbg-nolocal, AC_HELP_STRING([--enable-dbg-nolocal], [enables debugging mode where shared-memory communication is disabled]),

    AC_DEFINE(ENABLED_NO_LOCAL, 1, [Define to disable shared-memory communication for debugging]))

AC_ARG_ENABLE(dbg-localoddeven, AC_HELP_STRING([--enable-dbg-localoddeven], [enables debugging mode where shared-memory communication is enabled only between even processes or odd processes on a node]),

    AC_DEFINE(ENABLED_ODD_EVEN_CLIQUES, 1, [Define to enable debugging mode where shared-memory communication is done only between even procs or odd procs]))

AC_CANONICAL_TARGET

# Find a C compiler.

# We also need to do this before the F77 and FC test to ensure that we

# find the C preprocessor reliably.

PAC_PROG_CC

AM_PROG_CC_C_O dnl needed for automake "silent-rules"

PAC_PUSH_FLAG([CFLAGS])

AC_PROG_CPP

# Bug in autoconf.  Restore cross settings

if test "$pac_cross_compiling" = "yes" -a "$ac_cv_prog_cc_cross" = "no" ; then

    AC_MSG_RESULT([Resetting cross compilation to yes])

    cross_compiling=yes

    ac_cv_prog_cc_cross=yes

    ac_cv_prog_f77_cross=yes

    ac_cv_prog_fc_cross=yes

    ac_cv_prog_cxx_cross=yes

fi

PAC_POP_FLAG([CFLAGS])

# also needed by hwloc in embedded mode, must also come early for expansion

# ordering reasons

AC_USE_SYSTEM_EXTENSIONS

dnl now that autoconf and core compilers are setup, init automake and libtool

dnl

dnl We would like to pass -Werror, but we are cheating in the "examples/"

dnl directory and overriding the user-flags like CFLAGS, which automake-1.12

dnl warns about.  Long-term we may need to use a hand-written Makefile.in or

dnl something else in this special dir.

AM_INIT_AUTOMAKE([-Wall -Wno-portability-recursive foreign 1.12.3 silent-rules subdir-objects])

AM_MAINTAINER_MODE([enable])

AM_PROG_AR

LT_INIT()

# Non-verbose make by default

m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])

# Disable rpath in the compiler wrappers if shared libraries are disabled, since

# rpath makes no sense in the context of static libraries.

if test "X$enable_shared" = "Xno" ; then

    enable_wrapper_rpath=no

fi

INTERLIB_DEPS=yes

# We conservatively disable interlibrary dependencies if the libtool

# support model is anything different from "pass_all"

if test "X$enable_shared" = "Xno" -o "$deplibs_check_method" != "pass_all" -o "$enable_interlib_deps" = "no" ; then

    INTERLIB_DEPS=no

fi

export INTERLIB_DEPS

AC_SUBST(INTERLIB_DEPS)

dnl AC_PROG_{CXX,F77,FC} must come early in configure.ac in order to avoid some

dnl esoteric autoconf macro expansion errors

dnl

dnl Also, DO NOT attempt to place shell conditionals (either manually or via

dnl AS_IF) around these macros in an effort to save configure time.  It will

dnl lead to weird AM_CONDITIONAL errors and potentially other problems.

# Before attempting to find valid compilers, set the corresponding precious

# shell variable to "no" for any languages that have been disabled by the user

# with "--disable-LANG".  Libtool understands this as a request to disable

# support for this language. This should save a bit of configure time and also

# prevent user complaints like ticket #1570.

AS_IF([test "x$enable_f77" = "xno"],[F77=no])

AS_IF([test "x$enable_fc"  = "xno"],[FC=no])

AS_IF([test "x$enable_cxx" = "xno"],[CXX=no])

# suppress default "-g -O2" from AC_PROG_CXX

: ${CXXFLAGS=""}

AC_PROG_CXX([PAC_CXX_SEARCH_LIST])

# suppress default "-g -O2" from AC_PROG_FC

: ${FCFLAGS=""}

AC_PROG_FC([PAC_FC_SEARCH_LIST])

save_IFS="$IFS"

IFS=","

enable_f77=no

enable_fc=no

for option in $enable_fortran ; do

    case "$option" in

        yes|all)

		enable_f77=yes

		enable_fc=yes

		;;

        no|none)

		;;

        f77)

		enable_f77=yes

		;;

        fc)

		enable_fc=yes

		;;

        *)

		IFS="$save_IFS"

		AC_MSG_WARN([Unknown value $option for --enable-fortran])

		IFS=","

		;;

    esac

done

IFS="$save_IFS"

if test "$enable_f77" = "no" ; then

   if test "$enable_fc" = "yes" ; then

      AC_MSG_ERROR([Fortran 90 support requires enabling Fortran 77])

   fi

fi

if test ! -z "$FC" -a -z "$F77" ; then

   F77=$FC

   if test ! -z "$FCFLAGS" -a -z "$FFLAGS" ; then

      FFLAGS=$FCFLAGS

   fi

fi

AM_CONDITIONAL([INSTALL_MPIF77],[test "$F77" != "$FC" -a "$FFLAGS" != "$FCFLAGS"])

# This needs to come after we've potentially set F77=$FC. Otherwise, we could

# override the user's Fortran compiler selection when only specifying FC at configure

# time, as is allowed.

# suppress default "-g -O2" from AC_PROG_F77

: ${FFLAGS=""}

AC_PROG_F77([PAC_F77_SEARCH_LIST])

# compute canonical system types

AC_CANONICAL_BUILD

AC_CANONICAL_HOST

# TARGET not needed, MPICH isn't a compiler

# Enable better caching control

PAC_ARG_CACHING

# Set CFLAGS for enable strict if necessary.  Do this *first* because

# it may influence the output of the other tests

PAC_ARG_STRICT

# -----------------------------------------------------------------------------

# First check that we have a clean build if we are doing a VPATH build

PAC_VPATH_CHECK(src/include/mpi.h src/env/mpicc,lib)

# ----------------------------------------------------------------------------

# This test is complicated by the fact that top_srcdir is not set until

# the very end of configure.  Instead, we get it ourselves

if test -z "$top_srcdir" ; then

   use_top_srcdir=$srcdir   

else

   use_top_srcdir=$top_srcdir

fi

if test -z "$master_top_srcdir" ; then 

    # This needs to be an absolute pathname

    case "$use_top_srcdir" in

    /*) ;;

    *)

        use_top_srcdir=`(cd $use_top_srcdir && pwd)`

	;;	

    esac

    master_top_srcdir=$use_top_srcdir

fi

# Get the directory that we're running in...

if test -z "$master_top_builddir" ; then

   master_top_builddir="`pwd`"

fi

AC_SUBST(master_top_builddir)

AC_SUBST(master_top_srcdir)

export master_top_builddir

export master_top_srcdir

if test -z "$with_cross"; then

  if test -f "$master_top_srcdir/src/cross/$host_alias"; then

    with_cross="$master_top_srcdir/src/cross/$host_alias"

  else

    with_cross=no

  fi

fi

if test "$with_cross" != "no"; then

  AC_MSG_NOTICE([Using cross file: $with_cross])

fi

# ----------------------------------------------------------------------------

dnl Export important "precious" variables so that any directories configured via

dnl PAC_CONFIG_SUBDIR will agree with the top-level configure about these

dnl critical variables (esp. compiler selection).  These exports should come

dnl before any subconfigures in this script.

dnl

dnl This list is arguably incomplete, and should possibly be automatically

dnl generated from "$ac_precious_vars" using code similar to the implementation

dnl of PAC_CONFIG_SUBDIR.

dnl

dnl To be clear, without these exports any variable values determined by this

dnl configure script will not be seen by child scripts.  Instead they will dnl

dnl receive the only the original inherited environment and configure args used

dnl when this configure script was invoked.

export AR

export AR_FLAGS

export CC

export CFLAGS

export CPPFLAGS

export CXX

export CXXFLAGS

export F77

export FC

export FCFLAGS

export FFLAGS

export LDFLAGS

export LIBS

export MPILIBNAME

export PMPILIBNAME

export RANLIB

export OPALIBNAME

export MPLLIBNAME

# ----------------------------------------------------------------------------

# with-device

if test "$with_device" = "default" ; then

    # Pick the device.  For now, always choose ch3

    with_device=ch3

fi

# Extract the device name from any options

# Allow the device to specify a directory; if no directory, use the

# included directories

# 

DEVICE=$with_device

AC_SUBST(DEVICE)

device_name=`echo $with_device | sed -e 's/:.*$//'`

changequote(<<,>>)

device_args=`echo $with_device | sed -e 's/^[^:]*//' -e 's/^://'`

changequote([,])

devicedir=$use_top_srcdir/src/mpid/$device_name

devicereldir=src/mpid/$device_name

case "$device_name" in

     /*) 

     devicedir=$DEVICE

     # Get the name from the leaf

     device_name=`echo $device_name ~ sed -e 's%.*/%%'`

     # FIXME: should the devicereldir be different (perhaps not -

     # this allows use to build within our tree, even when other data

     # is outside of the tree)

     ;;

     *) 

     ;;

esac

export device_name

export device_args

export devicedir

# See if the device wants to say something about the compilers

if test -f $devicedir/mpichprereq ; then

    . $devicedir/mpichprereq

fi

# expand all of the prereq macros in the correct order

m4_map([PAC_SUBCFG_DO_PREREQ], [PAC_SUBCFG_MODULE_LIST])

# ----------------------------------------------------------------------------

# Set default library names if names haven't already been provided

AC_ARG_VAR([MPILIBNAME],[can be used to override the name of the MPI library (default: "mpi")])

AC_ARG_VAR([PMPILIBNAME],[can be used to override the name of the MPI profiling library (default: "p$MPILIBNAME")])

AC_ARG_VAR([MPICXXLIBNAME],[can be used to override the name of the MPI C++ library (default: "${MPILIBNAME}cxx")])

AC_ARG_VAR([MPIFCLIBNAME],[can be used to override the name of the MPI fortran library (default: "${MPILIBNAME}fort")])

MPILIBNAME=${MPILIBNAME:-"mpi"}

PMPILIBNAME_set=no

if test -n "$PMPILIBNAME" ; then 

   PMPILIBNAME_set=yes

fi

PMPILIBNAME=${PMPILIBNAME:-"p$MPILIBNAME"}

# Note that the name for this library may be updated after we check for 

# enable_shmem

# Fortran names are set later.

# We use a different library for the C++ wrappers to avoid problems when

# creating shared libraries