b29b852281
config/ directory. We split them apart a while ago in the hopes that
it would simplify things, but it didn't really (e.g., because there
were still some ompi/opal .m4 files in the top-level config/
directory, resulting in developer confusion where any given m4 macro
was defined).
So this commit consolidates them back into the top-level directory for
simplicity.
There's still (at least) two changes that would be nice to make:
1. Split any generated .m4 file (e.g., autogen-generated .m4 files)
into a separate directory somewhere so that a top-level -Iconfig/
will only get our explicitly defined macros, not the autogen stuff
(e.g., with libevent2019 needing to get the visibility macro, but
NOT all the autogen-generated inclusion of component configure.m4
files).
1. Change configure to be of the form:
{{{
# ...a small amount of preamble/setup...
OPAL_SETUP
m4_ifdef([project_orte], [ORTE_SETUP])
m4_ifdef([project_ompi], [OMPI_SETUP])
# ...a small amount of finishing stuff...
}}}
I doubt we'll ever get anything as clean as that, but that would be
the goal to shoot for.
This commit was SVN r27704.
202 строки
10 KiB
Bash
202 строки
10 KiB
Bash
dnl -*- shell-script -*-
|
|
dnl
|
|
dnl Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
|
|
dnl University Research and Technology
|
|
dnl Corporation. All rights reserved.
|
|
dnl Copyright (c) 2004-2005 The University of Tennessee and The University
|
|
dnl of Tennessee Research Foundation. All rights
|
|
dnl reserved.
|
|
dnl Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
|
|
dnl University of Stuttgart. All rights reserved.
|
|
dnl Copyright (c) 2004-2005 The Regents of the University of California.
|
|
dnl All rights reserved.
|
|
dnl Copyright (c) 2011-2012 Cisco Systems, Inc. All rights reserved.
|
|
dnl $COPYRIGHT$
|
|
dnl
|
|
dnl Additional copyrights may follow
|
|
dnl
|
|
dnl $HEADER$
|
|
dnl
|
|
|
|
|
|
# OMPI_FORTRAN_CHECK(Fortran type, c type required, types to search,
|
|
# expected size, define ompi_fortran_<foo>_t or not))
|
|
#----------------------------------------------------------
|
|
# Check Fortran type, including:
|
|
# - whether compiler supports or not
|
|
# - size of type
|
|
# - equal to expected size
|
|
# - alignment
|
|
# - associated C type
|
|
#
|
|
# types to search is a comma-seperated list of values
|
|
AC_DEFUN([OMPI_FORTRAN_CHECK], [
|
|
OPAL_VAR_SCOPE_PUSH([ofc_have_type ofc_type_size ofc_type_alignment ofc_c_type ofc_expected_size])
|
|
|
|
ofc_expected_size=$4
|
|
ofc_define_type=$5
|
|
ofc_have_type=0
|
|
ofc_type_size=$ac_cv_sizeof_int
|
|
ofc_type_alignment=$ac_cv_sizeof_int
|
|
ofc_c_type=ompi_fortran_bogus_type_t
|
|
ofc_type_kind=0
|
|
|
|
# Only check if we actually want the Fortran bindings / have a
|
|
# Fortran compiler. This allows us to call this macro, even if
|
|
# there is no Fortran compiler. If we have no Fortran compiler,
|
|
# then just set a bunch of defaults.
|
|
if test $OMPI_WANT_FORTRAN_BINDINGS -eq 1; then
|
|
OMPI_FORTRAN_CHECK_TYPE([$1], [ofc_have_type=1], [ofc_have_type=0])
|
|
else
|
|
AC_MSG_CHECKING([if Fortran compiler supports $1])
|
|
AC_MSG_RESULT([skipped])
|
|
fi
|
|
|
|
if test "$ofc_have_type" = "1"; then
|
|
# What is the size of this type?
|
|
|
|
# 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_FORTRAN_GET_SIZEOF([], [$1], [ofc_type_size])
|
|
if test "$ofc_expected_size" != "-1" -a "$ofc_type_size" != "$ofc_expected_size"; then
|
|
AC_MSG_WARN([*** Fortran $1 does not have expected size!])
|
|
AC_MSG_WARN([*** Expected $ofc_expected_size, got $ofc_type_size])
|
|
AC_MSG_WARN([*** Disabling MPI support for Fortran $1])
|
|
ofc_have_type=0
|
|
else
|
|
# Look for a corresponding C type (will abort by itself if the
|
|
# type isn't found and we need it)
|
|
ofc_c_type=
|
|
m4_ifval([$3], [OMPI_FIND_TYPE([$1], [$3], [$2], [$ofc_type_size], [ofc_c_type])
|
|
if test -z "$ofc_c_type" ; then
|
|
ofc_have_type=0
|
|
fi])
|
|
|
|
# Get the alignment of the type
|
|
if test "$ofc_have_type" = "1"; then
|
|
OMPI_FORTRAN_GET_ALIGNMENT([$1], [ofc_type_alignment])
|
|
|
|
# Add it to the relevant list of types found
|
|
if test "$ofc_expected_size" != "-1"; then
|
|
ofc_letter=m4_translit(m4_bpatsubst($1, [^\(.\).+], [[\1]]), [a-z], [A-Z])
|
|
ofc_str="OMPI_FORTRAN_${ofc_letter}KINDS=\"\$OMPI_FORTRAN_${ofc_letter}KINDS $ofc_type_size \""
|
|
eval $ofc_str
|
|
fi
|
|
fi
|
|
|
|
# Get the kind of the type. We do this by looking at the
|
|
# Fortran type's corresponding C type (which we figured
|
|
# out above). Then we look a the official BIND(C) KIND
|
|
# type for that type. The official BIND(C) types were
|
|
# taken from table 15.2 of the Fortran 2008 standard,
|
|
# published on 6 October as ISO/IEC 1539-1:2010 (this is
|
|
# not a free document). A copy of this table is in the
|
|
# file ompi/mpi/fortran/c_to_integer_kind_mapping.pdf.
|
|
|
|
# NOTE: Some of the values of these C_* constants *may be
|
|
# negative* if the compiler doesn't support them. We have
|
|
# already verified that both the Fortran and the C types
|
|
# both exist. However, the compiler may still have -1 for
|
|
# the C_<foo> constants if the C type is not the same
|
|
# format as its corresponding Fortran type (e.g., Absoft's
|
|
# "REAL*16" and "long double" are the same size, but not
|
|
# the same format -- so the compiler is allowed to define
|
|
# C_LONG_DOUBLE to -1).
|
|
|
|
AC_MSG_CHECKING([for corresponding KIND value of $1])
|
|
case "$ofc_c_type" in
|
|
char) ofc_type_kind=C_SIGNED_CHAR ;;
|
|
double) ofc_type_kind=C_DOUBLE ;;
|
|
float) ofc_type_kind=C_FLOAT ;;
|
|
int) ofc_type_kind=C_INT ;;
|
|
int16_t) ofc_type_kind=C_INT16_T ;;
|
|
int32_t) ofc_type_kind=C_INT32_T ;;
|
|
int64_t) ofc_type_kind=C_INT64_T ;;
|
|
int8_t) ofc_type_kind=C_INT8_T ;;
|
|
long) ofc_type_kind=C_LONG ;;
|
|
long*double) ofc_type_kind=C_LONG_DOUBLE ;;
|
|
long*long) ofc_type_kind=C_LONG_LONG ;;
|
|
short) ofc_type_kind=C_SHORT ;;
|
|
float*_Complex) ofc_type_kind=C_FLOAT_COMPLEX ;;
|
|
double*_Complex) ofc_type_kind=C_DOUBLE_COMPLEX ;;
|
|
long*double*_Complex) ofc_type_kind=C_LONG_DOUBLE_COMPLEX ;;
|
|
*)
|
|
# Skip types like "DOUBLE PRECISION"
|
|
;;
|
|
esac
|
|
AS_IF([test "$ofc_type_kind" != ""],
|
|
[AC_MSG_RESULT([$ofc_type_kind])],
|
|
[AC_MSG_RESULT([<skipped>])])
|
|
|
|
# See if the value is -1. If so, then just say we don't
|
|
# have a match. If the compiler doesn't support
|
|
# ISO_C_BINDING, then we'll just fall back to a default
|
|
# kind and hope for the best. :-\
|
|
OMPI_FORTRAN_GET_KIND_VALUE([$ofc_type_kind], 4, [ofc_type_kind_value])
|
|
AS_IF([test $ofc_type_kind_value -le 0],
|
|
[ofc_have_type=0
|
|
AC_MSG_WARN([Compiler $1 and $ofc_c_type mismatch; MPI datatype unsupported])])
|
|
fi
|
|
fi
|
|
|
|
# We always need these defines -- even if we don't have a given
|
|
# type, there are some places in the code where we have to have
|
|
# *something*. Note that the bpatsubst's are the same as used
|
|
# above (see comment above), but we added a translit to make them
|
|
# uppercase.
|
|
|
|
# If we got a pretty name, use that as the basis. If not, use the
|
|
# first part of the provided fortran type (e.g.,
|
|
# "logical(selected_int_kind(2))" -> logical1")
|
|
|
|
# Finally, note that it is necessary to use the Big Long Ugly m4
|
|
# expressions in the AC_DEFINE_UNQUOTEDs. If you don't (e.g., put
|
|
# the result of the BLUm4E in a shell variable and use that in
|
|
# AC_DEFINE_UNQUOTED), autoheader won't put them in the
|
|
# AC_CONFIG_HEADER (or AM_CONFIG_HEADER, in our case).
|
|
AC_DEFINE_UNQUOTED([OMPI_HAVE_FORTRAN_]m4_translit(m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]), [a-z], [A-Z]),
|
|
[$ofc_have_type],
|
|
[Whether we have Fortran $1 or not])
|
|
AC_DEFINE_UNQUOTED([OMPI_SIZEOF_FORTRAN_]m4_translit(m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]), [a-z], [A-Z]),
|
|
[$ofc_type_size],
|
|
[Size of Fortran $1])
|
|
AC_DEFINE_UNQUOTED([OMPI_ALIGNMENT_FORTRAN_]m4_translit(m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]), [a-z], [A-Z]),
|
|
[$ofc_type_alignment],
|
|
[Alignment of Fortran $1])
|
|
AC_DEFINE_UNQUOTED([OMPI_KIND_FORTRAN_]m4_translit(m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]), [a-z], [A-Z]),
|
|
[$ofc_type_kind],
|
|
[Fortrn KIND number for $1])
|
|
if test "$3" != "" -a "$ofc_define_type" = "yes"; then
|
|
AC_DEFINE_UNQUOTED([ompi_fortran_]m4_translit(m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]), [A-Z], [a-z])[_t],
|
|
[$ofc_c_type],
|
|
[C type corresponding to Fortran $1])
|
|
fi
|
|
|
|
# Save some in shell variables for later use (e.g., need
|
|
# OMPI_SIZEOF_FORTRAN_INTEGER in OMPI_FORTRAN_GET_HANDLE_MAX)
|
|
[OMPI_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_])[_C_TYPE=$ofc_c_type]
|
|
[OMPI_KIND_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_])[=$ofc_type_kind]
|
|
[OMPI_HAVE_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_])[=$ofc_have_type]
|
|
[OMPI_SIZEOF_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_])[=$ofc_type_size]
|
|
[OMPI_ALIGNMENT_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_])[=$ofc_type_alignment]
|
|
|
|
# Wow, this is sick. But it works! :-)
|
|
AC_SUBST([OMPI_HAVE_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]))
|
|
AC_SUBST([OMPI_KIND_FORTRAN_]m4_translit(m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]), [a-z], [A-Z]))
|
|
AC_SUBST([OMPI_SIZEOF_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]))
|
|
AC_SUBST([OMPI_SIZEOF_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]))
|
|
AC_SUBST([OMPI_ALIGNMENT_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]))
|
|
|
|
# Clean up
|
|
OPAL_VAR_SCOPE_POP
|
|
])dnl
|