1302cb4072
originally suggested by Ralf Wildenhues, to try to speed autogen, configure, and make (and possibly even make install). Use automake's include directive to drastically reduce the number of Makefile files (although the number of Makefile.am files is the same - most are just included in a top-level Makefile.am). Also use an Automake SUBDIRs feature to eliminate the dynamic-mca tree, which was no longer really needed. This makes adding a framework easier (since you don't have to remember the dynamic-mca tree) and makes building faster (as make doesn't have to recurse through the dynamic-mca tree) This commit was SVN r7777.
1720 строки
56 KiB
Plaintext
1720 строки
56 KiB
Plaintext
# -*- shell-script -*-
|
|
#
|
|
# Copyright (c) 2004-2005 The Trustees of Indiana University.
|
|
# All rights reserved.
|
|
# Copyright (c) 2004-2005 The Trustees of the University of Tennessee.
|
|
# All rights reserved.
|
|
# Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
|
|
# University of Stuttgart. All rights reserved.
|
|
# Copyright (c) 2004-2005 The Regents of the University of California.
|
|
# All rights reserved.
|
|
# $COPYRIGHT$
|
|
#
|
|
# Additional copyrights may follow
|
|
#
|
|
# $HEADER$
|
|
#
|
|
|
|
|
|
############################################################################
|
|
# Initialization, version number, and other random setup/init stuff
|
|
############################################################################
|
|
|
|
# Init autoconf
|
|
|
|
# We don't have the version number to put in here yet, and we can't
|
|
# call OMPI_GET_VERSION (etc.) before AC_INIT. So use the shell
|
|
# version.
|
|
|
|
AC_INIT([Open MPI],
|
|
[m4_normalize(esyscmd([config/ompi_get_version.sh VERSION --base]))],
|
|
[http://www.open-mpi.org/community/help/], [openmpi])
|
|
AC_PREREQ(2.58)
|
|
AC_CONFIG_AUX_DIR(./config)
|
|
AC_CONFIG_MACRO_DIR(./config)
|
|
|
|
# Get our platform support file. This has to be done very, very early
|
|
# because it twiddles random bits of autoconf
|
|
OMPI_LOAD_PLATFORM
|
|
|
|
#
|
|
# Init automake
|
|
#
|
|
|
|
AM_INIT_AUTOMAKE([foreign dist-bzip2 subdir-objects no-define])
|
|
|
|
# Make configure depend on the VERSION file, since it's used in AC_INIT
|
|
AC_SUBST([CONFIGURE_DEPENDENCIES], ['$(top_srcdir)/VERSION'])
|
|
|
|
# Get the version of OMPI that we are installing
|
|
|
|
OMPI_GET_VERSION($srcdir/VERSION, OMPI)
|
|
|
|
# override/fixup the version numbers set by AC_INIT, since on
|
|
# developer builds, there's no good way to know what the version is
|
|
# before running configure :(. We only use the base version number
|
|
# (ie, no svn r numbers) for the version set in AC_INIT. This will
|
|
# always match reality because we add the VERSION file (the only way
|
|
# to change the major.minor.release{greek}) into the configure
|
|
# dependencies.
|
|
PACKAGE_VERSION="$OMPI_VERSION"
|
|
PACKAGE_STRING="${PACKAGE_NAME} ${PACKAGE_VERSION}"
|
|
VERSION="${PACKAGE_VERSION}"
|
|
|
|
AC_SUBST(OMPI_MAJOR_VERSION)
|
|
AC_SUBST(OMPI_MINOR_VERSION)
|
|
AC_SUBST(OMPI_RELEASE_VERSION)
|
|
AC_SUBST(OMPI_GREEK_VERSION)
|
|
AC_SUBST(OMPI_WANT_SVN)
|
|
AC_SUBST(OMPI_SVN_R)
|
|
AC_SUBST(OMPI_VERSION)
|
|
|
|
AC_DEFINE_UNQUOTED(OMPI_MAJOR_VERSION, $OMPI_MAJOR_VERSION,
|
|
[Major release number of Open MPI])
|
|
AC_DEFINE_UNQUOTED(OMPI_MINOR_VERSION, $OMPI_MINOR_VERSION,
|
|
[Minor release number of Open MPI])
|
|
AC_DEFINE_UNQUOTED(OMPI_RELEASE_VERSION, $OMPI_RELEASE_VERSION,
|
|
[Release release number of Open MPI])
|
|
AC_DEFINE_UNQUOTED(OMPI_GREEK_VERSION, "$OMPI_GREEK_VERSION",
|
|
[Greek - alpha, beta, etc - release number of Open MPI])
|
|
AC_DEFINE_UNQUOTED(OMPI_VERSION, "$OMPI_RELEASE_VERSION",
|
|
[Complete release number of Open MPI])
|
|
|
|
# JMS: For the moment, cheat and have ORTE and OPAL version numbers be
|
|
# the same. Someday, they will be 3rd part import packages and have
|
|
# their own version numbers
|
|
|
|
ORTE_MAJOR_VERSION="$OMPI_MAJOR_VERSION"
|
|
ORTE_MINOR_VERSION="$OMPI_MINOR_VERSION"
|
|
ORTE_RELEASE_VERSION="$OMPI_RELEASE_VERSION"
|
|
ORTE_GREEK_VERSION="$OMPI_GREEK_VERSION"
|
|
ORTE_WANT_SVN="$OMPI_WANT_SVN"
|
|
ORTE_SVN_R="$OMPI_SVN_R"
|
|
ORTE_VERSION="$OMPI_VERSION"
|
|
|
|
AC_SUBST(ORTE_MAJOR_VERSION)
|
|
AC_SUBST(ORTE_MINOR_VERSION)
|
|
AC_SUBST(ORTE_RELEASE_VERSION)
|
|
AC_SUBST(ORTE_GREEK_VERSION)
|
|
AC_SUBST(ORTE_WANT_SVN)
|
|
AC_SUBST(ORTE_SVN_R)
|
|
AC_SUBST(ORTE_VERSION)
|
|
|
|
AC_DEFINE_UNQUOTED(ORTE_MAJOR_VERSION, $ORTE_MAJOR_VERSION,
|
|
[Major release number of Open RTE])
|
|
AC_DEFINE_UNQUOTED(ORTE_MINOR_VERSION, $ORTE_MINOR_VERSION,
|
|
[Minro release number of Open RTE])
|
|
AC_DEFINE_UNQUOTED(ORTE_RELEASE_VERSION, $ORTE_RELEASE_VERSION,
|
|
[Release release number of Open RTE])
|
|
AC_DEFINE_UNQUOTED(ORTE_GREEK_VERSION, "$ORTE_GREEK_VERSION",
|
|
[Greek - alpha, beta, etc - release number of Open RTE])
|
|
AC_DEFINE_UNQUOTED(ORTE_VERSION, "$ORTE_RELEASE_VERSION",
|
|
[Complete release number of Open RTE])
|
|
|
|
OPAL_MAJOR_VERSION="$OMPI_MAJOR_VERSION"
|
|
OPAL_MINOR_VERSION="$OMPI_MINOR_VERSION"
|
|
OPAL_RELEASE_VERSION="$OMPI_RELEASE_VERSION"
|
|
OPAL_GREEK_VERSION="$OMPI_GREEK_VERSION"
|
|
OPAL_WANT_SVN="$OMPI_WANT_SVN"
|
|
OPAL_SVN_R="$OMPI_SVN_R"
|
|
OPAL_VERSION="$OMPI_VERSION"
|
|
|
|
AC_SUBST(OPAL_MAJOR_VERSION)
|
|
AC_SUBST(OPAL_MINOR_VERSION)
|
|
AC_SUBST(OPAL_RELEASE_VERSION)
|
|
AC_SUBST(OPAL_GREEK_VERSION)
|
|
AC_SUBST(OPAL_WANT_SVN)
|
|
AC_SUBST(OPAL_SVN_R)
|
|
AC_SUBST(OPAL_VERSION)
|
|
|
|
AC_DEFINE_UNQUOTED(OPAL_MAJOR_VERSION, $OPAL_MAJOR_VERSION,
|
|
[Major release number of OPAL])
|
|
AC_DEFINE_UNQUOTED(OPAL_MINOR_VERSION, $OPAL_MINOR_VERSION,
|
|
[Minor release number of OPAL])
|
|
AC_DEFINE_UNQUOTED(OPAL_RELEASE_VERSION, $OPAL_RELEASE_VERSION,
|
|
[Release release number of OPAL])
|
|
AC_DEFINE_UNQUOTED(OPAL_GREEK_VERSION, "$OPAL_GREEK_VERSION",
|
|
[Greek - alpha, beta, etc - release number of OPAL])
|
|
AC_DEFINE_UNQUOTED(OPAL_VERSION, "$OPAL_RELEASE_VERSION",
|
|
[Complete release number of OPAL])
|
|
|
|
#
|
|
# Start it up
|
|
#
|
|
|
|
OMPI_CONFIGURE_SETUP
|
|
ompi_show_title "Configuring Open MPI"
|
|
|
|
ompi_show_subtitle "Checking versions"
|
|
AC_MSG_CHECKING([Open MPI version])
|
|
AC_MSG_RESULT([$OMPI_VERSION])
|
|
AC_MSG_CHECKING([Open MPI Subversion repository version])
|
|
AC_MSG_RESULT([$OMPI_SVN_R])
|
|
|
|
AC_MSG_CHECKING([Open Run-Time Environment (ORTE) version])
|
|
AC_MSG_RESULT([$ORTE_VERSION])
|
|
AC_MSG_CHECKING([ORTE Subversion repository version])
|
|
AC_MSG_RESULT([$ORTE_SVN_R])
|
|
|
|
AC_MSG_CHECKING([Open Portable Access Layer (OPAL) version])
|
|
AC_MSG_RESULT([$OPAL_VERSION])
|
|
AC_MSG_CHECKING([OPAL Subversion repository version])
|
|
AC_MSG_RESULT([$OPAL_SVN_R])
|
|
|
|
ompi_show_subtitle "Initialization, setup"
|
|
|
|
#
|
|
# GNU C and autotools are inconsistent about whether this is defined
|
|
# so let's make it true everywhere for now...
|
|
#
|
|
AC_GNU_SOURCE
|
|
|
|
OMPI_TOP_BUILDDIR="`pwd`"
|
|
AC_SUBST(OMPI_TOP_BUILDDIR)
|
|
cd "$srcdir"
|
|
OMPI_TOP_SRCDIR="`pwd`"
|
|
AC_SUBST(OMPI_TOP_SRCDIR)
|
|
cd "$OMPI_TOP_BUILDDIR"
|
|
|
|
AC_MSG_NOTICE([builddir: $OMPI_TOP_BUILDDIR])
|
|
AC_MSG_NOTICE([srcdir: $OMPI_TOP_SRCDIR])
|
|
if test "$OMPI_TOP_BUILDDIR" != "$OMPI_TOP_SRCDIR"; then
|
|
AC_MSG_NOTICE([Detected VPATH build])
|
|
fi
|
|
|
|
# Setup the top of the include/ompi_config.h file
|
|
|
|
AH_TOP([/* -*- c -*-
|
|
*
|
|
* Copyright (c) 2004-2005 The Trustees of Indiana University.
|
|
* All rights reserved.
|
|
* Copyright (c) 2004-2005 The Trustees of the University of Tennessee.
|
|
* All rights reserved.
|
|
* Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
|
|
* University of Stuttgart. All rights reserved.
|
|
* Copyright (c) 2004-2005 The Regents of the University of California.
|
|
* All rights reserved.
|
|
* $COPYRIGHT$
|
|
*
|
|
* Additional copyrights may follow
|
|
*
|
|
* $HEADER$
|
|
*
|
|
* Function: - OS, CPU and compiler dependent configuration
|
|
*/
|
|
|
|
#ifndef OMPI_CONFIG_H
|
|
#define OMPI_CONFIG_H
|
|
])
|
|
AH_BOTTOM([
|
|
#include "ompi_config_bottom.h"
|
|
#endif /* OMPI_CONFIG_H */
|
|
])
|
|
|
|
# Other basic setup stuff (shared with components)
|
|
|
|
OMPI_BASIC_SETUP
|
|
|
|
top_ompi_srcdir="$OMPI_TOP_SRCDIR"
|
|
AC_SUBST(top_ompi_srcdir)
|
|
top_ompi_builddir="$OMPI_TOP_BUILDDIR"
|
|
AC_SUBST(top_ompi_builddir)
|
|
|
|
############################################################################
|
|
# Configuration options
|
|
############################################################################
|
|
|
|
OMPI_CONFIGURE_OPTIONS
|
|
|
|
############################################################################
|
|
# Libtool: part one
|
|
# (before C compiler setup)
|
|
############################################################################
|
|
|
|
#
|
|
# Part one of libtool magic. Enable static so that we have the --with
|
|
# tests done up here and can check for OS. Save the values of
|
|
# $enable_static and $enable_shared before setting the defaults,
|
|
# because if the user specified --[en|dis]able-[static|shared] on the
|
|
# command line, they'll already be set. In this way, we can tell if
|
|
# the user requested something or if the default was set here.
|
|
#
|
|
|
|
ompi_enable_shared="$enable_shared"
|
|
ompi_enable_static="$enable_static"
|
|
AM_ENABLE_SHARED
|
|
AM_DISABLE_STATIC
|
|
|
|
WRAPPER_EXTRA_CFLAGS=
|
|
WRAPPER_EXTRA_CXXFLAGS=
|
|
WRAPPER_EXTRA_FFLAGS=
|
|
WRAPPER_EXTRA_FCFLAGS=
|
|
WRAPPER_EXTRA_LDFLAGS=
|
|
WRAPPER_EXTRA_LIBS=
|
|
|
|
|
|
|
|
############################################################################
|
|
# Check for compilers and preprocessors
|
|
############################################################################
|
|
ompi_show_title "Compiler and preprocessor tests"
|
|
|
|
##################################
|
|
# C compiler characteristics
|
|
##################################
|
|
|
|
OMPI_SETUP_CC
|
|
|
|
#
|
|
# Check for some types
|
|
#
|
|
|
|
AC_CHECK_TYPES(long long)
|
|
AC_CHECK_TYPES(long double)
|
|
AC_CHECK_TYPES(int8_t)
|
|
AC_CHECK_TYPES(uint8_t)
|
|
AC_CHECK_TYPES(int16_t)
|
|
AC_CHECK_TYPES(uint16_t)
|
|
AC_CHECK_TYPES(int32_t)
|
|
AC_CHECK_TYPES(uint32_t)
|
|
AC_CHECK_TYPES(int64_t)
|
|
AC_CHECK_TYPES(uint64_t)
|
|
AC_CHECK_TYPES(intptr_t)
|
|
AC_CHECK_TYPES(uintptr_t)
|
|
AC_CHECK_TYPES(mode_t)
|
|
|
|
|
|
#
|
|
# Check for type sizes
|
|
#
|
|
|
|
AC_CHECK_SIZEOF(char)
|
|
AC_CHECK_SIZEOF(short)
|
|
AC_CHECK_SIZEOF(int)
|
|
AC_CHECK_SIZEOF(long)
|
|
if test $ac_cv_type_long_long = yes; then
|
|
AC_CHECK_SIZEOF(long long)
|
|
fi
|
|
if test $ac_cv_type_long_double = yes; then
|
|
AC_CHECK_SIZEOF(long double)
|
|
fi
|
|
AC_CHECK_SIZEOF(float)
|
|
AC_CHECK_SIZEOF(double)
|
|
AC_CHECK_SIZEOF(void *)
|
|
AC_CHECK_SIZEOF(size_t)
|
|
|
|
#
|
|
# Check for type alignments
|
|
#
|
|
|
|
OMPI_C_GET_ALIGNMENT(char, OMPI_ALIGNMENT_CHAR)
|
|
OMPI_C_GET_ALIGNMENT(short, OMPI_ALIGNMENT_SHORT)
|
|
OMPI_C_GET_ALIGNMENT(wchar_t, OMPI_ALIGNMENT_WCHAR)
|
|
OMPI_C_GET_ALIGNMENT(int, OMPI_ALIGNMENT_INT)
|
|
OMPI_C_GET_ALIGNMENT(long, OMPI_ALIGNMENT_LONG)
|
|
if test $ac_cv_type_long_long = yes; then
|
|
OMPI_C_GET_ALIGNMENT(long long, OMPI_ALIGNMENT_LONG_LONG)
|
|
fi
|
|
OMPI_C_GET_ALIGNMENT(float, OMPI_ALIGNMENT_FLOAT)
|
|
OMPI_C_GET_ALIGNMENT(double, OMPI_ALIGNMENT_DOUBLE)
|
|
if test $ac_cv_type_long_double = yes; then
|
|
OMPI_C_GET_ALIGNMENT(long double, OMPI_ALIGNMENT_LONG_DOUBLE)
|
|
fi
|
|
OMPI_C_GET_ALIGNMENT(void *, OMPI_ALIGNMENT_VOID_P)
|
|
|
|
#
|
|
# Does the C compiler native support "bool"? (i.e., without
|
|
# <stdbool.h> or any other help)
|
|
#
|
|
|
|
AC_MSG_CHECKING(for C bool type)
|
|
AC_COMPILE_IFELSE(AC_LANG_PROGRAM([[
|
|
AC_INCLUDES_DEFAULT]],
|
|
[[bool bar, foo = true; bar = foo;]]),
|
|
[OMPI_NEED_C_BOOL=0 MSG=yes],[OMPI_NEED_C_BOOL=1 MSG=no])
|
|
AC_DEFINE_UNQUOTED(OMPI_NEED_C_BOOL, $OMPI_NEED_C_BOOL,
|
|
[Whether the C compiler supports "bool" without any other help (such as <stdbool.h>)])
|
|
AC_MSG_RESULT([$MSG])
|
|
|
|
#
|
|
# Check for other compiler characteristics
|
|
#
|
|
|
|
if test "$GCC" = "yes"; then
|
|
|
|
# gcc 2.96 will emit oodles of warnings if you use "inline" with
|
|
# -pedantic (which we do in developer builds). However,
|
|
# "__inline__" is ok. So we have to force gcc to select the
|
|
# right one. If you use -pedantic, the AC_C_INLINE test will fail
|
|
# (because it names a function foo() -- without the (void)). So
|
|
# we turn off all the picky flags, turn on -ansi mode (which is
|
|
# implied by -pedantic), and set warnings to be errors. Hence,
|
|
# this does the following (for 2.96):
|
|
#
|
|
# - causes the check for "inline" to emit a warning, which then
|
|
# fails
|
|
# - checks for __inline__, which then emits no error, and works
|
|
#
|
|
# This also works nicely for gcc 3.x because "inline" will work on
|
|
# the first check, and all is fine. :-)
|
|
|
|
CFLAGS_save="$CFLAGS"
|
|
CFLAGS="$OMPI_CFLAGS_BEFORE_PICKY -Werror -ansi"
|
|
fi
|
|
AC_C_INLINE
|
|
AC_C_RESTRICT
|
|
OMPI_C_WEAK_SYMBOLS
|
|
if test "$GCC" = "yes"; then
|
|
CFLAGS="$CFLAGS_save"
|
|
fi
|
|
|
|
if test "x$CC" = "xicc"; then
|
|
OMPI_CHECK_ICC_VARARGS
|
|
fi
|
|
|
|
# If we want the profiling layer:
|
|
# - If the C compiler has weak symbols, use those.
|
|
# - If not, then set to compile the code again with #define's in a
|
|
# separate directory.
|
|
|
|
if test "$WANT_WEAK_SYMBOLS" = "0"; then
|
|
OMPI_C_HAVE_WEAK_SYMBOLS=0
|
|
fi
|
|
if test "$WANT_MPI_PROFILING" = "1"; then
|
|
if test "$OMPI_C_HAVE_WEAK_SYMBOLS" = "1"; then
|
|
OMPI_PROFILING_COMPILE_SEPARATELY=0
|
|
else
|
|
OMPI_PROFILING_COMPILE_SEPARATELY=1
|
|
fi
|
|
else
|
|
OMPI_PROFILING_COMPILE_SEPARATELY=0
|
|
fi
|
|
|
|
#
|
|
# There are 2 layers to the MPI Language binidings One layer generates
|
|
# MPI_* bindings. The other layer generates PMPI_* bindings. The
|
|
# following conditions determine whether each (or both) these layers
|
|
# are built.
|
|
# 1. MPI_* bindings are needed if:
|
|
# - Profiling is not required
|
|
# - Profiling is required but weak symbols are not
|
|
# supported
|
|
# 2. PMPI_* bindings are needed if profiling is required. Hence we
|
|
# define 2 conditionals which tell us whether each of these layers
|
|
# need to be built or NOT
|
|
#
|
|
|
|
AM_CONDITIONAL(WANT_MPI_BINDINGS_LAYER,
|
|
test "$WANT_MPI_PROFILING" = 0 -o "$OMPI_PROFILING_COMPILE_SEPARATELY" = 1)
|
|
|
|
AM_CONDITIONAL(WANT_PMPI_BINDINGS_LAYER,
|
|
test "$WANT_MPI_PROFILING" = 1)
|
|
AM_CONDITIONAL(COMPILE_PROFILING_SEPARATELY,
|
|
test "$OMPI_PROFILING_COMPILE_SEPARATELY" = 1)
|
|
AC_DEFINE_UNQUOTED(OMPI_ENABLE_MPI_PROFILING, $WANT_MPI_PROFILING,
|
|
[Whether we want MPI profiling or not])
|
|
AC_DEFINE_UNQUOTED(OMPI_HAVE_WEAK_SYMBOLS, $OMPI_C_HAVE_WEAK_SYMBOLS,
|
|
[Wehther we have weak symbols or not])
|
|
|
|
|
|
##################################
|
|
# C++ compiler characteristics
|
|
##################################
|
|
|
|
OMPI_SETUP_CXX
|
|
|
|
# check for type sizes
|
|
|
|
AC_LANG_SAVE
|
|
AC_LANG_CPLUSPLUS
|
|
AC_CHECK_SIZEOF(bool)
|
|
|
|
# check for type alignments
|
|
|
|
OMPI_C_GET_ALIGNMENT(bool, OMPI_ALIGNMENT_CXX_BOOL)
|
|
AC_LANG_RESTORE
|
|
|
|
# check if we want C++ support
|
|
|
|
AM_CONDITIONAL(WANT_MPI_CXX_BINDINGS,
|
|
test "$WANT_MPI_CXX_SUPPORT" = 1)
|
|
AC_DEFINE_UNQUOTED(OMPI_WANT_CXX_BINDINGS, $WANT_MPI_CXX_SUPPORT,
|
|
[Whether we want MPI cxx support or not])
|
|
|
|
|
|
##################################
|
|
# Assembler Configuration
|
|
##################################
|
|
|
|
ompi_show_subtitle "Assembler"
|
|
|
|
AM_PROG_AS
|
|
OMPI_CONFIG_ASM
|
|
|
|
|
|
##################################
|
|
# Fortran
|
|
##################################
|
|
|
|
OMPI_SETUP_F77
|
|
OMPI_F77_FIND_EXT_SYMBOL_CONVENTION($OMPI_F77)
|
|
|
|
# This allows us to mark bogus types, but still have them be a valid
|
|
# [sentinel] value
|
|
|
|
AC_DEFINE([ompi_fortran_bogus_type_t], [int],
|
|
[A bogus type that allows us to have sentinel type values that are still valid])
|
|
|
|
# We want to set the #define's for all of these, so invoke the macros
|
|
# regardless of whether we have F77 support or not.
|
|
|
|
OMPI_F77_CHECK(LOGICAL, LOGICAL, logical, yes,
|
|
[char int int32_t], -1)
|
|
|
|
OMPI_F77_CHECK(INTEGER, INTEGER, integer, yes,
|
|
[int32_t int int64_r long:long long], -1)
|
|
OMPI_F77_CHECK(INTEGER*1, INTEGER1, integer1, no,
|
|
[char int8_t short int int64_t long:long long], 1)
|
|
OMPI_F77_CHECK(INTEGER*2, INTEGER2, integer2, no,
|
|
[short int16_t int32_t int int64_t long:long long], 2)
|
|
OMPI_F77_CHECK(INTEGER*4, INTEGER4, integer4, no,
|
|
[int32_t int int64_t long:long long], 4)
|
|
OMPI_F77_CHECK(INTEGER*8, INTEGER8, integer8, no,
|
|
[int int64_t long:long long], 8)
|
|
OMPI_F77_CHECK(INTEGER*16, INTEGER16, integer16, no,
|
|
[int int64_t long:long long], 16)
|
|
|
|
OMPI_F77_CHECK(REAL, REAL, real, yes,
|
|
[float double long:double], -1)
|
|
OMPI_F77_CHECK(REAL*4, REAL4, real4, no,
|
|
[float double long:double], 4)
|
|
OMPI_F77_CHECK(REAL*8, REAL8, real8, no,
|
|
[float double long:double], 8)
|
|
OMPI_F77_CHECK(REAL*16, REAL16, real16, no,
|
|
[float double long:double], 16)
|
|
|
|
OMPI_F77_CHECK(DOUBLE PRECISION, DOUBLE_PRECISION, double_precision, yes,
|
|
[float double long:double], -1)
|
|
|
|
OMPI_F77_CHECK(COMPLEX, COMPLEX, [], yes, [], -1)
|
|
|
|
# The complex*N tests are a bit different (note: the complex tests are
|
|
# the same as all the rest, because complex is a composite of two
|
|
# reals, which we *have* to have. It's only the complex*N tests that
|
|
# are different). The fortran complex types are composites of the
|
|
# real*(N/2) types. So for us to support complex*N, two conditions
|
|
# must be true:
|
|
#
|
|
# a) we must support real*(N/2) (i.e., compiler supports it and we
|
|
# have a back-end C type for it)
|
|
# b) compiler supports complex*N
|
|
|
|
OMPI_F77_CHECK(COMPLEX*8, COMPLEX8, [], no, [], 8)
|
|
OMPI_F77_CHECK(COMPLEX*16, COMPLEX16, [], no, [], 16)
|
|
OMPI_F77_CHECK(COMPLEX*32, COMPLEX32, [], no, [], 32)
|
|
|
|
# Regardless of whether we have fortran bindings, or even a fortran
|
|
# compiler, get the max value for a fortran MPI handle (this macro
|
|
# handles the case where we don't have a fortran compiler).
|
|
|
|
OMPI_F77_GET_FORTRAN_HANDLE_MAX
|
|
|
|
#
|
|
# There are 2 layers to the MPI f77 layer. The only extra thing that
|
|
# determine f77 bindings is that fortran can be disabled by user. In
|
|
# such cases, we need to not build the target at all. One layer
|
|
# generates MPI_f77* bindings. The other layer generates PMPI_f77*
|
|
# bindings. The following conditions determine whether each (or both)
|
|
# these layers are built.
|
|
#
|
|
# Superceeding clause:
|
|
# - fortran77 bindings should be enabled, else everything is
|
|
# disabled
|
|
# 1. MPI_f77* bindings are needed if:
|
|
# - Profiling is not required
|
|
# - Profiling is required but weak symbols are not
|
|
# supported
|
|
# 2. PMPI_* bindings are needed if profiling is required. Hence we
|
|
# define 2 conditionals which tell us whether each of these layers
|
|
# need to be built or NOT
|
|
#
|
|
AM_CONDITIONAL(WANT_MPI_F77_BINDINGS_LAYER,
|
|
test \( "$WANT_MPI_PROFILING" = 0 -o "$OMPI_PROFILING_COMPILE_SEPARATELY" = 1 \) -a "$OMPI_WANT_F77_BINDINGS" = 1)
|
|
|
|
AM_CONDITIONAL(WANT_PMPI_F77_BINDINGS_LAYER,
|
|
test "$OMPI_WANT_F77_BINDINGS" = 1 -a "$WANT_MPI_PROFILING" = 1)
|
|
|
|
#
|
|
# Fortran 90 setup
|
|
#
|
|
|
|
OMPI_HAVE_F90_INTEGER1=0
|
|
OMPI_HAVE_F90_INTEGER2=0
|
|
OMPI_HAVE_F90_INTEGER4=0
|
|
OMPI_HAVE_F90_INTEGER8=0
|
|
OMPI_HAVE_F90_INTEGER16=0
|
|
OMPI_HAVE_F90_REAL4=0
|
|
OMPI_HAVE_F90_REAL8=0
|
|
OMPI_HAVE_F90_REAL16=0
|
|
OMPI_HAVE_F90_COMPLEX8=0
|
|
OMPI_HAVE_F90_COMPLEX16=0
|
|
OMPI_HAVE_F90_COMPLEX32=0
|
|
|
|
OMPI_SIZEOF_F90_LOGICAL=0
|
|
OMPI_SIZEOF_F90_INT=0
|
|
OMPI_SIZEOF_F90_REAL=0
|
|
OMPI_SIZEOF_F90_DBLPREC=0
|
|
OMPI_SIZEOF_F90_COMPLEX=0
|
|
OMPI_SIZEOF_F90_DBLCOMPLEX=0
|
|
|
|
OMPI_SIZEOF_F90_INT1=0
|
|
OMPI_SIZEOF_F90_INT2=0
|
|
OMPI_SIZEOF_F90_INT4=0
|
|
OMPI_SIZEOF_F90_INT8=0
|
|
OMPI_SIZEOF_F90_INT16=0
|
|
|
|
OMPI_SIZEOF_F90_REAL4=0
|
|
OMPI_SIZEOF_F90_REAL8=0
|
|
OMPI_SIZEOF_F90_REAL16=0
|
|
|
|
OMPI_SIZEOF_F90_COMPLEX8=0
|
|
OMPI_SIZEOF_F90_COMPLEX16=0
|
|
OMPI_SIZEOF_F90_COMPLEX32=0
|
|
|
|
OMPI_ALIGNMENT_F90_LOGICAL=0
|
|
OMPI_ALIGNMENT_F90_INT=0
|
|
OMPI_ALIGNMENT_F90_REAL=0
|
|
OMPI_ALIGNMENT_F90_DBLPREC=0
|
|
OMPI_ALIGNMENT_F90_COMPLEX=0
|
|
OMPI_ALIGNMENT_F90_DBLCOMPLEX=0
|
|
|
|
OMPI_ALIGNMENT_F90_INT1=0
|
|
OMPI_ALIGNMENT_F90_INT2=0
|
|
OMPI_ALIGNMENT_F90_INT4=0
|
|
OMPI_ALIGNMENT_F90_INT8=0
|
|
OMPI_ALIGNMENT_F90_INT16=0
|
|
|
|
OMPI_ALIGNMENT_F90_REAL4=0
|
|
OMPI_ALIGNMENT_F90_REAL8=0
|
|
OMPI_ALIGNMENT_F90_REAL16=0
|
|
|
|
OMPI_ALIGNMENT_F90_COMPLEX8=0
|
|
OMPI_ALIGNMENT_F90_COMPLEX16=0
|
|
OMPI_ALIGNMENT_F90_COMPLEX32=0
|
|
|
|
OMPI_PRECISION_F90_REAL4=0
|
|
OMPI_PRECISION_F90_REAL8=0
|
|
OMPI_PRECISION_F90_REAL16=0
|
|
|
|
OMPI_PRECISION_F90_COMPLEX8=0
|
|
OMPI_PRECISION_F90_COMPLEX16=0
|
|
OMPI_PRECISION_F90_COMPLEX32=0
|
|
|
|
OMPI_RANGE_F90_REAL4=0
|
|
OMPI_RANGE_F90_REAL8=0
|
|
OMPI_RANGE_F90_REAL16=0
|
|
|
|
OMPI_RANGE_F90_COMPLEX8=0
|
|
OMPI_RANGE_F90_COMPLEX16=0
|
|
OMPI_RANGE_F90_COMPLEX32=0
|
|
|
|
OMPI_MPI_OFFSET_KIND=0
|
|
OMPI_MPI_ADDRESS_KIND=0
|
|
|
|
#
|
|
# lists of supported Fortran types
|
|
#
|
|
OMPI_FORTRAN_LKINDS=""
|
|
OMPI_FORTRAN_IKINDS=""
|
|
OMPI_FORTRAN_RKINDS=""
|
|
OMPI_FORTRAN_CKINDS=""
|
|
|
|
|
|
OMPI_SETUP_F90
|
|
|
|
if test "$OMPI_WANT_F90_BINDINGS" = "0" ; then
|
|
OMPI_SIZEOF_F90_LOGICAL=$ac_cv_sizeof_int
|
|
OMPI_SIZEOF_F90_INT=$ac_cv_sizeof_int
|
|
OMPI_SIZEOF_F90_REAL=$ac_cv_sizeof_float
|
|
OMPI_SIZEOF_F90_DBLPREC=$ac_cv_sizeof_double
|
|
else
|
|
# Look for the fortran module compiler flag
|
|
|
|
OMPI_F90_FIND_MODULE_INCLUDE_FLAG
|
|
|
|
# If we want modern Fortran support, then get supported types and sizes
|
|
|
|
OMPI_F90_CHECK_TYPE(integer(selected_int_kind(2)), OMPI_HAVE_F90_INTEGER1)
|
|
if test "$OMPI_HAVE_F90_INTEGER1" = "1"; then
|
|
OMPI_FORTRAN_LKINDS="${OMPI_FORTRAN_LKINDS}1 "
|
|
OMPI_FORTRAN_IKINDS="${OMPI_FORTRAN_IKINDS}1 "
|
|
OMPI_F90_GET_SIZEOF(integer(selected_int_kind(2)),
|
|
OMPI_SIZEOF_F90_INT1)
|
|
OMPI_F90_GET_ALIGNMENT(integer(selected_int_kind(2)),
|
|
OMPI_ALIGNMENT_F90_INT1)
|
|
OMPI_F90_GET_SIZEOF(logical(selected_int_kind(2)),
|
|
OMPI_SIZEOF_F90_LOGICAL)
|
|
OMPI_F90_GET_ALIGNMENT(logical(selected_int_kind(2)),
|
|
OMPI_ALIGNMENT_F90_LOGICAL1)
|
|
fi
|
|
|
|
OMPI_F90_CHECK_TYPE(integer(selected_int_kind(4)), OMPI_HAVE_F90_INTEGER2)
|
|
if test "$OMPI_HAVE_F90_INTEGER2" = "1"; then
|
|
OMPI_FORTRAN_LKINDS="${OMPI_FORTRAN_LKINDS}2 "
|
|
OMPI_FORTRAN_IKINDS="${OMPI_FORTRAN_IKINDS}2 "
|
|
OMPI_F90_GET_SIZEOF(integer(selected_int_kind(4)),
|
|
OMPI_SIZEOF_F90_INT2)
|
|
OMPI_F90_GET_ALIGNMENT(integer(selected_int_kind(4)),
|
|
OMPI_ALIGNMENT_F90_INT2)
|
|
OMPI_F90_GET_SIZEOF(logical(selected_int_kind(4)),
|
|
OMPI_SIZEOF_F90_LOGICAL2)
|
|
OMPI_F90_GET_ALIGNMENT(logical(selected_int_kind(4)),
|
|
OMPI_ALIGNMENT_F90_LOGICAL2)
|
|
fi
|
|
|
|
OMPI_F90_CHECK_TYPE(integer(selected_int_kind(9)), OMPI_HAVE_F90_INTEGER4)
|
|
if test "$OMPI_HAVE_F90_INTEGER4" = "1"; then
|
|
OMPI_FORTRAN_LKINDS="${OMPI_FORTRAN_LKINDS}4 "
|
|
OMPI_FORTRAN_IKINDS="${OMPI_FORTRAN_IKINDS}4 "
|
|
OMPI_F90_GET_SIZEOF(integer(selected_int_kind(9)),
|
|
OMPI_SIZEOF_F90_INT4)
|
|
OMPI_F90_GET_ALIGNMENT(integer(selected_int_kind(9)),
|
|
OMPI_ALIGNMENT_F90_INT4)
|
|
OMPI_F90_GET_SIZEOF(logical(selected_int_kind(9)),
|
|
OMPI_SIZEOF_F90_LOGICAL4)
|
|
OMPI_F90_GET_ALIGNMENT(logical(selected_int_kind(9)),
|
|
OMPI_ALIGNMENT_F90_LOGICAL4)
|
|
fi
|
|
|
|
OMPI_F90_CHECK_TYPE(integer(selected_int_kind(18)), OMPI_HAVE_F90_INTEGER8)
|
|
if test "$OMPI_HAVE_F90_INTEGER8" = "1"; then
|
|
OMPI_FORTRAN_LKINDS="${OMPI_FORTRAN_LKINDS}8 "
|
|
OMPI_FORTRAN_IKINDS="${OMPI_FORTRAN_IKINDS}8 "
|
|
OMPI_F90_GET_SIZEOF(integer(selected_int_kind(18)),
|
|
OMPI_SIZEOF_F90_INT8)
|
|
OMPI_F90_GET_ALIGNMENT(integer(selected_int_kind(18)),
|
|
OMPI_ALIGNMENT_F90_INT8)
|
|
OMPI_F90_GET_SIZEOF(logical(selected_int_kind(18)),
|
|
OMPI_SIZEOF_F90_LOGICAL8)
|
|
OMPI_F90_GET_ALIGNMENT(logical(selected_int_kind(18)),
|
|
OMPI_ALIGNMENT_F90_LOGICAL8)
|
|
fi
|
|
|
|
OMPI_F90_CHECK_TYPE(integer(selected_int_kind(19)),
|
|
OMPI_HAVE_F90_INTEGER16)
|
|
if test "$OMPI_HAVE_F90_INTEGER16" = "1"; then
|
|
OMPI_FORTRAN_LKINDS="${OMPI_FORTRAN_LKINDS}16 "
|
|
OMPI_FORTRAN_IKINDS="${OMPI_FORTRAN_IKINDS}16 "
|
|
OMPI_F90_GET_SIZEOF(integer(selected_int_kind(19)),
|
|
OMPI_SIZEOF_F90_INT16)
|
|
OMPI_F90_GET_ALIGNMENT(integer(selected_int_kind(19)),
|
|
OMPI_ALIGNMENT_F90_INT16)
|
|
OMPI_F90_GET_SIZEOF(logical(selected_int_kind(19)),
|
|
OMPI_SIZEOF_F90_LOGICAL16)
|
|
OMPI_F90_GET_ALIGNMENT(logical(selected_int_kind(19)),
|
|
OMPI_ALIGNMENT_F90_LOGICAL16)
|
|
fi
|
|
|
|
OMPI_F90_CHECK_TYPE(real(selected_real_kind(6)), OMPI_HAVE_F90_REAL4)
|
|
if test "$OMPI_HAVE_F90_REAL4" = "1"; then
|
|
OMPI_HAVE_F90_COMPLEX8=1
|
|
OMPI_FORTRAN_RKINDS="${OMPI_FORTRAN_RKINDS}4 "
|
|
OMPI_FORTRAN_CKINDS="${OMPI_FORTRAN_CKINDS}4 "
|
|
OMPI_F90_GET_SIZEOF(real(selected_real_kind(6)), OMPI_SIZEOF_F90_REAL4)
|
|
OMPI_F90_GET_SIZEOF(complex(selected_real_kind(6)),
|
|
OMPI_SIZEOF_F90_COMPLEX8)
|
|
OMPI_F90_GET_ALIGNMENT(real(selected_real_kind(6)),
|
|
OMPI_ALIGNMENT_F90_REAL4)
|
|
OMPI_F90_GET_ALIGNMENT(complex(selected_real_kind(6)),
|
|
OMPI_ALIGNMENT_F90_COMPLEX8)
|
|
OMPI_F90_GET_PRECISION(real(selected_real_kind(6)),
|
|
OMPI_PRECISION_F90_REAL4)
|
|
OMPI_F90_GET_PRECISION(complex(selected_real_kind(6)),
|
|
OMPI_PRECISION_F90_COMPLEX8)
|
|
OMPI_F90_GET_RANGE(real(selected_real_kind(6)),
|
|
OMPI_RANGE_F90_REAL4)
|
|
OMPI_F90_GET_RANGE(complex(selected_real_kind(6)),
|
|
OMPI_RANGE_F90_COMPLEX8)
|
|
fi
|
|
|
|
OMPI_F90_CHECK_TYPE(real(selected_real_kind(15)), OMPI_HAVE_F90_REAL8)
|
|
if test "$OMPI_HAVE_F90_REAL8" = "1"; then
|
|
OMPI_HAVE_F90_COMPLEX16=1
|
|
OMPI_FORTRAN_RKINDS="${OMPI_FORTRAN_RKINDS}8 "
|
|
OMPI_FORTRAN_CKINDS="${OMPI_FORTRAN_CKINDS}8 "
|
|
OMPI_F90_GET_SIZEOF(real(selected_real_kind(15)),
|
|
OMPI_SIZEOF_F90_REAL8)
|
|
OMPI_F90_GET_SIZEOF(complex(selected_real_kind(15)),
|
|
OMPI_SIZEOF_F90_COMPLEX16)
|
|
OMPI_F90_GET_ALIGNMENT(real(selected_real_kind(15)),
|
|
OMPI_ALIGNMENT_F90_REAL8)
|
|
OMPI_F90_GET_ALIGNMENT(complex(selected_real_kind(15)),
|
|
OMPI_ALIGNMENT_F90_COMPLEX16)
|
|
OMPI_F90_GET_PRECISION(real(selected_real_kind(15)),
|
|
OMPI_PRECISION_F90_REAL8)
|
|
OMPI_F90_GET_PRECISION(complex(selected_real_kind(15)),
|
|
OMPI_PRECISION_F90_COMPLEX16)
|
|
OMPI_F90_GET_RANGE(real(selected_real_kind(15)),
|
|
OMPI_RANGE_F90_REAL8)
|
|
OMPI_F90_GET_RANGE(complex(selected_real_kind(15)),
|
|
OMPI_RANGE_F90_COMPLEX16)
|
|
fi
|
|
|
|
OMPI_F90_CHECK_TYPE(real(selected_real_kind(31)), OMPI_HAVE_F90_REAL16)
|
|
if test "$OMPI_HAVE_F90_REAL16" = "1"; then
|
|
OMPI_HAVE_F90_COMPLEX32=1
|
|
OMPI_FORTRAN_RKINDS="${OMPI_FORTRAN_RKINDS}16 "
|
|
OMPI_FORTRAN_CKINDS="${OMPI_FORTRAN_CKINDS}16 "
|
|
OMPI_F90_GET_SIZEOF(real(selected_real_kind(31)),
|
|
OMPI_SIZEOF_F90_REAL16)
|
|
OMPI_F90_GET_SIZEOF(complex(selected_real_kind(31)),
|
|
OMPI_SIZEOF_F90_COMPLEX32)
|
|
OMPI_F90_GET_ALIGNMENT(real(selected_real_kind(31)),
|
|
OMPI_ALIGNMENT_F90_REAL16)
|
|
OMPI_F90_GET_ALIGNMENT(complex(selected_real_kind(31)),
|
|
OMPI_ALIGNMENT_F90_COMPLEX32)
|
|
OMPI_F90_GET_PRECISION(real(selected_real_kind(31)),
|
|
OMPI_PRECISION_F90_REAL16)
|
|
OMPI_F90_GET_PRECISION(complex(selected_real_kind(31)),
|
|
OMPI_PRECISION_F90_COMPLEX32)
|
|
OMPI_F90_GET_RANGE(real(selected_real_kind(31)),
|
|
OMPI_RANGE_F90_REAL16)
|
|
OMPI_F90_GET_RANGE(complex(selected_real_kind(31)),
|
|
OMPI_RANGE_F90_COMPLEX32)
|
|
fi
|
|
|
|
OMPI_F90_GET_SIZEOF(logical, OMPI_SIZEOF_F90_LOGICAL)
|
|
OMPI_F90_GET_ALIGNMENT(logical, OMPI_ALIGNMENT_F90_LOGICAL)
|
|
|
|
OMPI_F90_GET_SIZEOF(integer, OMPI_SIZEOF_F90_INT)
|
|
OMPI_F90_GET_ALIGNMENT(integer, OMPI_ALIGNMENT_F90_INT)
|
|
|
|
OMPI_F90_GET_SIZEOF(real, OMPI_SIZEOF_F90_REAL)
|
|
OMPI_F90_GET_ALIGNMENT(real, OMPI_ALIGNMENT_F90_REAL)
|
|
|
|
OMPI_F90_GET_SIZEOF(real(kind(1.D0)), OMPI_SIZEOF_F90_DBLPREC)
|
|
OMPI_F90_GET_ALIGNMENT(real(kind(1.D0)), OMPI_ALIGNMENT_F90_DBLPREC)
|
|
|
|
OMPI_F90_GET_SIZEOF(complex, OMPI_SIZEOF_F90_COMPLEX)
|
|
OMPI_F90_GET_ALIGNMENT(complex, OMPI_ALIGNMENT_F90_COMPLEX)
|
|
|
|
OMPI_F90_GET_SIZEOF(complex(kind(1.D0)), OMPI_SIZEOF_F90_DBLCOMPLEX)
|
|
OMPI_F90_GET_ALIGNMENT(complex(kind(1.D0)), OMPI_ALIGNMENT_F90_DBLCOMPLEX)
|
|
|
|
#
|
|
# get values for Fortran MPI_OFFSET_KIND and MPI_ADDRESS_KIND
|
|
#
|
|
|
|
OMPI_F90_GET_INT_KIND(18, OMPI_MPI_OFFSET_KIND)
|
|
|
|
if test "$ac_cv_sizeof_void_p" = "2"; then
|
|
OMPI_F90_GET_INT_KIND(4, OMPI_MPI_ADDRESS_KIND)
|
|
elif test "$ac_cv_sizeof_void_p" = "4"; then
|
|
OMPI_F90_GET_INT_KIND(9, OMPI_MPI_ADDRESS_KIND)
|
|
elif test "$ac_cv_sizeof_void_p" = "8"; then
|
|
OMPI_F90_GET_INT_KIND(18, OMPI_MPI_ADDRESS_KIND)
|
|
elif test "$ac_cv_sizeof_void_p" = "16"; then
|
|
OMPI_F90_GET_INT_KIND(19, OMPI_MPI_ADDRESS_KIND)
|
|
else
|
|
AC_MSG_ERROR([Cannot support Fortran MPI_ADDRESS_KIND!])
|
|
fi
|
|
fi
|
|
|
|
#
|
|
# Check sizes against what is expected and fix things up
|
|
#
|
|
|
|
if test "$OMPI_SIZEOF_F90_INT1" != "1" ; then
|
|
OMPI_SIZEOF_F90_INT1=0
|
|
OMPI_ALIGNMENT_F90_INT1=0
|
|
OMPI_HAVE_F90_INTEGER1=0
|
|
fi
|
|
if test "$OMPI_SIZEOF_F90_INT2" != "2" ; then
|
|
OMPI_SIZEOF_F90_INT2=0
|
|
OMPI_ALIGNMENT_F90_INT2=0
|
|
OMPI_HAVE_F90_INTEGER2=0
|
|
fi
|
|
if test "$OMPI_SIZEOF_F90_INT4" != "4" ; then
|
|
OMPI_SIZEOF_F90_INT4=0
|
|
OMPI_ALIGNMENT_F90_INT4=0
|
|
OMPI_HAVE_F90_INTEGER4=0
|
|
fi
|
|
if test "$OMPI_SIZEOF_F90_INT8" != "8" ; then
|
|
OMPI_SIZEOF_F90_INT8=0
|
|
OMPI_ALIGNMENT_F90_INT8=0
|
|
OMPI_HAVE_F90_INTEGER8=0
|
|
fi
|
|
if test "$OMPI_SIZEOF_F90_INT16" != "16" ; then
|
|
OMPI_SIZEOF_F90_INT16=0
|
|
OMPI_ALIGNMENT_F90_INT16=0
|
|
OMPI_HAVE_F90_INTEGER16=0
|
|
fi
|
|
|
|
if test "$OMPI_SIZEOF_F90_REAL4" != "4" ; then
|
|
OMPI_SIZEOF_F90_REAL4=0
|
|
OMPI_ALIGNMENT_F90_REAL4=0
|
|
OMPI_PRECISION_F90_REAL4=0
|
|
OMPI_RANGE_F90_REAL4=0
|
|
OMPI_HAVE_F90_REAL4=0
|
|
fi
|
|
if test "$OMPI_SIZEOF_F90_REAL8" != "8" ; then
|
|
OMPI_SIZEOF_F90_REAL8=0
|
|
OMPI_ALIGNMENT_F90_REAL8=0
|
|
OMPI_PRECISION_F90_REAL8=0
|
|
OMPI_RANGE_F90_REAL8=0
|
|
OMPI_HAVE_F90_REAL8=0
|
|
fi
|
|
if test "$OMPI_SIZEOF_F90_REAL16" != "16" ; then
|
|
OMPI_SIZEOF_F90_REAL16=0
|
|
OMPI_ALIGNMENT_F90_REAL16=0
|
|
OMPI_PRECISION_F90_REAL16=0
|
|
OMPI_RANGE_F90_REAL16=0
|
|
OMPI_HAVE_F90_REAL16=0
|
|
fi
|
|
|
|
if test "$OMPI_SIZEOF_F90_COMPLEX8" != "8" ; then
|
|
OMPI_SIZEOF_F90_COMPLEX8=0
|
|
OMPI_ALIGNMENT_F90_COMPLEX8=0
|
|
OMPI_PRECISION_F90_COMPLEX8=0
|
|
OMPI_RANGE_F90_COMPLEX8=0
|
|
OMPI_HAVE_F90_COMPLEX8=0
|
|
fi
|
|
if test "$OMPI_SIZEOF_F90_COMPLEX16" != "16" ; then
|
|
OMPI_SIZEOF_F90_COMPLEX16=0
|
|
OMPI_ALIGNMENT_F90_COMPLEX16=0
|
|
OMPI_PRECISION_F90_COMPLEX16=0
|
|
OMPI_RANGE_F90_COMPLEX16=0
|
|
OMPI_HAVE_F90_COMPLEX16=0
|
|
fi
|
|
if test "$OMPI_SIZEOF_F90_COMPLEX32" != "32" ; then
|
|
OMPI_SIZEOF_F90_COMPLEX32=0
|
|
OMPI_ALIGNMENT_F90_COMPLEX32=0
|
|
OMPI_PRECISION_F90_COMPLEX32=0
|
|
OMPI_RANGE_F90_COMPLEX32=0
|
|
OMPI_HAVE_F90_COMPLEX32=0
|
|
fi
|
|
|
|
AC_SUBST(OMPI_FORTRAN_LKINDS)
|
|
AC_SUBST(OMPI_FORTRAN_IKINDS)
|
|
AC_SUBST(OMPI_FORTRAN_RKINDS)
|
|
AC_SUBST(OMPI_FORTRAN_CKINDS)
|
|
|
|
AC_SUBST(OMPI_SIZEOF_F90_INT1)
|
|
AC_SUBST(OMPI_SIZEOF_F90_INT2)
|
|
AC_SUBST(OMPI_SIZEOF_F90_INT4)
|
|
AC_SUBST(OMPI_SIZEOF_F90_INT8)
|
|
AC_SUBST(OMPI_SIZEOF_F90_INT16)
|
|
|
|
AC_SUBST(OMPI_SIZEOF_F90_REAL4)
|
|
AC_SUBST(OMPI_SIZEOF_F90_REAL8)
|
|
AC_SUBST(OMPI_SIZEOF_F90_REAL16)
|
|
|
|
AC_SUBST(OMPI_SIZEOF_F90_COMPLEX8)
|
|
AC_SUBST(OMPI_SIZEOF_F90_COMPLEX16)
|
|
AC_SUBST(OMPI_SIZEOF_F90_COMPLEX32)
|
|
|
|
AC_SUBST(OMPI_MPI_OFFSET_KIND)
|
|
AC_SUBST(OMPI_MPI_ADDRESS_KIND)
|
|
|
|
AC_DEFINE_UNQUOTED(OMPI_HAVE_F90_INTEGER1, $OMPI_HAVE_F90_INTEGER1,
|
|
[support for fortran integer*1])
|
|
AC_DEFINE_UNQUOTED(OMPI_HAVE_F90_INTEGER2, $OMPI_HAVE_F90_INTEGER2,
|
|
[support for fortran integer*2])
|
|
AC_DEFINE_UNQUOTED(OMPI_HAVE_F90_INTEGER4, $OMPI_HAVE_F90_INTEGER4,
|
|
[support for fortran integer*4])
|
|
AC_DEFINE_UNQUOTED(OMPI_HAVE_F90_INTEGER8, $OMPI_HAVE_F90_INTEGER8,
|
|
[support for fortran integer*8])
|
|
AC_DEFINE_UNQUOTED(OMPI_HAVE_F90_INTEGER16, $OMPI_HAVE_F90_INTEGER16,
|
|
[support for fortran integer*16])
|
|
|
|
AC_DEFINE_UNQUOTED(OMPI_HAVE_F90_REAL4, $OMPI_HAVE_F90_REAL4,
|
|
[support for fortran real*4])
|
|
AC_DEFINE_UNQUOTED(OMPI_HAVE_F90_REAL8, $OMPI_HAVE_F90_REAL8,
|
|
[support for fortran real*8])
|
|
AC_DEFINE_UNQUOTED(OMPI_HAVE_F90_REAL16, $OMPI_HAVE_F90_REAL16,
|
|
[support for fortran real*16])
|
|
|
|
AC_DEFINE_UNQUOTED(OMPI_HAVE_F90_COMPLEX8, $OMPI_HAVE_F90_COMPLEX8,
|
|
[support for fortran complex*8])
|
|
AC_DEFINE_UNQUOTED(OMPI_HAVE_F90_COMPLEX16, $OMPI_HAVE_F90_COMPLEX16,
|
|
[support for fortran complex*16])
|
|
AC_DEFINE_UNQUOTED(OMPI_HAVE_F90_COMPLEX32, $OMPI_HAVE_F90_COMPLEX32,
|
|
[support for fortran complex*32])
|
|
|
|
AC_DEFINE_UNQUOTED(OMPI_SIZEOF_F90_INT1, $OMPI_SIZEOF_F90_INT1,
|
|
[size of fortran integer*1])
|
|
AC_DEFINE_UNQUOTED(OMPI_SIZEOF_F90_INT2, $OMPI_SIZEOF_F90_INT2,
|
|
[size of fortran integer*2])
|
|
AC_DEFINE_UNQUOTED(OMPI_SIZEOF_F90_INT4, $OMPI_SIZEOF_F90_INT4,
|
|
[size of fortran integer*4])
|
|
AC_DEFINE_UNQUOTED(OMPI_SIZEOF_F90_INT8, $OMPI_SIZEOF_F90_INT8,
|
|
[size of fortran integer*8])
|
|
AC_DEFINE_UNQUOTED(OMPI_SIZEOF_F90_INT16, $OMPI_SIZEOF_F90_INT16,
|
|
[size of fortran integer*16])
|
|
|
|
AC_DEFINE_UNQUOTED(OMPI_SIZEOF_F90_REAL4, $OMPI_SIZEOF_F90_REAL4,
|
|
[size of fortran real*4])
|
|
AC_DEFINE_UNQUOTED(OMPI_SIZEOF_F90_REAL8, $OMPI_SIZEOF_F90_REAL8,
|
|
[size of fortran real*8])
|
|
AC_DEFINE_UNQUOTED(OMPI_SIZEOF_F90_REAL16, $OMPI_SIZEOF_F90_REAL16,
|
|
[size of fortran real*16])
|
|
|
|
AC_DEFINE_UNQUOTED(OMPI_SIZEOF_F90_COMPLEX8, $OMPI_SIZEOF_F90_COMPLEX8,
|
|
[size of fortran complex*8])
|
|
AC_DEFINE_UNQUOTED(OMPI_SIZEOF_F90_COMPLEX16, $OMPI_SIZEOF_F90_COMPLEX16,
|
|
[size of fortran complex*16])
|
|
AC_DEFINE_UNQUOTED(OMPI_SIZEOF_F90_COMPLEX32, $OMPI_SIZEOF_F90_COMPLEX32,
|
|
[size of fortran complex*32])
|
|
|
|
AC_DEFINE_UNQUOTED(OMPI_ALIGNMENT_F90_LOGICAL, $OMPI_ALIGNMENT_F90_LOGICAL,
|
|
[Alignment of fortran logical])
|
|
AC_DEFINE_UNQUOTED(OMPI_ALIGNMENT_F90_INT, $OMPI_ALIGNMENT_F90_INT,
|
|
[Alignment of fortran integer])
|
|
AC_DEFINE_UNQUOTED(OMPI_ALIGNMENT_F90_REAL, $OMPI_ALIGNMENT_F90_REAL,
|
|
[alignment of fortran real])
|
|
AC_DEFINE_UNQUOTED(OMPI_ALIGNMENT_F90_DBLPREC, $OMPI_ALIGNMENT_F90_DBLPREC,
|
|
[Alignment of fortran double precision])
|
|
AC_DEFINE_UNQUOTED(OMPI_ALIGNMENT_F90_COMPLEX, $OMPI_ALIGNMENT_F90_COMPLEX,
|
|
[Alignment of fortran complex])
|
|
AC_DEFINE_UNQUOTED(OMPI_ALIGNMENT_F90_DBLCOMPLEX,
|
|
$OMPI_ALIGNMENT_F90_DBLCOMPLEX,
|
|
[Alignment of fortran double complex])
|
|
|
|
AC_DEFINE_UNQUOTED(OMPI_ALIGNMENT_F90_INT1, $OMPI_ALIGNMENT_F90_INT1,
|
|
[alignment of fortran integer*1])
|
|
AC_DEFINE_UNQUOTED(OMPI_ALIGNMENT_F90_INT2, $OMPI_ALIGNMENT_F90_INT2,
|
|
[alignment of fortran integer*2])
|
|
AC_DEFINE_UNQUOTED(OMPI_ALIGNMENT_F90_INT4, $OMPI_ALIGNMENT_F90_INT4,
|
|
[alignment of fortran integer*4])
|
|
AC_DEFINE_UNQUOTED(OMPI_ALIGNMENT_F90_INT8, $OMPI_ALIGNMENT_F90_INT8,
|
|
[alignment of fortran integer*8])
|
|
AC_DEFINE_UNQUOTED(OMPI_ALIGNMENT_F90_INT16, $OMPI_ALIGNMENT_F90_INT16,
|
|
[alignment of fortran integer*16])
|
|
|
|
AC_DEFINE_UNQUOTED(OMPI_ALIGNMENT_F90_REAL4, $OMPI_ALIGNMENT_F90_REAL4,
|
|
[alignment of fortran real*4])
|
|
AC_DEFINE_UNQUOTED(OMPI_ALIGNMENT_F90_REAL8, $OMPI_ALIGNMENT_F90_REAL8,
|
|
[alignment of fortran real*8])
|
|
AC_DEFINE_UNQUOTED(OMPI_ALIGNMENT_F90_REAL16, $OMPI_ALIGNMENT_F90_REAL16,
|
|
[alignment of fortran real*16])
|
|
|
|
AC_DEFINE_UNQUOTED(OMPI_ALIGNMENT_F90_COMPLEX8, $OMPI_ALIGNMENT_F90_COMPLEX8,
|
|
[alignment of fortran complex*8])
|
|
AC_DEFINE_UNQUOTED(OMPI_ALIGNMENT_F90_COMPLEX16, $OMPI_ALIGNMENT_F90_COMPLEX16,
|
|
[alignment of fortran complex*16])
|
|
AC_DEFINE_UNQUOTED(OMPI_ALIGNMENT_F90_COMPLEX32, $OMPI_ALIGNMENT_F90_COMPLEX32,
|
|
[alignment of fortran complex*32])
|
|
|
|
AC_DEFINE_UNQUOTED(OMPI_PRECISION_F90_REAL4, $OMPI_PRECISION_F90_REAL4,
|
|
[precision of fortran real*4])
|
|
AC_DEFINE_UNQUOTED(OMPI_PRECISION_F90_REAL8, $OMPI_PRECISION_F90_REAL8,
|
|
[precision of fortran real*8])
|
|
AC_DEFINE_UNQUOTED(OMPI_PRECISION_F90_REAL16, $OMPI_PRECISION_F90_REAL16,
|
|
[precision of fortran real*16])
|
|
|
|
AC_DEFINE_UNQUOTED(OMPI_PRECISION_F90_COMPLEX8, $OMPI_PRECISION_F90_COMPLEX8,
|
|
[precision of fortran complex*8])
|
|
AC_DEFINE_UNQUOTED(OMPI_PRECISION_F90_COMPLEX16, $OMPI_PRECISION_F90_COMPLEX16,
|
|
[precision of fortran complex*16])
|
|
AC_DEFINE_UNQUOTED(OMPI_PRECISION_F90_COMPLEX32, $OMPI_PRECISION_F90_COMPLEX32,
|
|
[precision of fortran complex*32])
|
|
|
|
AC_DEFINE_UNQUOTED(OMPI_RANGE_F90_REAL4, $OMPI_RANGE_F90_REAL4,
|
|
[range of fortran real*4])
|
|
AC_DEFINE_UNQUOTED(OMPI_RANGE_F90_REAL8, $OMPI_RANGE_F90_REAL8,
|
|
[range of fortran real*8])
|
|
AC_DEFINE_UNQUOTED(OMPI_RANGE_F90_REAL16, $OMPI_RANGE_F90_REAL16,
|
|
[range of fortran real*16])
|
|
|
|
AC_DEFINE_UNQUOTED(OMPI_RANGE_F90_COMPLEX8, $OMPI_RANGE_F90_COMPLEX8,
|
|
[range of fortran complex*8])
|
|
AC_DEFINE_UNQUOTED(OMPI_RANGE_F90_COMPLEX16, $OMPI_RANGE_F90_COMPLEX16,
|
|
[range of fortran complex*16])
|
|
AC_DEFINE_UNQUOTED(OMPI_RANGE_F90_COMPLEX32, $OMPI_RANGE_F90_COMPLEX32,
|
|
[range of fortran complex*32])
|
|
|
|
# checkpoint results
|
|
AC_CACHE_SAVE
|
|
|
|
##################################
|
|
# Header files
|
|
##################################
|
|
|
|
ompi_show_title "Header file tests"
|
|
|
|
AC_CHECK_HEADERS([alloca.h aio.h arpa/inet.h dirent.h \
|
|
dlfcn.h execinfo.h err.h fcntl.h inttypes.h libgen.h libutil.h \
|
|
net/if.h netdb.h netinet/in.h netinet/tcp.h \
|
|
poll.h pthread.h pty.h pwd.h sched.h stdint.h \
|
|
string.h strings.h stropts.h sys/fcntl.h sys/ipc.h \
|
|
sys/ioctl.h sys/mman.h sys/param.h sys/queue.h \
|
|
sys/resource.h sys/select.h sys/socket.h sys/sockio.h \
|
|
sys/stat.h sys/statvfs.h sys/time.h sys/tree.h \
|
|
sys/types.h sys/uio.h sys/utsname.h sys/wait.h syslog.h \
|
|
time.h termios.h ulimit.h unistd.h util.h])
|
|
|
|
# Note that sometimes we have <stdbool.h>, but it doesn't work (e.g.,
|
|
# have both Portland and GNU installed; using pgcc will find GNU's
|
|
# <stdbool.h>, which all it does -- by standard -- is define "bool" to
|
|
# "_Bool" [see
|
|
# http://www.opengroup.org/onlinepubs/009695399/basedefs/stdbool.h.html],
|
|
# and Portland has no idea what to do with _Bool).
|
|
|
|
# So first figure out if we have <stdbool.h> (i.e., check the value of
|
|
# the macro HAVE_STDBOOL_H from the result of AC_CHECK_HEADERS,
|
|
# above). If we do have it, then check to see if it actually works.
|
|
# Define OMPI_USE_STDBOOL_H as approrpaite.
|
|
AC_CHECK_HEADERS([stdbool.h], [have_stdbool_h=1], [have_stdbool_h=0])
|
|
AC_MSG_CHECKING([if <stdbool.h> works])
|
|
if test "$have_stdbool_h" = "1"; then
|
|
AC_COMPILE_IFELSE(AC_LANG_PROGRAM([[
|
|
AC_INCLUDES_DEFAULT
|
|
#if HAVE_STDBOOL_H
|
|
#include <stdbool.h>
|
|
#endif]],
|
|
[[bool bar, foo = true; bar = foo;]]),
|
|
[OMPI_USE_STDBOOL_H=1 MSG=yes],[OMPI_USE_STDBOOL_H=0 MSG=no])
|
|
else
|
|
OMPI_USE_STDBOOL_H=0
|
|
MSG="no (don't have <stdbool.h>)"
|
|
fi
|
|
AC_DEFINE_UNQUOTED(OMPI_USE_STDBOOL_H, $OMPI_USE_STDBOOL_H,
|
|
[Whether to use <stdbool.h> or not])
|
|
AC_MSG_RESULT([$MSG])
|
|
|
|
# checkpoint results
|
|
AC_CACHE_SAVE
|
|
|
|
|
|
##################################
|
|
# Types
|
|
##################################
|
|
|
|
ompi_show_title "Type tests"
|
|
|
|
# Size of pid_t
|
|
AC_CHECK_SIZEOF(pid_t)
|
|
|
|
AC_CHECK_TYPES([socklen_t], [AC_DEFINE([HAVE_SOCKLEN_T], [1],
|
|
[Whether we have socklen_t or not])],
|
|
[], [AC_INCLUDES_DEFAULT
|
|
#include <sys/socket.h>])
|
|
|
|
AC_CHECK_TYPES([struct sockaddr_in], [], [], [AC_INCLUDES_DEFAULT
|
|
#ifdef HAVE_NETINET_IN_H
|
|
#include <netinet/in.h>
|
|
#endif])
|
|
|
|
# SA_RESTART in signal.h
|
|
AC_MSG_CHECKING([if SA_RESTART defined in signal.h])
|
|
AC_EGREP_CPP(yes, [
|
|
#include <signal.h>
|
|
#ifdef SA_RESTART
|
|
yes
|
|
#endif ], [MSG=yes VALUE=1], [MSG=no VALUE=0])
|
|
AC_DEFINE_UNQUOTED(OMPI_HAVE_SA_RESTART, $VALUE,
|
|
[Whether we have SA_RESTART in <signal.h> or not])
|
|
AC_MSG_RESULT([$MSG])
|
|
|
|
# sa_len in struct sockaddr
|
|
AC_MSG_CHECKING([for sa_len in struct sockaddr])
|
|
AC_TRY_COMPILE([#include <sys/types.h>
|
|
#include <sys/socket.h>], [struct sockaddr s; s.sa_len;],
|
|
[MSG=yes VALUE=1], [MSG=no VALUE=0])
|
|
AC_DEFINE_UNQUOTED(OMPI_HAVE_SA_LEN, $VALUE,
|
|
[Whether we have the sa_len struct in <sys/socket.h> or not])
|
|
AC_MSG_RESULT([$MSG])
|
|
|
|
AC_CHECK_MEMBERS([struct dirent.d_type], [], [], [
|
|
#include <sys/types.h>
|
|
#include <dirent.h>])
|
|
|
|
AC_CHECK_MEMBERS([siginfo_t.si_fd],,,[#include <signal.h>])
|
|
|
|
|
|
# checkpoint results
|
|
AC_CACHE_SAVE
|
|
|
|
|
|
##################################
|
|
# Libraries
|
|
##################################
|
|
|
|
ompi_show_title "Library and Function tests"
|
|
|
|
AC_CHECK_LIB([util], [openpty],
|
|
[WRAPPER_EXTRA_LIBS="$WRAPPER_EXTRA_LIBS -lutil"
|
|
LIBS="$LIBS -lutil"])
|
|
|
|
AC_CHECK_LIB([nsl], [gethostbyname],
|
|
[WRAPPER_EXTRA_LIBS="$WRAPPER_EXTRA_LIBS -lnsl"
|
|
LIBS="$LIBS -lnsl"])
|
|
|
|
AC_CHECK_LIB([socket], [socket],
|
|
[WRAPPER_EXTRA_LIBS="$WRAPPER_EXTRA_LIBS -lsocket"
|
|
LIBS="$LIBS -lsocket"])
|
|
|
|
AC_CHECK_FUNCS([asprintf snprintf vasprintf vsnprintf openpty isatty htonl ntohl htons ntohs getpwuid fork waitpid execve pipe setsid mmap])
|
|
|
|
#
|
|
# Make sure we can copy va_lists (need check declared, not linkable)
|
|
#
|
|
|
|
AC_CHECK_DECL(va_copy, OMPI_HAVE_VA_COPY=1, OMPI_HAVE_VA_COPY=0,
|
|
[#include <stdarg.h>])
|
|
AC_DEFINE_UNQUOTED(OMPI_HAVE_VA_COPY, $OMPI_HAVE_VA_COPY,
|
|
[Whether we have va_copy or not])
|
|
|
|
AC_CHECK_DECL(__va_copy, OMPI_HAVE_UNDERSCORE_VA_COPY=1,
|
|
OMPI_HAVE_UNDERSCORE_VA_COPY=0, [#include <stdarg.h>])
|
|
AC_DEFINE_UNQUOTED(OMPI_HAVE_UNDERSCORE_VA_COPY, $OMPI_HAVE_UNDERSCORE_VA_COPY,
|
|
[Whether we have __va_copy or not])
|
|
|
|
AC_CHECK_DECLS(__func__)
|
|
|
|
#
|
|
# Solaris has sched_yield in -lrt. Can't use a simple AC_CHECK_LIB,
|
|
# though, because Linux has sched_yield in glic (so linking in librt
|
|
# will "find" sched_yield, even though it would have been found anyway
|
|
# -- so -lrt would be useless [and potentially harmful?] in this
|
|
# case).
|
|
#
|
|
|
|
AC_MSG_CHECKING([if we need -lrt for sched_yield])
|
|
AC_LINK_IFELSE(AC_LANG_PROGRAM([[extern char *sched_yield;]],
|
|
[[char *bar = sched_yield;]]),
|
|
[MSG=no],[MSG=not_found])
|
|
if test "$MSG" = "not_found"; then
|
|
LIBS_save="$LIBS"
|
|
LIBS="$LIBS -lrt"
|
|
AC_LINK_IFELSE(AC_LANG_PROGRAM([[extern char *sched_yield;]],
|
|
[[char *bar = sched_yield;]]),
|
|
[MSG=yes],[MSG=not_found])
|
|
if test "$MSG" = "not_found"; then
|
|
LIBS="$LIBS_save"
|
|
fi
|
|
fi
|
|
AC_MSG_RESULT([$MSG])
|
|
|
|
# see if we actually have sched_yeild. Use AC_CHECK_FUNCS so that it
|
|
# does the glibs "not implemented" check. Will use the current LIBS,
|
|
# so will check in -lrt if we decided we needed it above
|
|
AC_CHECK_FUNCS([sched_yield])
|
|
|
|
#
|
|
# FreeBSD has backtrace in -lexecinfo. Can't use a simple AC_CHECK_LIB,
|
|
# though, because Linux has backtrace in glic (so linking in libexecinfo
|
|
# will "find" backtrace, even though it would have been found anyway
|
|
# -- so -lexecinfo would be useless [and potentially harmful?] in this
|
|
# case).
|
|
#
|
|
|
|
AC_MSG_CHECKING([if we need -lexecinfo for backtrace])
|
|
AC_LINK_IFELSE(AC_LANG_PROGRAM([[extern char *backtrace;]],
|
|
[[char *bar = backtrace;]]),
|
|
[MSG=no],[MSG=not_found])
|
|
if test "$MSG" = "not_found"; then
|
|
LIBS_save="$LIBS"
|
|
LIBS="$LIBS -lexecinfo"
|
|
AC_LINK_IFELSE(AC_LANG_PROGRAM([[extern char *backtrace;]],
|
|
[[char *bar = backtrace;]]),
|
|
[MSG=yes],[MSG=not_found])
|
|
if test "$MSG" = "not_found"; then
|
|
LIBS="$LIBS_save"
|
|
fi
|
|
fi
|
|
AC_MSG_RESULT([$MSG])
|
|
|
|
# see if we actually have backtrace. Use AC_CHECK_FUNCS so that it
|
|
# does the glibs "not implemented" check. Will use the current LIBS,
|
|
# so will check in -lexecinfo if we decided we needed it above
|
|
AC_CHECK_FUNCS([backtrace])
|
|
|
|
#
|
|
# See if we need the math library explicitly linked in
|
|
#
|
|
|
|
AC_CHECK_LIB([m], [ceil])
|
|
|
|
# checkpoint results
|
|
AC_CACHE_SAVE
|
|
|
|
|
|
##################################
|
|
# System-specific tests
|
|
##################################
|
|
|
|
ompi_show_title "System-specific tests"
|
|
|
|
#
|
|
# Test to determine type of MPI_Offset. This is searched in the following order
|
|
# int64_t, long long, long, int. If none of these are 8 bytes, then we should
|
|
# search for int32_t, long long, long, int.
|
|
#
|
|
MPI_OFFSET_TYPE="not found"
|
|
MPI_OFFSET_DATATYPE="not found"
|
|
AC_MSG_CHECKING([checking for type of MPI_Offset])
|
|
if test "$ac_cv_type_long_long" = "yes" -a "$ac_cv_sizeof_long_long" = 8; then
|
|
MPI_OFFSET_TYPE="long long"
|
|
MPI_OFFSET_DATATYPE=MPI_LONG_LONG
|
|
MPI_OFFSET_SIZE=8
|
|
elif test "$ac_cv_type_long" = "yes" -a "$ac_cv_sizeof_long" = 8; then
|
|
MPI_OFFSET_TYPE="long"
|
|
MPI_OFFSET_DATATYPE=MPI_LONG
|
|
MPI_OFFSET_SIZE=8
|
|
elif test "ac_cv_sizeof_int" = 8; then
|
|
MPI_OFFSET_TYPE=int
|
|
MPI_OFFSET_DATATYPE=MPI_INT
|
|
MPI_OFFSET_SIZE=8
|
|
elif test "$ac_cv_type_long_long" = "yes" -a "$ac_cv_sizeof_long_long" = 4; then
|
|
MPI_OFFSET_TYPE="long long"
|
|
MPI_OFFSET_DATATYPE=MPI_LONG_LONG
|
|
MPI_OFFSET_SIZE=4
|
|
elif test "$ac_cv_type_long" = "yes" -a "$ac_cv_sizeof_long" = 4; then
|
|
MPI_OFFSET_TYPE="long"
|
|
MPI_OFFSET_DATATYPE=MPI_LONG
|
|
MPI_OFFSET_SIZE=4
|
|
elif test "ac_cv_sizeof_int" = 4; then
|
|
MPI_OFFSET_TYPE=int
|
|
MPI_OFFSET_DATATYPE=MPI_INT
|
|
MPI_OFFSET_SIZE=4
|
|
fi
|
|
AC_MSG_RESULT([$MPI_OFFSET_TYPE])
|
|
if test "$MPI_OFFSET_TYPE" = "not found"; then
|
|
AC_MSG_WARN([*** Unable to find the right definition for MPI_Offset])
|
|
AC_MSG_ERROR([Cannot continue])
|
|
fi
|
|
AC_DEFINE_UNQUOTED(MPI_Offset, $MPI_OFFSET_TYPE, [Type of MPI_Offset])
|
|
|
|
#
|
|
# If we haven't already, figure out an MPI datatype that corresponds
|
|
# to the back-end C type of MPI_Offset.
|
|
#
|
|
AC_MSG_CHECKING([checking for an MPI datatype for MPI_Offset])
|
|
AC_MSG_RESULT([$MPI_OFFSET_DATATYPE])
|
|
if test "$MPI_OFFSET_DATATYPE" = "not found"; then
|
|
AC_MSG_WARN([*** Unable to find an MPI datatype corresponding to MPI_Offset])
|
|
AC_MSG_ERROR([Cannot continue])
|
|
fi
|
|
AC_DEFINE_UNQUOTED(OMPI_OFFSET_DATATYPE, $MPI_OFFSET_DATATYPE, [MPI datatype corresponding to MPI_Offset])
|
|
|
|
# all: endian
|
|
|
|
AC_WORDS_BIGENDIAN
|
|
|
|
OMPI_CHECK_BROKEN_QSORT
|
|
|
|
# all: SYSV semaphores
|
|
# all: SYSV shared memory
|
|
# all: size of FD_SET
|
|
# all: sizeof struct stat members
|
|
# all: type of getsockopt optlen
|
|
# all: type of recvfrom optlen
|
|
|
|
#
|
|
# Check out what thread support we have
|
|
#
|
|
|
|
OMPI_CONFIG_THREADS
|
|
CFLAGS="$CFLAGS $THREAD_CFLAGS"
|
|
CXXFLAGS="$CXXFLAGS $THREAD_CXXFLAGS"
|
|
CPPFLAGS="$CPPFLAGS $THREAD_CPPFLAGS"
|
|
CXXCPPFLAGS="$CXXCPPFLAGS $THREAD_CXXCPPFLAGS"
|
|
LDFLAGS="$LDFLAGS $THREAD_LDFLAGS"
|
|
LIBS="$LIBS $THREAD_LIBS"
|
|
|
|
WRAPPER_EXTRA_CFLAGS="$WRAPPER_EXTRA_CFLAGS $THREAD_CFLAGS"
|
|
WRAPPER_EXTRA_CXXFLAGS="$WRAPPER_EXTRA_CXXFLAGS $THREAD_CXXFLAGS"
|
|
WRAPPER_EXTRA_FFLAGS="$WRAPPER_EXTRA_FFLAGS $THREAD_FFLAGS"
|
|
WRAPPER_EXTRA_FCFLAGS="$WRAPPER_EXTRA_FCFLAGS $THREAD_FFLAGS"
|
|
WRAPPER_EXTRA_LDFLAGS="$WRAPPER_EXTRA_LDFLAGS $THREAD_LDFLAGS"
|
|
WRAPPER_EXTRA_LIBS="$WRAPPER_EXTRA_LIBS $THREAD_LIBS"
|
|
|
|
#
|
|
# What is the local equivalent of "ln -s"
|
|
#
|
|
|
|
AC_PROG_LN_S
|
|
|
|
#
|
|
# We need as and lex
|
|
#
|
|
AM_PROG_AS
|
|
AM_PROG_LEX
|
|
|
|
# If we don't have GNU Flex and we don't have a generated .c file
|
|
# (distribution tarballs will have the .c file included, but SVN
|
|
# checkouts will not), then error. Must have GNU Flex -- other
|
|
# versions of Lex are not workable (all things being equal, since this
|
|
# is *only* required for developers, we decided that it really was not
|
|
# worth it to be portable between different versions of lex ;-).
|
|
|
|
if test -z "$LEX" -o -n "`echo $LEX | grep missing`" -o \
|
|
"`basename $LEX`" != "flex"; then
|
|
if test ! -f "$srcdir/opal/util/show_help_lex.c"; then
|
|
AC_MSG_WARN([*** Could not find GNU Flex on your system.])
|
|
AC_MSG_WARN([*** GNU Flex required for developer builds of Open MPI.])
|
|
AC_MSG_WARN([*** Other versions of Lex are not supported.])
|
|
AC_MSG_WARN([*** YOU DO NOT NEED FLEX FOR DISTRIBUTION TARBALLS!])
|
|
AC_MSG_WARN([*** If you absolutely cannot install GNU Flex on this system])
|
|
AC_MSG_WARN([*** consider using a distribution tarball, or generate the])
|
|
AC_MSG_WARN([*** following files on another system (using Flex) and])
|
|
AC_MSG_WARN([*** copy them here:])
|
|
for lfile in `find . -name \*.l -print`; do
|
|
cfile="`echo $lfile | cut -d. -f-2`"
|
|
AC_MSG_WARN([*** $cfile.c])
|
|
done
|
|
AC_MSG_ERROR([Cannot continue])
|
|
fi
|
|
fi
|
|
|
|
#
|
|
# File system case sensitivity
|
|
#
|
|
|
|
OMPI_CASE_SENSITIVE_FS_SETUP
|
|
|
|
# AIX: FIONBIO in sys/ioctl.h
|
|
# glibc: memcpy
|
|
|
|
# checkpoint results
|
|
AC_CACHE_SAVE
|
|
|
|
|
|
##################################
|
|
# MCA
|
|
##################################
|
|
|
|
ompi_show_title "Modular Component Architecture (MCA) setup"
|
|
|
|
AC_MSG_CHECKING([for subdir args])
|
|
OMPI_CONFIG_SUBDIR_ARGS([ompi_subdir_args])
|
|
AC_MSG_RESULT([$ompi_subdir_args])
|
|
|
|
OMPI_MCA
|
|
|
|
# checkpoint results
|
|
AC_CACHE_SAVE
|
|
|
|
|
|
############################################################################
|
|
# Final top-level OMPI configuration
|
|
############################################################################
|
|
|
|
ompi_show_title "Final top-level OMPI configuration"
|
|
|
|
############################################################################
|
|
# Libevent setup
|
|
############################################################################
|
|
|
|
ompi_show_subtitle "Libevent 3rd party event handler"
|
|
CFLAGS_save="$CFLAGS"
|
|
CFLAGS="$OMPI_CFLAGS_BEFORE_PICKY"
|
|
OMPI_SETUP_LIBEVENT
|
|
CFLAGS="$CFLAGS_save"
|
|
|
|
|
|
############################################################################
|
|
# Libtool: part two
|
|
# (after C compiler setup)
|
|
############################################################################
|
|
|
|
ompi_show_subtitle "Libtool configuration"
|
|
|
|
# Use convenience libltdl for the moment, because we need to force the
|
|
# use of the newest libltdl (i.e., the one that ships with libtool
|
|
# 1.5) because it has support for a lot more things than older
|
|
# versions of libtool (which are generally installed by default).
|
|
AS_IF([test "$OMPI_ENABLE_DLOPEN_SUPPORT" = "1"],
|
|
[AC_LIBLTDL_CONVENIENCE(opal/libltdl)
|
|
AC_LIBTOOL_DLOPEN])
|
|
AC_SUBST(LTDLINCL)
|
|
AC_SUBST(LIBLTDL)
|
|
AM_PROG_LIBTOOL
|
|
|
|
# AC_CONFIG_SUBDIRS appears to be broken for non-gcc compilers (i.e.,
|
|
# passing precious variables down to the sub-configure).
|
|
#
|
|
# Note that we also did some magic scripty-foo in autogen.sh to rename
|
|
# the output libtool library "libompi_ltdl", so add -lompi_ltdl here.
|
|
# This is because so many systems have older versions of libltdl
|
|
# installed very early in ld.so's search path; if we installed our own
|
|
# libltdl in some non-standard path (e.g., $HOME/local or even
|
|
# /usr/local), the libltdl in /usr/lib might get found first. And if
|
|
# it's older -- or just not matching the version that we need, Bad
|
|
# Things happen. [sigh]
|
|
#
|
|
# Finally, make libompi_ltdl follow the same shared/static convention
|
|
# that was user for the main OMPI libraries. So manually examine
|
|
# $enable_shared and $enable_static and pass down the corresponding
|
|
# flags.
|
|
|
|
ompi_show_subtitle "GNU libltdl setup"
|
|
|
|
if test "$OMPI_ENABLE_DLOPEN_SUPPORT" = "1" ; then
|
|
ompi_subdir_args="$ompi_subdir_args --enable-ltdl-convenience --disable-ltdl-install"
|
|
if test "$enable_shared" = "yes"; then
|
|
ompi_subdir_args="$ompi_subdir_args --enable-shared"
|
|
else
|
|
ompi_subdir_args="$ompi_subdir_args --disable-shared"
|
|
fi
|
|
if test "$enable_static" = "yes"; then
|
|
ompi_subdir_args="$ompi_subdir_args --enable-static"
|
|
else
|
|
ompi_subdir_args="$ompi_subdir_args --disable-static"
|
|
fi
|
|
|
|
CFLAGS_save="$CFLAGS"
|
|
CFLAGS="$OMPI_CFLAGS_BEFORE_PICKY"
|
|
OMPI_CONFIG_SUBDIR(opal/libltdl, [$ompi_subdir_args], [HAPPY=1], [HAPPY=0])
|
|
if test "$HAPPY" = "1"; then
|
|
LIBLTDL_SUBDIR=libltdl
|
|
LIBLTDL_LTLIB=libltdl/libltdlc.la
|
|
WANT_LIBLTDL=1
|
|
|
|
# Arrgh. This is gross. But I can't think of any other way to do
|
|
# it. :-(
|
|
|
|
flags="`egrep ^LIBADD_DL opal/libltdl/Makefile | cut -d= -f2-`"
|
|
OMPI_CHECK_LINKER_FLAGS([opal/libltdl/libtool], [-export-dynamic $flags])
|
|
WRAPPER_EXTRA_LIBS="$WRAPPER_EXTRA_LIBS $extra_ldflags"
|
|
LDFLAGS="-export-dynamic $LDFLAGS"
|
|
else
|
|
LIBLTDL_SUBDIR=
|
|
LIBLTDL_LTLIB=
|
|
WANT_LIBLTDL=0
|
|
fi
|
|
CFLAGS="$CFLAGS_save"
|
|
else
|
|
AC_MSG_WARN([libltdl support disabled (by --disable-dlopen)])
|
|
|
|
LIBLTDL_SUBDIR=
|
|
LIBLTDL_LTLIB=
|
|
WANT_LIBLTDL=0
|
|
fi
|
|
|
|
AC_SUBST(LIBLTDL_SUBDIR)
|
|
AC_SUBST(LIBLTDL_LTLIB)
|
|
AM_CONDITIONAL(WANT_LIBLTDL, test "$WANT_LIBLTDL" = "1")
|
|
AC_DEFINE_UNQUOTED(OMPI_WANT_LIBLTDL, $WANT_LIBLTDL,
|
|
[Whether to include support for libltdl or not])
|
|
|
|
# Have a variable that can be used to indicate where ltdl.h lives. Do
|
|
# this specifically so that we get the included ltdl.h (which we know
|
|
# will work properly with the compiled code, including libltdl), not
|
|
# the system one (which is likely to be far too old and buggy).
|
|
|
|
OPAL_LTDL_CPPFLAGS='-I$(top_srcdir)/opal/libltdl'
|
|
AC_SUBST(OPAL_LTDL_CPPFLAGS)
|
|
|
|
|
|
############################################################################
|
|
# final wrapper compiler config
|
|
############################################################################
|
|
|
|
ompi_show_subtitle "Wrapper compiler flags"
|
|
|
|
#
|
|
# This is needed for VPATH builds, so that it will -I the appropriate
|
|
# include directory. We delayed doing it until now just so that
|
|
# '-I$(top_srcdir)' doesn't show up in any of the configure output --
|
|
# purely aesthetic.
|
|
#
|
|
# JMS: Someday to remove the -I's for the individual ompi, orte, opal
|
|
# directories -- the top-level ones will suffice after all #include's
|
|
# throughout the tree are converted to use the full path of our header
|
|
# files.
|
|
#
|
|
|
|
CPPFLAGS='-I$(top_srcdir)/include -I$(top_srcdir) -I$(top_builddir) -I$(top_builddir)/include -I$(top_srcdir)/opal -I$(top_srcdir)/orte -I$(top_srcdir)/ompi'" $CPPFLAGS"
|
|
CXXCPPFLAGS='-I$(top_srcdir)/include -I$(top_srcdir) -I$(top_builddir) -I$(top_builddir)/include -I$(top_srcdir)/opal -I$(top_srcdir)/orte -I$(top_srcdir)/ompi'" $CXXCPPFLAGS"
|
|
|
|
#
|
|
# Do a final process of the CFLAGS to make a WITHOUT_OPTFLAGS version.
|
|
# We need this so that we can guarantee to build the TotalView stuff
|
|
# with -g and nothing else.
|
|
#
|
|
|
|
OMPI_MAKE_STRIPPED_FLAGS($CFLAGS)
|
|
CFLAGS_WITHOUT_OPTFLAGS="$s_result"
|
|
if test "$with_tv_debug_flags" != ""; then
|
|
TOTALVIEW_DEBUG_FLAGS="$with_tv_debug_flags"
|
|
else
|
|
TOTALVIEW_DEBUG_FLAGS="-g"
|
|
fi
|
|
AC_MSG_CHECKING([which of CFLAGS are ok for TotalView modules])
|
|
AC_MSG_RESULT([$CFLAGS_WITHOUT_OPTFLAGS])
|
|
AC_MSG_CHECKING([extra CFLAGS for TotalView modules])
|
|
AC_MSG_RESULT([$TOTALVIEW_DEBUG_FLAGS])
|
|
|
|
AC_SUBST(CFLAGS_WITHOUT_OPTFLAGS)
|
|
AC_SUBST(TOTALVIEW_DEBUG_FLAGS)
|
|
|
|
#
|
|
# Adding WRAPPER_* flags so that extra flags needed for wrappper compilers
|
|
#
|
|
# WRAPPER_EXTRA_CFLAGS
|
|
#
|
|
AC_MSG_CHECKING([for mpicc CFLAGS])
|
|
OMPI_UNIQ(WRAPPER_EXTRA_CFLAGS)
|
|
AC_SUBST(WRAPPER_EXTRA_CFLAGS)
|
|
AC_DEFINE_UNQUOTED(WRAPPER_EXTRA_CFLAGS, "$WRAPPER_EXTRA_CFLAGS",
|
|
[Additional CFLAGS to pass through the wrapper compilers])
|
|
AC_MSG_RESULT([$WRAPPER_EXTRA_CFLAGS])
|
|
|
|
#
|
|
# WRAPPER_EXTRA_CXXFLAGS
|
|
#
|
|
AC_MSG_CHECKING([for mpiCC CXXFLAGS])
|
|
OMPI_UNIQ(WRAPPER_EXTRA_CXXFLAGS)
|
|
AC_SUBST(WRAPPER_EXTRA_CXXFLAGS)
|
|
AC_DEFINE_UNQUOTED(WRAPPER_EXTRA_CXXFLAGS, "$WRAPPER_EXTRA_CXXFLAGS",
|
|
[Additional CXXFLAGS to pass through the wrapper compilers])
|
|
AC_MSG_RESULT([$WRAPPER_EXTRA_CXXFLAGS])
|
|
|
|
#
|
|
# WRAPPER_EXTRA_FFLAGS
|
|
#
|
|
AC_MSG_CHECKING([for mpif77/mpif90 FFLAGS])
|
|
OMPI_UNIQ(WRAPPER_EXTRA_FFLAGS)
|
|
AC_SUBST(WRAPPER_EXTRA_FFLAGS)
|
|
AC_DEFINE_UNQUOTED(WRAPPER_EXTRA_FFLAGS, "$WRAPPER_EXTRA_FFLAGS",
|
|
[Additional FFLAGS to pass through the wrapper compilers])
|
|
AC_MSG_RESULT([$WRAPPER_EXTRA_FFLAGS])
|
|
|
|
#
|
|
# WRAPPER_EXTRA_FCFLAGS
|
|
#
|
|
AC_MSG_CHECKING([for mpif77/mpif90 FCFLAGS])
|
|
OMPI_UNIQ(WRAPPER_EXTRA_FCFLAGS)
|
|
AC_SUBST(WRAPPER_EXTRA_FCFLAGS)
|
|
AC_DEFINE_UNQUOTED(WRAPPER_EXTRA_FCFLAGS, "$WRAPPER_EXTRA_FCFLAGS",
|
|
[Additional FCFLAGS to pass through the wrapper compilers])
|
|
AC_MSG_RESULT([$WRAPPER_EXTRA_FCFLAGS])
|
|
|
|
#
|
|
# WRAPPER_EXTRA_LDFLAGS
|
|
#
|
|
AC_MSG_CHECKING([for wrapper compiler LDFLAGS])
|
|
OMPI_UNIQ(WRAPPER_EXTRA_LDFLAGS)
|
|
AC_SUBST(WRAPPER_EXTRA_LDFLAGS)
|
|
AC_DEFINE_UNQUOTED(WRAPPER_EXTRA_LDFLAGS, "$WRAPPER_EXTRA_LDFLAGS",
|
|
[Additional LDFLAGS to pass through the wrapper compilers])
|
|
AC_MSG_RESULT([$WRAPPER_EXTRA_LDFLAGS])
|
|
|
|
#
|
|
# WRAPPER_EXTRA_LIBS
|
|
#
|
|
AC_MSG_CHECKING([for wrapper compiler LIBS])
|
|
AC_SUBST(WRAPPER_EXTRA_LIBS)
|
|
AC_DEFINE_UNQUOTED(WRAPPER_EXTRA_LIBS, "$WRAPPER_EXTRA_LIBS",
|
|
[Additional LIBS to pass through the wrapper compilers])
|
|
AC_MSG_RESULT([$WRAPPER_EXTRA_LIBS])
|
|
|
|
#
|
|
# Adding LIBMPI_* flags from the components that are necessary to
|
|
# compile with libmpi
|
|
#
|
|
# LIBMPI_EXTRA_LDFLAGS
|
|
#
|
|
AC_MSG_CHECKING([for libmpi additional LDFLAGS])
|
|
OMPI_UNIQ(LIBMPI_EXTRA_LDFLAGS)
|
|
AC_SUBST(LIBMPI_EXTRA_LDFLAGS)
|
|
AC_DEFINE_UNQUOTED(LIBMPI_EXTRA_LDFLAGS, "$LIBMPI_EXTRA_LDFLAGS",
|
|
[Additional LDFLAGS to compile against libmpi])
|
|
AC_MSG_RESULT([$LIBMPI_EXTRA_LDFLAGS])
|
|
|
|
#
|
|
# LIBMPI_EXTRA_LIBS
|
|
#
|
|
AC_MSG_CHECKING([for libmpi additional LIBS])
|
|
AC_SUBST(LIBMPI_EXTRA_LIBS)
|
|
AC_DEFINE_UNQUOTED(LIBMPI_EXTRA_LIBS, "$LIBMPI_EXTRA_LIBS",
|
|
[Additional LIBS to compile against libmpi])
|
|
AC_MSG_RESULT([$LIBMPI_EXTRA_LIBS])
|
|
|
|
#
|
|
# Delayed the substitution of CFLAGS and CXXFLAGS until now because
|
|
# they may have been modified throughout the course of this script.
|
|
#
|
|
|
|
AC_SUBST(CFLAGS)
|
|
AC_SUBST(CPPFLAGS)
|
|
AC_SUBST(CXXFLAGS)
|
|
AC_SUBST(CXXCPPFLAGS)
|
|
AC_SUBST(FFLAGS)
|
|
AC_SUBST(FCFLAGS)
|
|
|
|
|
|
############################################################################
|
|
# Party on
|
|
############################################################################
|
|
|
|
ompi_show_subtitle "Final output"
|
|
|
|
AM_CONFIG_HEADER([include/ompi_config.h include/mpi.h])
|
|
AC_CONFIG_FILES([
|
|
Makefile
|
|
|
|
config/Makefile
|
|
|
|
include/Makefile
|
|
include/mpif.h
|
|
|
|
etc/Makefile
|
|
contrib/Makefile
|
|
|
|
opal/Makefile
|
|
opal/asm/Makefile
|
|
opal/event/Makefile
|
|
opal/event/compat/Makefile
|
|
opal/event/compat/sys/Makefile
|
|
opal/util/Makefile
|
|
opal/mca/base/Makefile
|
|
|
|
orte/Makefile
|
|
|
|
orte/tools/console/Makefile
|
|
orte/tools/orted/Makefile
|
|
orte/tools/orteprobe/Makefile
|
|
orte/tools/orterun/Makefile
|
|
orte/tools/openmpi/Makefile
|
|
|
|
ompi/Makefile
|
|
|
|
ompi/debuggers/Makefile
|
|
|
|
ompi/mpi/Makefile
|
|
ompi/mpi/c/Makefile
|
|
ompi/mpi/c/profile/Makefile
|
|
ompi/mpi/cxx/Makefile
|
|
ompi/mpi/f77/Makefile
|
|
ompi/mpi/f77/profile/Makefile
|
|
ompi/mpi/f90/Makefile
|
|
ompi/mpi/f90/fortran_kinds.sh
|
|
ompi/mpi/f90/fortran_sizes.h
|
|
ompi/mpi/f90/scripts/Makefile
|
|
|
|
ompi/tools/ompi_info/Makefile
|
|
ompi/tools/wrappers/Makefile
|
|
|
|
test/Makefile
|
|
test/asm/Makefile
|
|
test/class/Makefile
|
|
test/dps/Makefile
|
|
test/mca/Makefile
|
|
test/mca/gpr/Makefile
|
|
test/mca/ns/Makefile
|
|
test/mca/oob/Makefile
|
|
test/mca/ras/Makefile
|
|
test/mca/rds/Makefile
|
|
test/mca/rmaps/Makefile
|
|
test/mca/schema/Makefile
|
|
test/memory/Makefile
|
|
test/runtime/Makefile
|
|
test/support/Makefile
|
|
test/threads/Makefile
|
|
test/util/Makefile
|
|
])
|
|
AC_OUTPUT
|