# -*- shell-script -*- # # Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana # University Research and Technology # Corporation. All rights reserved. # Copyright (c) 2004-2005 The University of Tennessee and The University # of Tennessee Research Foundation. 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 OMPI_SETUP_WRAPPER_INIT ############################################################################ # 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 # 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 )]) 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_PUSH(C++) AC_CHECK_SIZEOF(bool) # check for type alignments OMPI_C_GET_ALIGNMENT(bool, OMPI_ALIGNMENT_CXX_BOOL) AC_LANG_POP(C++) # 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 # # Check for Fortran compilers value of TRUE and for the correct assumption # on LOGICAL for conversion into what C considers to be a true value # OMPI_F77_GET_VALUE_TRUE OMPI_F77_CHECK_LOGICAL_ARRAY # # 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 # NOTE: Some Fortran compilers actually will return that a type # exists even if it doesn't support it -- the compiler will # automatically convert the unsupported type to a type that it # *does* support. For example, if you try to use INTEGER*16 and # the compiler doesn't support it, it may well automatically # convert it to INTEGER*8 for you (!). So we have to check the # actual size of the type once we determine that the compiler # doesn't error if we try to use it (i.e,. the compiler *might* # support that type). If the size doesn't match the expected # size, then the compiler doesn't really support it. OMPI_F90_CHECK_TYPE(integer(selected_int_kind(2)), OMPI_HAVE_F90_INTEGER1) if test "$OMPI_HAVE_F90_INTEGER1" = "1"; then OMPI_F90_GET_SIZEOF(integer(selected_int_kind(2)), OMPI_SIZEOF_F90_INT1) if test "$OMPI_SIZEOF_F90_INT1" != 1; then AC_MSG_WARN([*** Fortran 90 selected_int_kind(2) does not have expected size!]) AC_MSG_WARN([*** Expected 1, got $OMPI_SIZEOF_F90_INT1]) AC_MSG_WARN([*** Disabling MPI support for Fortran selected_int_kind(2)]) else OMPI_FORTRAN_LKINDS="${OMPI_FORTRAN_LKINDS}1 " OMPI_FORTRAN_IKINDS="${OMPI_FORTRAN_IKINDS}1 " 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 fi OMPI_F90_CHECK_TYPE(integer(selected_int_kind(4)), OMPI_HAVE_F90_INTEGER2) if test "$OMPI_HAVE_F90_INTEGER2" = "1"; then OMPI_F90_GET_SIZEOF(integer(selected_int_kind(4)), OMPI_SIZEOF_F90_INT2) if test "$OMPI_SIZEOF_F90_INT2" != 2; then AC_MSG_WARN([*** Fortran 90 selected_int_kind(4) does not have expected size!]) AC_MSG_WARN([*** Expected 2, got $OMPI_SIZEOF_F90_INT2]) AC_MSG_WARN([*** Disabling MPI support for Fortran selected_int_kind(4)]) else OMPI_FORTRAN_LKINDS="${OMPI_FORTRAN_LKINDS}2 " OMPI_FORTRAN_IKINDS="${OMPI_FORTRAN_IKINDS}2 " 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 fi OMPI_F90_CHECK_TYPE(integer(selected_int_kind(9)), OMPI_HAVE_F90_INTEGER4) if test "$OMPI_HAVE_F90_INTEGER4" = "1"; then OMPI_F90_GET_SIZEOF(integer(selected_int_kind(9)), OMPI_SIZEOF_F90_INT4) if test "$OMPI_SIZEOF_F90_INT4" != 4; then AC_MSG_WARN([*** Fortran 90 selected_int_kind(9) does not have expected size!]) AC_MSG_WARN([*** Expected 4, got $OMPI_SIZEOF_F90_INT4]) AC_MSG_WARN([*** Disabling MPI support for Fortran selected_int_kind(9)]) else OMPI_FORTRAN_LKINDS="${OMPI_FORTRAN_LKINDS}4 " OMPI_FORTRAN_IKINDS="${OMPI_FORTRAN_IKINDS}4 " 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 fi OMPI_F90_CHECK_TYPE(integer(selected_int_kind(18)), OMPI_HAVE_F90_INTEGER8) if test "$OMPI_HAVE_F90_INTEGER8" = "1"; then OMPI_F90_GET_SIZEOF(integer(selected_int_kind(18)), OMPI_SIZEOF_F90_INT8) if test "$OMPI_SIZEOF_F90_INT8" != 8; then AC_MSG_WARN([*** Fortran 90 selected_int_kind(18) does not have expected size!]) AC_MSG_WARN([*** Expected 8, got $OMPI_SIZEOF_F90_INT8]) AC_MSG_WARN([*** Disabling MPI support for Fortran selected_int_kind(18)]) else OMPI_FORTRAN_LKINDS="${OMPI_FORTRAN_LKINDS}8 " OMPI_FORTRAN_IKINDS="${OMPI_FORTRAN_IKINDS}8 " 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 fi OMPI_F90_CHECK_TYPE(integer(selected_int_kind(19)), OMPI_HAVE_F90_INTEGER16) if test "$OMPI_HAVE_F90_INTEGER16" = "1"; then OMPI_F90_GET_SIZEOF(integer(selected_int_kind(19)), OMPI_SIZEOF_F90_INT16) if test "$OMPI_SIZEOF_F90_INT16" != 16; then AC_MSG_WARN([*** Fortran 90 selected_int_kind(19) does not have expected size!]) AC_MSG_WARN([*** Expected 16, got $OMPI_SIZEOF_F90_INT16]) AC_MSG_WARN([*** Disabling MPI support for Fortran selected_int_kind(19)]) else OMPI_FORTRAN_LKINDS="${OMPI_FORTRAN_LKINDS}16 " OMPI_FORTRAN_IKINDS="${OMPI_FORTRAN_IKINDS}16 " 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 fi OMPI_F90_CHECK_TYPE(real(selected_real_kind(6)), OMPI_HAVE_F90_REAL4) if test "$OMPI_HAVE_F90_REAL4" = "1"; then OMPI_F90_GET_SIZEOF(real(selected_real_kind(6)), OMPI_SIZEOF_F90_REAL4) if test "$OMPI_SIZEOF_F90_REAL4" != 4; then AC_MSG_WARN([*** Fortran 90 selected_real_kind(6) does not have expected size!]) AC_MSG_WARN([*** Expected 4, got $OMPI_SIZEOF_F90_REAL4]) AC_MSG_WARN([*** Disabling MPI support for Fortran selected_real_kind(6)]) else OMPI_HAVE_F90_COMPLEX8=1 OMPI_FORTRAN_RKINDS="${OMPI_FORTRAN_RKINDS}4 " OMPI_FORTRAN_CKINDS="${OMPI_FORTRAN_CKINDS}4 " 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 fi OMPI_F90_CHECK_TYPE(real(selected_real_kind(15)), OMPI_HAVE_F90_REAL8) if test "$OMPI_HAVE_F90_REAL8" = "1"; then OMPI_F90_GET_SIZEOF(real(selected_real_kind(15)), OMPI_SIZEOF_F90_REAL8) if test "$OMPI_SIZEOF_F90_REAL8" != 8; then AC_MSG_WARN([*** Fortran 90 selected_real_kind(15) does not have expected size!]) AC_MSG_WARN([*** Expected 8, got $OMPI_SIZEOF_F90_REAL8]) AC_MSG_WARN([*** Disabling MPI support for Fortran selected_real_kind(15)]) else OMPI_HAVE_F90_COMPLEX16=1 OMPI_FORTRAN_RKINDS="${OMPI_FORTRAN_RKINDS}8 " OMPI_FORTRAN_CKINDS="${OMPI_FORTRAN_CKINDS}8 " 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 fi OMPI_F90_CHECK_TYPE(real(selected_real_kind(31)), OMPI_HAVE_F90_REAL16) if test "$OMPI_HAVE_F90_REAL16" = "1"; then OMPI_F90_GET_SIZEOF(real(selected_real_kind(31)), OMPI_SIZEOF_F90_REAL16) if test "$OMPI_SIZEOF_F90_REAL16" != 16; then AC_MSG_WARN([*** Fortran 90 selected_real_kind(31) does not have expected size!]) AC_MSG_WARN([*** Expected 16, got $OMPI_SIZEOF_F90_REAL16]) AC_MSG_WARN([*** Disabling MPI support for Fortran selected_real_kind(31)]) else OMPI_HAVE_F90_COMPLEX32=1 OMPI_FORTRAN_RKINDS="${OMPI_FORTRAN_RKINDS}16 " OMPI_FORTRAN_CKINDS="${OMPI_FORTRAN_CKINDS}16 " 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 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 # # Substitute everything in # 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 , but it doesn't work (e.g., # have both Portland and GNU installed; using pgcc will find GNU's # , 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 (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 works]) if test "$have_stdbool_h" = "1"; then AC_COMPILE_IFELSE(AC_LANG_PROGRAM([[ AC_INCLUDES_DEFAULT #if HAVE_STDBOOL_H #include #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 )" fi AC_DEFINE_UNQUOTED(OMPI_USE_STDBOOL_H, $OMPI_USE_STDBOOL_H, [Whether to use 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 ]) AC_CHECK_TYPES([struct sockaddr_in], [], [], [AC_INCLUDES_DEFAULT #ifdef HAVE_NETINET_IN_H #include #endif]) # SA_RESTART in signal.h AC_MSG_CHECKING([if SA_RESTART defined in signal.h]) AC_EGREP_CPP(yes, [ #include #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 or not]) AC_MSG_RESULT([$MSG]) # sa_len in struct sockaddr AC_MSG_CHECKING([for sa_len in struct sockaddr]) AC_TRY_COMPILE([#include #include ], [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 or not]) AC_MSG_RESULT([$MSG]) AC_CHECK_MEMBERS([struct dirent.d_type], [], [], [ #include #include ]) AC_CHECK_MEMBERS([siginfo_t.si_fd],,,[#include ]) AC_CHECK_MEMBERS([siginfo_t.si_band],,,[#include ]) # 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 ]) 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 ]) 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_yeild in -lrt, usually in libc OMPI_CHECK_FUNC_LIB([sched_yield], [rt]) # FreeBSD has backtrace in -lexecinfo, usually in libc OMPI_CHECK_FUNC_LIB([backtrace], [execinfo]) # IRIX has dirname in -lgen, usually in libc OMPI_CHECK_FUNC_LIB([dirname], [gen]) # # 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(OMPI_MPI_OFFSET_TYPE, $MPI_OFFSET_TYPE, [Type of MPI_Offset -- has to be defined here and typedef'ed later because mpi.h does not get AC SUBST's]) # # 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 AC_MSG_ERROR([Failed to build GNU libltdl. This usually means that something is incorrectly setup with your environment. There may be useful information in opal/libltdl/config.log. You can also disable GNU libltdl (which will disable dynamic shared object loading) by configuring with --disable-dlopen.]) 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 compiler config ############################################################################ ompi_show_subtitle "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 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) ############################################################################ # final wrapper compiler config ############################################################################ ompi_show_subtitle "Wrapper compiler flags" OMPI_SETUP_WRAPPER_FINAL ############################################################################ # 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