# -*- shell-script -*- # # Copyright (c) 2004-2009 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-2007 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 (c) 2006-2010 Cisco Systems, Inc. All rights reserved. # Copyright (c) 2006-2008 Sun Microsystems, Inc. All rights reserved. # Copyright (c) 2006-2007 Los Alamos National Security, LLC. All rights # reserved. # Copyright (c) 2009 Oak Ridge National Labs. All rights reserved. # $COPYRIGHT$ # # Additional copyrights may follow # # $HEADER$ # AC_DEFUN([OMPI_SETUP_MPI_FORTRAN],[ #----------- # Fortran 77 #----------- OMPI_SETUP_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([CHARACTER], [yes], [char, int32_t, int, int64_t, long long, long], [-1]) OMPI_F77_CHECK([LOGICAL], [yes], [char, int32_t, int, int64_t, long long, long], [-1]) OMPI_F77_CHECK([LOGICAL*1], [yes], [char, int8_t, short, int32_t, int, int64_t, long long, long], [1]) OMPI_F77_CHECK([LOGICAL*2], [yes], [short, int16_t, int32_t, int, int64_t, long long, long], [2]) OMPI_F77_CHECK([LOGICAL*4], [yes], [int32_t, int, int64_t, long long, long], [4]) OMPI_F77_CHECK([LOGICAL*8], [yes], [int, int64_t, long long, long], [8]) OMPI_F77_CHECK([INTEGER], [yes], [int32_t, int, int64_t, long long, long], [-1]) OMPI_F77_CHECK([INTEGER*1], [no], [char, int8_t, short, int, int64_t, long long, long], [1]) OMPI_F77_CHECK([INTEGER*2], [no], [short, int16_t, int32_t, int, int64_t, long long, long], [2]) OMPI_F77_CHECK([INTEGER*4], [no], [int32_t, int, int64_t, long long, long], [4]) OMPI_F77_CHECK([INTEGER*8], [no], [int, int64_t, long long, long], [8]) OMPI_F77_CHECK([INTEGER*16], [no], [int, int64_t, long long, long], [16]) OMPI_F77_CHECK([REAL], [yes], [float, double, long double], [-1]) OMPI_F77_CHECK([REAL*2], [no], [float, double, long double], [2]) OMPI_F77_CHECK([REAL*4], [no], [float, double, long double], [4]) OMPI_F77_CHECK([REAL*8], [no], [float, double, long double], [8]) OMPI_F77_CHECK([REAL*16], [no], [float, double, long double], [16]) # In some compilers, the bit representation of REAL*16 is not the same # as the C counterpart that we found. If this is the case, then we # want to disable reduction support for MPI_REAL16 (per ticket #1603). OMPI_F77_CHECK_REAL16_C_EQUIV OMPI_F77_CHECK([DOUBLE PRECISION], [yes], [float, double, long double], [-1]) OMPI_F77_CHECK([COMPLEX], [yes], [], [-1]) # Double precision complex types are not standard, but many compilers support it. # Code should be wrapped with #ifdef OMPI_HAVE_FORTRAN_DOUBLE_COMPLEX OMPI_F77_CHECK([DOUBLE 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], [no], [], [8]) OMPI_F77_CHECK([COMPLEX*16], [no], [], [16]) OMPI_F77_CHECK([COMPLEX*32], [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 # How big should MPI_STATUS_SIZE be? (i.e., the size of # MPI_STATUS, expressed in units of Fortran INTEGERs). The C # equivalent of MPI_Status contains 4 C ints and a size_t. AC_MSG_CHECKING([for the value of MPI_STATUS_SIZE]) OMPI_FORTRAN_STATUS_SIZE=0 if test $OMPI_WANT_F77_BINDINGS -eq 0; then AC_MSG_RESULT([skipped (no Fortran bindings)]) else bytes=`expr 4 \* $ac_cv_sizeof_int + $ac_cv_sizeof_size_t` num_integers=`expr $bytes / $OMPI_SIZEOF_FORTRAN_INTEGER` sanity=`expr $num_integers \* $OMPI_SIZEOF_FORTRAN_INTEGER` AS_IF([test "$sanity" != "$bytes"], [AC_MSG_RESULT([unknown!]) AC_MSG_WARN([WARNING: Size of C int: $ac_cv_sizeof_int]) AC_MSG_WARN([WARNING: Size of C size_t: $ac_cv_sizeof_size_t]) AC_MSG_WARN([WARNING: Size of Fortran INTEGER: $OMPI_SIZEOF_FORTRAN_INTEGER]) AC_MSG_WARN([Could not make this work out evenly...!]) AC_MSG_ERROR([Cannot continue])]) OMPI_FORTRAN_STATUS_SIZE=$num_integers AC_MSG_RESULT([$OMPI_FORTRAN_STATUS_SIZE Fortran INTEGERs]) fi AC_SUBST(OMPI_FORTRAN_STATUS_SIZE) # # 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 #----------- OMPI_SETUP_F90 # Look for the fortran module compiler flag OMPI_F90_FIND_MODULE_INCLUDE_FLAG # Look for all the types OMPI_F90_IKINDS="" OMPI_F90_RKINDS="" OMPI_F90_CKINDS="" OMPI_F90_CHECK([CHARACTER]) # LOGICAL and friends OMPI_F90_CHECK([LOGICAL]) OMPI_F90_CHECK([LOGICAL*1], [1]) OMPI_F90_CHECK([LOGICAL*2], [2]) OMPI_F90_CHECK([LOGICAL*4], [4]) OMPI_F90_CHECK([LOGICAL*8], [8]) # INTEGER and friends OMPI_F90_CHECK([INTEGER]) OMPI_F90_CHECK([INTEGER*1], [1]) OMPI_F90_CHECK([INTEGER*2], [2]) OMPI_F90_CHECK([INTEGER*4], [4]) OMPI_F90_CHECK([INTEGER*8], [8]) OMPI_F90_CHECK([INTEGER*16], [16]) # REAL, DOUBLE PRECISION, REAL*4, *8, *16 OMPI_F90_CHECK([REAL]) OMPI_F90_CHECK([REAL*2], [2]) OMPI_F90_CHECK([REAL*4], [4]) OMPI_F90_CHECK([REAL*8], [8]) OMPI_F90_CHECK([REAL*16], [16]) OMPI_F90_CHECK([DOUBLE PRECISION]) # COMPLEX, DOUBLE COMPLEX, COMPLEX*8, *16, *32 OMPI_F90_CHECK([COMPLEX]) OMPI_F90_CHECK([COMPLEX*8], [8]) OMPI_F90_CHECK([COMPLEX*16], [16]) OMPI_F90_CHECK([COMPLEX*32], [32]) OMPI_F90_CHECK([DOUBLE COMPLEX]) AC_SUBST(OMPI_F90_IKINDS) AC_SUBST(OMPI_F90_RKINDS) AC_SUBST(OMPI_F90_CKINDS) # get kind value for Fortran MPI_INTEGER_KIND (corresponding to # whatever is the same size as a F77 INTEGER -- for the # most-likely-will-never-occur case where F77 INTEGER is smaller than # an F90 INTEGER; see MPI-2 4.12.6.5 if test "$OMPI_SIZEOF_FORTRAN_INTEGER" = "2"; then OMPI_F90_GET_INT_KIND(MPI_INTEGER_KIND, 4, OMPI_MPI_INTEGER_KIND) elif test "$OMPI_SIZEOF_FORTRAN_INTEGER" = "4"; then OMPI_F90_GET_INT_KIND(MPI_INTEGER_KIND, 9, OMPI_MPI_INTEGER_KIND) elif test "$OMPI_SIZEOF_FORTRAN_INTEGER" = "8"; then OMPI_F90_GET_INT_KIND(MPI_INTEGER_KIND, 18, OMPI_MPI_INTEGER_KIND) elif test "$OMPI_SIZEOF_FORTRAN_INTEGER" = "16"; then OMPI_F90_GET_INT_KIND(MPI_INTEGER_KIND, 19, OMPI_MPI_INTEGER_KIND) AC_MSG_ERROR([Cannot support Fortran MPI_INTEGER_KIND!]) fi AC_SUBST(OMPI_MPI_INTEGER_KIND) # get kind value for Fortran MPI_ADDRESS_KIND (corresponding to # whatever is big enough to hold (void*)) if test $ac_cv_sizeof_void_p = 2 ; then OMPI_F90_GET_INT_KIND(MPI_ADDRESS_KIND, 4, OMPI_MPI_ADDRESS_KIND) elif test $ac_cv_sizeof_void_p = 4 ; then OMPI_F90_GET_INT_KIND(MPI_ADDRESS_KIND, 9, OMPI_MPI_ADDRESS_KIND) elif test $ac_cv_sizeof_void_p = 8 ; then OMPI_F90_GET_INT_KIND(MPI_ADDRESS_KIND, 18, OMPI_MPI_ADDRESS_KIND) elif test $ac_cv_sizeof_void_p = 16 ; then OMPI_F90_GET_INT_KIND(MPI_ADDRESS_KIND, 19, OMPI_MPI_ADDRESS_KIND) else AC_MSG_ERROR([Cannot support Fortran MPI_ADDRESS_KIND!]) fi AC_SUBST(OMPI_MPI_ADDRESS_KIND) # get kind value for Fortran MPI_OFFSET_KIND (corresponding to INTEGER*8) OMPI_F90_GET_INT_KIND(MPI_OFFSET_KIND, 18, OMPI_MPI_OFFSET_KIND) AC_SUBST(OMPI_MPI_OFFSET_KIND) ])