File: ompi_setup_mpi_fortran.m4

package info (click to toggle)
openmpi 1.6.5-9.1%2Bdeb8u1
  • links: PTS, VCS
  • area: main
  • in suites: jessie
  • size: 91,628 kB
  • ctags: 44,305
  • sloc: ansic: 408,966; cpp: 44,454; sh: 27,828; makefile: 10,486; asm: 3,882; python: 1,239; lex: 805; perl: 549; csh: 253; fortran: 232; f90: 126; tcl: 12
file content (253 lines) | stat: -rw-r--r-- 10,650 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
# -*- 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)
])