configure.ac 30.1 KB
Newer Older
1
AC_PREREQ([2.69])
2

Andreas Marek's avatar
Andreas Marek committed
3
AC_INIT([elpa],[2015.02.002], [elpa-library@rzg.mpg.de])
4
AC_SUBST([PACKAGE_VERSION])
5

6
7
8
AC_CONFIG_SRCDIR([src/elpa1.F90])

AM_INIT_AUTOMAKE([foreign -Wall subdir-objects])
9
10
11
12
13
14
15
16
17

# Without this, automake tries to be smart and rebuilt
# the autoconf generated files such as configure, aclocal.m4, etc.,
# in case the timestamps of files such as configure.ac are newer
#
# This only makes trouble for end users with out-of-date autoconf versions
# that cannot produce these files
AM_MAINTAINER_MODE([disable])

18
19
20
21
AC_CONFIG_MACRO_DIR([m4])
AC_CONFIG_HEADERS([config.h])
AM_SILENT_RULES([yes])

22
23
rm -rf config.h config-f90.h

24
25
26
27
28
29
30
31
32
33
34
35
36
# Set the libtool library version, see LIBRARY_INTERFACE
#
# See http://www.gnu.org/software/libtool/manual/html_node/Updating-version-info.html
#
# [c:r:a]
#
# c: The currently implement interface
# r: The revision number of the current interface, that is the number
#    of released source-code changes for the current interface
# a: The "age" is the number of interfaces prior to c that are also supported
#    by the current interface, as they are ABI compatible (e.g. only new symbols
#    were added by the new interface)
#
Andreas Marek's avatar
Andreas Marek committed
37
AC_SUBST([ELPA_SO_VERSION], [3:0:0])
38
39
#

40

41
42
43
44
45
46
AX_CHECK_GNU_MAKE()
if test x$_cv_gnu_make_command = x ; then
        AC_MSG_ERROR([Need GNU Make])
fi

AC_CHECK_PROG(CPP_FOUND,cpp,yes,no)
47
if test x"${CPP_FOUND}" = xno; then
48
49
50
51
52
53
54
  AC_MSG_ERROR([no cpp found])
fi

# gnu-make fortran module dependencies
m4_include([fdep/fortran_dependencies.m4])
FDEP_F90_GNU_MAKE_DEPS

55
56
57
58
###

AC_MSG_CHECKING(whether --enable-openmp is specified)
AC_ARG_ENABLE([openmp],
59
		AS_HELP_STRING([--enable-openmp],
60
61
62
63
64
65
66
67
68
			       [use OpenMP threading, default no.]),
	      [],
	      [enable_openmp=no])
AC_MSG_RESULT([${enable_openmp}])
AM_CONDITIONAL([WITH_OPENMP],[test x"$enable_openmp" = x"yes"])
if test x"${enable_openmp}" = x"yes"; then
	AC_DEFINE([WITH_OPENMP], [1], [use OpenMP threading])
fi

Andreas Marek's avatar
Andreas Marek committed
69
70
71
72
73
74
75
dnl check whether mpi compilers are available;
dnl if not abort since it is mandatory

# C
AC_LANG([C])
m4_include([m4/ax_prog_cc_mpi.m4])
AX_PROG_CC_MPI([true],[],[AC_MSG_ERROR([no MPI C wrapper found])])
76
77
78
79
80
81
82
if test x"${enable_openmp}" = x"yes"; then
	AX_ELPA_OPENMP
	if test "$ac_cv_prog_cc_openmp" = unsupported; then
	  AC_MSG_ERROR([Could not compile a C program with OpenMP, adjust CFLAGS])
	fi
	CFLAGS="$OPENMP_CFLAGS $CFLAGS"
fi
83

84
AC_PROG_INSTALL
85
86
AM_PROG_AR
AM_PROG_AS
Andreas Marek's avatar
Andreas Marek committed
87
88
89
90
91
92
93


# Fortran
AC_LANG([Fortran])
m4_include([m4/ax_prog_fc_mpi.m4])
AX_PROG_FC_MPI([],[],[AC_MSG_ERROR([no MPI Fortran wrapper found])])

94
95
96
97
98
99
100
101
102
if test x"${enable_openmp}" = x"yes"; then
	AX_ELPA_OPENMP
	if test "$ac_cv_prog_fc_openmp" = unsupported; then
	  AC_MSG_ERROR([Could not compile a Fortran program with OpenMP, adjust FCFLAGS])
	fi
	FCFLAGS="$OPENMP_FCFLAGS $FCFLAGS"
fi


Andreas Marek's avatar
Andreas Marek committed
103
104
105

# C++
AC_LANG([C++])
106
AC_PROG_CXX
107

108
109
110
111
112
113
114
if test x"${enable_openmp}" = x"yes"; then
	AX_ELPA_OPENMP
	if test "$ac_cv_prog_cxx_openmp" = unsupported; then
	  AC_MSG_ERROR([Could not compile a C++ program with OpenMP, adjust CXXFLAGS])
	fi
	CXXFLAGS="$OPENMP_CXXFLAGS $CXXFLAGS"
fi
Andreas Marek's avatar
Andreas Marek committed
115
116
117



Andreas Marek's avatar
Andreas Marek committed
118
dnl variables needed for the tests
119
N="0"
Andreas Marek's avatar
Andreas Marek committed
120
121
122
123
124
125
126
127
128

dnl these test will cause an abort of configure if not
dnl successful. However, if MKL is found then the blas, blacs,
dnl lapack, and scalapack test can fail and vice versa
have_blas=no
have_blacs=no
have_mkl=no
have_lapack=no
have_scalapack=no
129

Andreas Marek's avatar
Andreas Marek committed
130
131
132
133
134
135
dnl these tests will decide which kernels can be build
dnl the usual case is all except the BlueGene (bg) kernels

can_compile_sse=no
can_compile_bgp=no
can_compile_bqq=no
136
can_compile_gpu=no
Andreas Marek's avatar
Andreas Marek committed
137
138
139
140

fortran_can_check_environment=no
use_specific_real_kernel=no
use_specific_complex_kernel=no
141
build_with_gpu_support_only=no
Andreas Marek's avatar
Andreas Marek committed
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

install_real_generic=yes
install_real_generic_simple=yes
install_real_sse=no
install_real_bgp=no
install_real_bgq=no
install_real_avx_block2=no
install_real_avx_block4=no
install_real_avx_block6=no

install_complex_generic=yes
install_complex_generic_simple=yes
install_complex_sse=no
install_complex_bgp=no
install_complex_bgq=no
install_complex_avx_block1=no
install_complex_avx_block2=no
159

160
161
install_gpu=no

Andreas Marek's avatar
Andreas Marek committed
162
163
AC_LANG([C])

164
165
166
167
168
169
170
171
172
dnl build with ftimings support
AC_MSG_CHECKING(whether ELPA should be build with ftimings support)
AC_ARG_WITH([ftimings],
		AS_HELP_STRING([--with-ftimings],
			       [detailed timings, default no.]),
	      [with_ftimings=yes],
	      [with_ftimings=no])
AC_MSG_RESULT([${with_ftimings}])

173
174
175
176
177
178
179
180
181
182
183
184
185
186
dnl build with the possibilty to redirect stdout and stderr
dnl per MPI task in a file
AC_MSG_CHECKING(whether stdout/stderr file redirect should be enabled)
AC_ARG_WITH([redirect],
		AS_HELP_STRING([--with-redirect],
			       [for test programs, allow redirection of stdout/stderr per MPI taks in a file (useful for ftimings), default no.]),
	      [with_redirect=yes],
	      [with_redirect=no])
AC_MSG_RESULT([${with_redirect}])

if test x"${with_redirect}" = x"yes"; then
  AC_DEFINE([HAVE_REDIRECT], [1], [Redirect stdout and stderr of test programs per MPI tasks to a file])
fi
AM_CONDITIONAL([HAVE_REDIRECT],[test x"$with_redirect" = x"yes"])
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208

if test x"${with_ftimings}" = x"yes"; then
  AC_DEFINE([HAVE_DETAILED_TIMINGS], [1], [Enable more timings])
  AC_ARG_ENABLE([papi],
	[AS_HELP_STRING([--disable-papi],[Do not use PAPI to also measure flop count, autodetected by default])],
	[want_papi=$enableval],[want_papi="auto"])
  papi_found=unknown
  if test x"$want_papi" != x"no" ; then
    AC_CHECK_LIB([papi],[PAPI_library_init],[papi_found="yes"],[papi_found="no"])
    if test x"$want_papi" = x"yes" ; then
      if test x"$papi_found" = x"no" ; then
        AC_MSG_ERROR(["Could not find usable PAPI installation, please adjust CFLAGS, LDFLAGS"])
      fi
    fi
  fi
  if test x"$papi_found" = x"yes"; then
    AC_DEFINE([HAVE_LIBPAPI], [1], [Use the PAPI library])
    LIBS="-lpapi $LIBS"
  fi
fi
AM_CONDITIONAL([HAVE_DETAILED_TIMINGS],[test x"$with_ftimings" = x"yes"])

Andreas Marek's avatar
Andreas Marek committed
209
210
AC_MSG_CHECKING(whether SSE assembler kernel can be compiled)

211
212
$CC -c $srcdir/src/elpa2_kernels/elpa2_kernels_asm_x86_64.s -o test.o 2>/dev/null
if test "$?" == 0; then
Andreas Marek's avatar
Andreas Marek committed
213
214
215
  can_compile_sse=yes
  install_real_sse=yes
  install_complex_sse=yes
216
else
Andreas Marek's avatar
Andreas Marek committed
217
218
219
  can_compile_sse=no
  install_real_sse=no
  install_complex_sse=no
220
221
fi
rm -f ./test.o
Andreas Marek's avatar
Andreas Marek committed
222
AC_MSG_RESULT([${can_compile_sse}])
223

Andreas Marek's avatar
Andreas Marek committed
224
dnl check whether one can compile with avx - gcc intrinsics
225

226
dnl first pass: try with specified CFLAGS and CXXFLAGS
227
AC_MSG_CHECKING([whether we can compile AVX intrinsics in C])
228
229
AC_COMPILE_IFELSE([AC_LANG_SOURCE([
 #include <x86intrin.h>
230
 int main(int argc, char **argv){
231
232
 double* q;
 __m256d a1_1 = _mm256_load_pd(q);
233
 return 0;
234
235
236
237
238
 }
 ])],
 [can_compile_avx=yes],
 [can_compile_avx=no]
)
Andreas Marek's avatar
Andreas Marek committed
239
AC_MSG_RESULT([${can_compile_avx}])
240
241
242
if test "${can_compile_avx}" = "yes" ; then
  AC_MSG_CHECKING([whether we can compile AVX intrinsics in C++])
  AC_LANG_PUSH([C++])
243
244
  AC_COMPILE_IFELSE([AC_LANG_SOURCE([
   #include <x86intrin.h>
245
   int main(int argc, char **argv){
246
247
   double* q;
   __m256d a1_1 = _mm256_load_pd(q);
248
   return 0;
249
250
251
252
253
   }
   ])],
   [can_compile_avx=yes],
   [can_compile_avx=no]
  )
254
  AC_LANG_POP([C++])
255
  AC_MSG_RESULT([${can_compile_avx}])
256
257
  if test "${can_compile_avx}" = "no" ; then
    AC_MSG_WARN([Cannot compile C++ with AVX: disabling AVX alltogether])
258
259
260
  fi
fi

261
if test "${can_compile_avx}" = "yes" ; then
Andreas Marek's avatar
Andreas Marek committed
262
263
264
265
266
267
  install_real_avx_block2=yes
  install_real_avx_block4=yes
  install_real_avx_block6=yes

  install_complex_avx_block1=yes
  install_complex_avx_block2=yes
268
269
270
271
272
273
274
275
276
fi

dnl set the AVX optimization flags if this option is specified
AC_MSG_CHECKING(whether AVX optimization flags should be set automatically)
AC_ARG_WITH([avx-optimization],
		AS_HELP_STRING([--with-avx-optimization],
			       [use AVX optimization, default no.]),
	      [with_avx_optimization=yes],
	      [with_avx_optimization=no])
Andreas Marek's avatar
Andreas Marek committed
277
AC_MSG_RESULT([${with_avx_optimization}])
278
if test x"${with_avx_optimization}" = x"yes"; then
Andreas Marek's avatar
Andreas Marek committed
279
280
281
 CFLAGS="$CFLAGS -funsafe-loop-optimizations -funsafe-math-optimizations -ftree-vect-loop-version -ftree-vectorize"
 CXXFLAGS="$CXXFLAGS -funsafe-loop-optimizations -funsafe-math-optimizations -ftree-vect-loop-version -ftree-vectorize"
fi
282

283
AC_LANG([Fortran])
284
285
286
AC_FC_FREEFORM
AC_FC_MODULE_FLAG
AC_FC_MODULE_OUTPUT_FLAG
287
AC_FC_LIBRARY_LDFLAGS
288
289
290
291

save_FCFLAGS=$FCFLAGS
save_LDFLAGS=$LDFLAGS

292
293
294
AC_ARG_VAR([SCALAPACK_LDFLAGS],[Extra LDFLAGS necessary to link a program with Scalapack])
AC_ARG_VAR([SCALAPACK_FCFLAGS],[Extra FCFLAGS necessary to compile a Fortran program with Scalapack])

295
296
FCFLAGS="$FCFLAGS $SCALAPACK_FCFLAGS"
LDFLAGS="$LDFLAGS $SCALAPACK_LDFLAGS"
297

298
dnl check whether fortran error_unit is defined
299
AC_MSG_CHECKING([whether Fortran module iso_fortran_env is available])
300
AC_COMPILE_IFELSE([AC_LANG_SOURCE([
301
302
303
304
305
306
307
308
309
310
  program test_error_unit
    use ISO_FORTRAN_ENV, only : error_unit
    implicit none

    write(error_unit,*) "error_unit is defined"
  end program
])],
  [can_use_iso_fortran_env=yes],
  [can_use_iso_fortran_env=no]
)
311
AC_MSG_RESULT([${can_use_iso_fortran_env}])
312

313
314
315
316
dnl check whether one can link with specified MKL (desired method)
AC_MSG_CHECKING([whether we can compile a Fortran program using MKL])


317
AC_COMPILE_IFELSE([AC_LANG_SOURCE([
318
  program test_mkl
319
    use mkl_service
320
321
322
323
324
325
326
327
328
329
330
331
    character*198 :: string
    call mkl_get_version_string(string)
    write(*,'(a)') string
  end program
])],
  [can_compile_with_mkl=yes],
  [can_compile_with_mkl=no]
)
AC_MSG_RESULT([${can_compile_with_mkl}])

if test x"$can_compile_with_mkl" = x"yes" ; then
  AC_MSG_CHECKING([whether we can link a Fortran program with MKL])
332
  AC_LINK_IFELSE([AC_LANG_SOURCE([
333
    program test_mkl
334
      use mkl_service
335
336
337
338
339
      character*198 :: string
      call mkl_get_version_string(string)
      write(*,'(a)') string
    end program
  ])],
Andreas Marek's avatar
Andreas Marek committed
340
341
    [have_mkl=yes],
    [have_mkl=no]
342
  )
Andreas Marek's avatar
Andreas Marek committed
343
  AC_MSG_RESULT([${have_mkl}])
344
345
346
fi

dnl if not mkl, check all the necessary individually
347
if test x"${have_mkl}" = x"yes" ; then
348
349
350
351
  WITH_MKL=1
else

  dnl first check blas
Andreas Marek's avatar
Andreas Marek committed
352
353
354
  AC_SEARCH_LIBS([dgemm],[blas],[have_blas=yes],[have_blas=no])
  AC_MSG_CHECKING([whether we can link a program with a blas lib])
  AC_MSG_RESULT([${have_blas}])
355

356
  if test x"${have_blas}" = x"no" ; then
357
    AC_MSG_ERROR([could not link with blas: specify path])
358
  fi
359
  dnl now lapack
Andreas Marek's avatar
Andreas Marek committed
360
361
362
  AC_SEARCH_LIBS([dlarrv],[lapack],[have_lapack=yes],[have_lapack=no])
  AC_MSG_CHECKING([whether we can link a program with a lapack lib])
  AC_MSG_RESULT([${have_lapack}])
363

364
  if test x"${have_lapack}" = x"no" ; then
365
    AC_MSG_ERROR([could not link with lapack: specify path])
366
  fi
Andreas Marek's avatar
Andreas Marek committed
367

368
369
  dnl test whether scalapack already contains blacs
  scalapack_libs="mpiscalapack scalapack"
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
  old_LIBS="$LIBS"
  for lib in ${scalapack_libs}; do
    LIBS="-l${lib} ${old_LIBS}"
    AC_MSG_CHECKING([whether -l${lib} already contains a BLACS implementation])
    AC_LINK_IFELSE([AC_LANG_FUNC_LINK_TRY([blacs_gridinit])],[blacs_in_scalapack=yes],[blacs_in_scalapack=no])
    AC_MSG_RESULT([${blacs_in_scalapack}])
    if test x"${blacs_in_scalapack}" = x"yes"; then
      break
    fi
  done

  if test x"${blacs_in_scalapack}" = x"no"; then
    LIBS="${old_LIBS}"

    dnl Test for stand-alone blacs
385
386
    AC_SEARCH_LIBS([bi_f77_init],[mpiblacsF77init],[],[],[-lmpiblacs])
    AC_SEARCH_LIBS([blacs_gridinit],[mpiblacs blacs],[have_blacs=yes],[have_blacs=no])
Andreas Marek's avatar
Andreas Marek committed
387

388
389
390
    if test x"${have_blacs}" = x"no"; then
      AC_MSG_ERROR([No usable BLACS found. If installed in a non-standard place, please specify suitable LDFLAGS and FCFLAGS as arguments to configure])
    fi
Andreas Marek's avatar
Andreas Marek committed
391
  fi
392

393
  AC_SEARCH_LIBS([pdtran],[$scalapack_libs],[have_scalapack=yes],[have_scalapack=no])
Andreas Marek's avatar
Andreas Marek committed
394

395
  if test x"${have_scalapack}" = x"no" ; then
396
    AC_MSG_ERROR([could not link with scalapack: specify path])
397
398
399
400
  fi

  dnl check whether we can link alltogehter
  AC_MSG_CHECKING([whether we can link a Fortran program with all blacs/scalapack])
401
  AC_LINK_IFELSE([AC_LANG_SOURCE([
402
403
    program dgemm_test

404
405
      integer , parameter:: M = 4, N = 3, K = 2
      real :: A(M,K), B(K,N), C(M,N)
406

407
      call dgemm('N','N',M,N,K,1.0,A,M,B,K,0.0,C,M)
408
409
410
411
412
413
414
415

     end program dgemm_test
     ])],
     [can_link_with_blacs_scalapack=yes],
     [can_link_with_blacs_scalapack=no]
   )
   AC_MSG_RESULT([${can_link_with_blacs_scalapack}])

416
   if test x"${can_link_with_blacs_scalapack}" = x"yes" ; then
417
418
     WITH_BLACS=1
   else
419
   AC_MSG_ERROR([We can neither link with MKL or another Scalpack. Please specify SCALAPACK_LDFLAGS and SCALAPACK_FCFLAGS!])
420
421
422
   fi
fi

423
424
425
426
dnl important: reset them again!
FCFLAGS=$save_FCFLAGS
LDFLAGS=$save_LDFLAGS

Andreas Marek's avatar
Andreas Marek committed
427
428
429
430
dnl check for intrinsic fortran function of 2003 standard
AC_MSG_CHECKING([whether we can use the intrinsic Fortran function "get_environment_variable"])


431
AC_COMPILE_IFELSE([AC_LANG_SOURCE([
Andreas Marek's avatar
Andreas Marek committed
432
433
434
435
436
437
438
439
440
441
442
443
  program test_get_environment

    character(len=256) :: homedir
    call get_environment_variable("HOME",homedir)
  end program
])],
  [fortran_can_check_environment=yes],
  [fortran_can_check_environment=no]
)
AC_MSG_RESULT([${fortran_can_check_environment}])


444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491

dnl check whether GPU version is requested

CUDA_INSTALL_PATH="/usr/local/cuda/"
#CUDA_SDK_INSTALL_PATH="/usr/local/NVIDIA_GPU_Computing_SDK"

AC_MSG_CHECKING(whether GPU support is requested)
AC_ARG_ENABLE(gpu-support,[AS_HELP_STRING([--enable-gpu-support],
	                                   [build ELPA2 with GPU-support])],
              want_gpu="yes", want_gpu="no")
AC_MSG_RESULT([${want_gpu}])


AC_ARG_WITH([cuda-path],[AS_HELP_STRING([--with-cuda-path=PATH],[prefix where CUDA is installed @<:@default=auto@:>@])],
            [CUDA_INSTALL_PATH=$withval], [with_cuda=auto])

AC_ARG_WITH([cuda-sdk-path],[AS_HELP_STRING([--with-cuda-sdk-path=PATH],[prefix where CUDA SDK is installed @<:@default=auto@:>@])],
            [CUDA_SDK_INSTALL_PATH=$withval],[with_cuda_sdk=auto])

dnl setup nvcc flags and use them in later tests
if test x"${want_gpu}" = x"yes" ; then
  AC_LANG_PUSH([C])
  CUDA_CFLAGS="$CUDA_CFLAGS -arch sm_35 -I$CUDA_INSTALL_PATH/include"
  LDFLAGS="$LDFLAGS -L$CUDA_INSTALL_PATH/lib64"
  NVCCFLAGS="$NVCCFLAGS $CUDA_CFLAGS $CUDA_LDFLAGS"
  NVCC="nvcc"
  AC_SUBST(NVCC)
  AC_SUBST(NVCCFLAGS)

  dnl check whether nvcc compiler is found
  AC_CHECK_PROG(nvcc_found,nvcc,yes,no)
  if test x"${nvcc_found}" = x"no" ; then
    AC_MSG_ERROR([nvcc not found; try to set the cuda-path or disable GPU support])
  fi

  dnl check whether we find cublas
  AC_SEARCH_LIBS([cublasDgemm],[cublas],[have_cublas=yes],[have_cublas=no])
  if test x"${have_cublas}" = x"no"; then
    AC_MSG_ERROR([Could not link cublas; try to set the cuda-path or disable GPU support])
  fi
  AC_SEARCH_LIBS([cudaMemcpy],[cudart],[have_cudart=yes],[have_cudart=no])
  if test x"${have_cudart}" = x"no"; then
    AC_MSG_ERROR([Could not link cudart; try to set the cuda-path or disable GPU support])
  fi
  AC_LANG_POP([C])
  install_gpu=yes
fi

Andreas Marek's avatar
Andreas Marek committed
492
493
494
495
496
497
498
499
dnl now check which kernels can be compiled

dnl the checks for SSE were already done before
dnl the checks for AVX were already done before

dnl check BGP kernel
AC_MSG_CHECKING([whether we can compile with BGP intrinsics])

500
AC_LINK_IFELSE([AC_LANG_SOURCE([
Andreas Marek's avatar
Andreas Marek committed
501
502
503
  program test_bgp
    complex*16 :: y3,q3,h2
    y3 = fxcpmadd(y3,q3,h2)
504

Andreas Marek's avatar
Andreas Marek committed
505
506
507
508
509
510
511
  end program
])],
  [can_compile_bgp=yes],
  [can_compile_bgp=no]
)
AC_MSG_RESULT([${can_compile_bgp}])

512
if test x"${can_compile_bgp}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
513
514
515
516
517
518
519
  install_real_bgp=yes
  install_complex_bgp=yes
fi

dnl check BGQ kernel
AC_MSG_CHECKING([whether we can compile with BGQ intrinsics])

520
AC_LINK_IFELSE([AC_LANG_SOURCE([
Andreas Marek's avatar
Andreas Marek committed
521
  program test_bgq
Andreas Marek's avatar
Andreas Marek committed
522
    VECTOR(REAL(8))::QPX_x2
Andreas Marek's avatar
Andreas Marek committed
523
524
    real*8 :: hh(10,2))
    QPX_h2 = VEC_SPLATS(hh(2,2))
525

Andreas Marek's avatar
Andreas Marek committed
526
527
528
529
530
531
532
  end program
])],
  [can_compile_bgq=yes],
  [can_compile_bgq=no]
)
AC_MSG_RESULT([${can_compile_bgq}])

533
if test x"${can_compile_bgq}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
534
535
536
537
538
539
  install_real_bgq=yes
  install_complex_bgq=yes
fi


dnl environment variable setting of kernel
540
if test x"${fortran_can_check_environment}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
541
542
543
 AC_DEFINE([HAVE_ENVIRONMENT_CHECKING],[1],[Fortran can querry environment variables])
fi

544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
dnl macro for testing whether the user wanted to compile only with the GPU version

dnl usage: DEFINE_OPTION([gpu-support-only],[gpu-support],[with_gpu_support],[install_gpu])

AC_DEFUN([DEFINE_OPTION_GPU_SUPPORT],[
  AC_ARG_WITH([$1],
               AS_HELP_STRING([--with-$1],
                              [only compile $2 ]),
              [with_option=yes],[with_option=no])

  if test x"${with_option}" = x"yes" ; then
    dnl make sure that all the other kernels are unset
    install_real_generic=no
    install_real_generic_simple=no
    install_real_sse=no
    install_real_bgp=no
    install_real_bgq=no
    install_real_avx_block2=no
    install_real_avx_block4=no
    install_real_avx_block6=no


    install_complex_generic=no
    install_complex_generic_simple=no
    install_complex_sse=no
    install_complex_bgp=no
    install_complex_bgq=no
    install_complex_avx_block1=no
    install_complex_avx_block2=no


    install_gpu=yes

    build_with_gpu_support_only=yes
    use_specific_complex_kernel=yes
    use_specific_real_kernel=yes
    dnl now set the specific kernel
    $3=yes

    AC_MSG_NOTICE([ELPA will be build only with $1])
  fi
])
dnl GPU version
DEFINE_OPTION_GPU_SUPPORT([gpu-version-only],[gpu-support],[install_gpu])
Andreas Marek's avatar
Andreas Marek committed
588

589
590
dnl macro for testing whether the user wanted to compile only with one
dnl specific real kernel
Andreas Marek's avatar
Andreas Marek committed
591

592
dnl usage: DEFINE_OPTION([real-generic-kernel-only],[generic-kernel],[with_real_generic_kernel],[install_real_generic])
Andreas Marek's avatar
Andreas Marek committed
593

594
595
596
597
AC_DEFUN([DEFINE_OPTION_REAL_KERNEL],[
  AC_ARG_WITH([$1],
               AS_HELP_STRING([--with-$1],
                              [only compile $2 for real case]),
598
              [with_option=yes],[with_option=no])
599

600
601
   if test x"${with_option}" = x"yes" ; then
    if test x"${use_specific_real_kernel}" = x"no" ; then
Andreas Marek's avatar
Andreas Marek committed
602
603
604

    dnl make sure that all the other kernels are unset
    install_real_generic=no
605
    install_real_generic_simple=no
Andreas Marek's avatar
Andreas Marek committed
606
    install_real_sse=no
607
    install_real_bgp=no
Andreas Marek's avatar
Andreas Marek committed
608
609
610
611
    install_real_bgq=no
    install_real_avx_block2=no
    install_real_avx_block4=no
    install_real_avx_block6=no
612
613
    install_gpu=no

Andreas Marek's avatar
Andreas Marek committed
614
    use_specific_real_kernel=yes
615
616
617
618
619
620
621
    dnl now set the specific kernel
    $3=yes

    dnl in case of SSE or AVX make sure that we can compile the choosen kernel
    if test x"${install_real_sse}" = x"yes" ; then
     if test x"${can_compile_sse}" = x"no" ; then
       AC_MSG_ERROR([$2 kernel was set, but cannot be compiled!])
622
     fi
623
624
625
626
627
    fi

    if test x"${install_real_avx_block2}" = x"yes" ; then
     if test x"${can_compile_avx}" = x"no" ; then
       AC_MSG_ERROR([$2 kernel was set, but cannot be compiled!])
628
     fi
629
630
631
632
633
    fi

    if test x"${install_real_avx_block4}" = x"yes" ; then
     if test x"${can_compile_avx}" = x"no" ; then
       AC_MSG_ERROR([$2 kernel was set, but cannot be compiled!])
634
     fi
635
636
637
638
639
    fi

    if test x"${install_real_avx_block6}" = x"yes" ; then
     if test x"${can_compile_avx}" = x"no" ; then
       AC_MSG_ERROR([$2 kernel was set, but cannot be compiled!])
640
     fi
641
642
643
644
    fi


    AC_MSG_NOTICE([$1 will be the only compiled kernel for real case])
645
646
647
648
    if test x"${want_gpu}" = x"yes" ; then
      AC_MSG_WARN([At the moment this disables GPU support!])
      AC_MSG_WARN([IF GPU support is wanted do NOT specify a specific real kernel])
    fi
649
650
651
652
653
   else
    AC_MSG_FAILURE([$1 failed; A specific kernel for real case has already been defined before!])
   fi
  fi
])
Andreas Marek's avatar
Andreas Marek committed
654
655


656

657
658
659
660
dnl last check whether user wants to compile only a specific kernel
dnl
dnl real kernels
dnl
Andreas Marek's avatar
Andreas Marek committed
661

662
663
664
665
666
dnl only do this if GPU support only has not been requested
if test x"${build_with_gpu_support_only}" = x"no" ; then

  dnl generic kernel
  DEFINE_OPTION_REAL_KERNEL([real-generic-kernel-only],[generic-kernel],[install_real_generic])
Andreas Marek's avatar
Andreas Marek committed
667

668
669
  dnl generic-simple kernel
  DEFINE_OPTION_REAL_KERNEL([real-generic-simple-kernel-only],[generic-simple-kernel],[install_real_generic_simple])
Andreas Marek's avatar
Andreas Marek committed
670

671
672
  dnl sse kernel
  DEFINE_OPTION_REAL_KERNEL([real-sse-kernel-only],[sse-kernel],[install_real_sse])
Andreas Marek's avatar
Andreas Marek committed
673

674
675
  dnl bgp kernel
  DEFINE_OPTION_REAL_KERNEL([real-bgp-kernel-only],[bgp-kernel],[install_real_bgp])
Andreas Marek's avatar
Andreas Marek committed
676

677
678
  dnl bgq kernel
  DEFINE_OPTION_REAL_KERNEL([real-bgq-kernel-only],[bgq-kernel],[install_real_bgq])
Andreas Marek's avatar
Andreas Marek committed
679

680
681
  dnl real-avx-block2 kernel
  DEFINE_OPTION_REAL_KERNEL([real-avx-block2-kernel-only],[real-avx-block2-kernel],[install_real_avx_block2])
Andreas Marek's avatar
Andreas Marek committed
682

683
684
685
686
687
688
  dnl real-avx-block4 kernel
  DEFINE_OPTION_REAL_KERNEL([real-avx-block4-kernel]-only,[real-avx-block4-kernel],[install_real_avx_block4])

  dnl real-avx-block6 kernel
  DEFINE_OPTION_REAL_KERNEL([real-avx-block6-kernel-only],[real-avx-block6-kernel],[install_real_avx_block6])
fi
Andreas Marek's avatar
Andreas Marek committed
689
690
691
692
693
694

dnl last check whether user wants to compile ony a specific kernel
dnl
dnl complex kernels
dnl

695
696
697
698
AC_DEFUN([DEFINE_OPTION_COMPLEX_KERNEL],[
  AC_ARG_WITH([$1],
                 AS_HELP_STRING([--with-$1],
                                [only compile $2 for complex case]),
699
              [with_option=yes],[with_option=no])
700

701
702
   if test x"${with_option}" = x"yes" ; then
    if test x"${use_specific_complex_kernel}" = x"no" ; then
Andreas Marek's avatar
Andreas Marek committed
703
704

    dnl make sure that all the other kernels are unset
705
    install_complex_generic=no
Andreas Marek's avatar
Andreas Marek committed
706
707
708
709
710
711
712
    install_complex_generic_simple=no
    install_complex_sse=no
    install_complex_bgp=no
    install_complex_bgq=no
    install_complex_avx_block1=no
    install_complex_avx_block2=no

713
    install_gpu=no
Andreas Marek's avatar
Andreas Marek committed
714
    use_specific_complex_kernel=yes
715
716
717
718
719
720
721
    dnl now set the specific kernel
    $3=yes

    dnl in case of SSE or AVX make sure that we can compile the choosen kernel
    if test x"${install_complex_sse}" = x"yes" ; then
     if test x"${can_compile_sse}" = x"no" ; then
       AC_MSG_ERROR([$2 kernel was set, but cannot be compiled!])
722
     fi
723
724
725
726
727
    fi

    if test x"${install_complex_avx_block1}" = x"yes" ; then
     if test x"${can_compile_avx}" = x"no" ; then
       AC_MSG_ERROR([$2 kernel was set, but cannot be compiled!])
728
     fi
729
730
731
732
733
    fi

    if test x"${install_complex_avx_block2}" = x"yes" ; then
     if test x"${can_compile_avx}" = x"no" ; then
       AC_MSG_ERROR([$2 kernel was set, but cannot be compiled!])
734
     fi
735
736
737
    fi

    AC_MSG_NOTICE([$1 will be the only compiled kernel for real case])
738
739
740
741
    if test x"${want_gpu}" = x"yes" ; then
      AC_MSG_WARN([At the moment this disables GPU support!])
      AC_MSG_WARN([IF GPU support is wanted do NOT specify a specific complex kernel])
    fi
742
743
744
745
746
   else
    AC_MSG_FAILURE([$1 failed; A specific kernel for real case has already been defined before!])
   fi
  fi
])
Andreas Marek's avatar
Andreas Marek committed
747

748
749
750
if test x"${build_with_gpu_support_only}" = x"no" ; then
  dnl generic kernel
  DEFINE_OPTION_COMPLEX_KERNEL([complex-generic-kernel-only],[generic-kernel],[install_complex_generic])
Andreas Marek's avatar
Andreas Marek committed
751

752
753
  dnl generic-simple kernel
  DEFINE_OPTION_COMPLEX_KERNEL([complex-generic-simple-kernel-only],[generic-simple-kernel],[install_complex_generic_simple])
Andreas Marek's avatar
Andreas Marek committed
754

755
756
  dnl sse kernel
  DEFINE_OPTION_COMPLEX_KERNEL([complex-sse-kernel-only],[sse-kernel],[install_complex_sse])
Andreas Marek's avatar
Andreas Marek committed
757

758
759
  dnl complex-bqp kernel
  DEFINE_OPTION_COMPLEX_KERNEL([complex-bgp-kernel-only],[bgp-kernel],[install_complex_bgp])
Andreas Marek's avatar
Andreas Marek committed
760

761
762
  dnl complex-bqq kernel
  DEFINE_OPTION_COMPLEX_KERNEL([complex-bgq-kernel-only],[bgq-kernel],[install_complex_bgq])
Andreas Marek's avatar
Andreas Marek committed
763

764
765
  dnl complex-avx-block1 kernel
  DEFINE_OPTION_COMPLEX_KERNEL([complex-avx-block1-kernel-only],[complex-avx-block1-kernel],[install_complex_avx_block1])
Andreas Marek's avatar
Andreas Marek committed
766

767
768
769
  dnl complex-avx-block2 kernel
  DEFINE_OPTION_COMPLEX_KERNEL([complex-avx-block2-kernel-only],[complex-avx-block2-kernel],[install_complex_avx_block2])
fi
Andreas Marek's avatar
Andreas Marek committed
770

771
dnl set the conditionals according to the previous tests
772
if test x"${can_use_iso_fortran_env}" = x"yes" ; then
773
774
775
 AC_DEFINE([HAVE_ISO_FORTRAN_ENV],[1],[can use module iso_fortran_env])
fi

776
777
778
779
780
781
782
783
#dnl check whether GPU version is requested
#
#CUDA_INSTALL_PATH="/usr/local/cuda/"
##CUDA_SDK_INSTALL_PATH="/usr/local/NVIDIA_GPU_Computing_SDK"
#
#
#AC_MSG_CHECKING(whether GPU support is requested)
#AC_ARG_ENABLE(gpu-support,[AS_HELP_STRING([--enable-gpu-support],
784
#	                                   [build ELPA2 with GPU-support ( no CPU version available)])],
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
#              want_gpu="yes", want_gpu="no")
##AC_ARG_WITH([GPU-SUPPORT], [AS_HELP_STRING([--with-GPU-SUPPORT],
##	                                   [build ELPA2 with GPU-support ( no CPU version available)])],
##			   [with_gpu=yes],[with_gpu=no])
#AC_MSG_RESULT([${want_gpu}])
#
#
#
#AC_ARG_WITH([cuda-path],[AS_HELP_STRING([--with-cuda-path=PATH],[prefix where CUDA is installed @<:@default=auto@:>@])],
#            [CUDA_INSTALL_PATH=$withval], [with_cuda=auto])
#
#AC_ARG_WITH([cuda-sdk-path],[AS_HELP_STRING([--with-cuda-sdk-path=PATH],[prefix where CUDA SDK is installed @<:@default=auto@:>@])],
#            [CUDA_SDK_INSTALL_PATH=$withval],[with_cuda_sdk=auto])
#
#
##AC_ARG_VAR([SCALAPACK_LDFLAGS],[Extra LDFLAGS necessary to link a program with Scalapack])
##AC_ARG_VAR([SCALAPACK_FCFLAGS],[Extra FCFLAGS necessary to compile a Fortran program with Scalapack])
#
##FCFLAGS="$FCFLAGS $SCALAPACK_FCFLAGS"
##LDFLAGS="$LDFLAGS $SCALAPACK_LDFLAGS"
#
#dnl setup nvcc flags
#if test x"${want_gpu}" = x"yes" ; then
#  AC_LANG_PUSH([C])
#  CUDA_CFLAGS="$CUDA_CFLAGS -arch sm_35 -I$CUDA_INSTALL_PATH/include"
#  LDFLAGS="$LDFLAGS -L$CUDA_INSTALL_PATH/lib64"
#  NVCCFLAGS="$NVCCFLAGS $CUDA_CFLAGS $CUDA_LDFLAGS"
#  NVCC="nvcc"
#  AC_SUBST(NVCC)
#  AC_SUBST(NVCCFLAGS)
#
#  dnl check whether nvcc compiler is found
#  AC_CHECK_PROG(nvcc_found,nvcc,yes,no)
#  if test x"${nvcc_found}" = x"no" ; then
#    AC_MSG_ERROR([nvcc not found])
#  fi
#
#  dnl check whether we find cublas
#  AC_SEARCH_LIBS([cublasDgemm],[cublas],[have_cublas=yes],[have_cublas=no])
#  if test x"${have_cublas}" = x"no"; then
#    AC_MSG_ERROR([Could not link cublas])
#  fi
#  AC_SEARCH_LIBS([cudaMemcpy],[cudart],[have_cudart=yes],[have_cudart=no])
#  if test x"${have_cudart}" = x"no"; then
#    AC_MSG_ERROR([Could not link cudart])
#  fi
#  AC_LANG_POP([C])
#  AC_DEFINE([WITH_GPU_VERSION],[1],[build with GPU support])
#fi
echo $install_gpu
AM_CONDITIONAL([WITH_GPU_VERSION],[test x"$install_gpu" = x"yes"])
if test x"${install_gpu}" = x"yes" ; then
  AC_DEFINE([WITH_GPU_VERSION],[1],[enable GPU support])
838
fi
839

Andreas Marek's avatar
Andreas Marek committed
840
AM_CONDITIONAL([WITH_REAL_GENERIC_KERNEL],[test x"$install_real_generic" = x"yes"])
841
if test x"${install_real_generic}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
842
843
844
845
 AC_DEFINE([WITH_REAL_GENERIC_KERNEL],[1],[can use real generic kernel])
fi

AM_CONDITIONAL([WITH_COMPLEX_GENERIC_KERNEL],[test x"$install_complex_generic" = x"yes"])
846
if test x"${install_complex_generic}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
847
848
849
850
 AC_DEFINE([WITH_COMPLEX_GENERIC_KERNEL],[1],[can use complex generic kernel])
fi

AM_CONDITIONAL([WITH_REAL_GENERIC_SIMPLE_KERNEL],[test x"$install_real_generic_simple" = x"yes"])
851
if test x"${install_real_generic_simple}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
852
853
854
855
 AC_DEFINE([WITH_REAL_GENERIC_SIMPLE_KERNEL],[1],[can use real generic-simple kernel])
fi

AM_CONDITIONAL([WITH_COMPLEX_GENERIC_SIMPLE_KERNEL],[test x"$install_complex_generic_simple" = x"yes"])
856
if test x"${install_complex_generic_simple}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
857
858
859
860
 AC_DEFINE([WITH_COMPLEX_GENERIC_SIMPLE_KERNEL],[1],[can use complex generic-simple kernel])
fi

AM_CONDITIONAL([WITH_REAL_SSE_KERNEL],[test x"$install_real_sse" = x"yes"])
861
if test x"${install_real_sse}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
862
863
864
865
 AC_DEFINE([WITH_REAL_SSE_KERNEL],[1],[can use real SSE kernel])
fi

AM_CONDITIONAL([WITH_COMPLEX_SSE_KERNEL],[test x"$install_complex_sse" = x"yes"])
866
if test x"${install_complex_sse}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
867
868
869
870
 AC_DEFINE([WITH_COMPLEX_SSE_KERNEL],[1],[can use complex SSE kernel])
fi

AM_CONDITIONAL([WITH_REAL_AVX_BLOCK2_KERNEL],[test x"$install_real_avx_block2" = x"yes"])
871
if test x"${install_real_avx_block2}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
872
873
874
875
 AC_DEFINE([WITH_REAL_AVX_BLOCK2_KERNEL],[1],[can use real_avx_block2 kernel])
fi

AM_CONDITIONAL([WITH_REAL_AVX_BLOCK4_KERNEL],[test x"$install_real_avx_block4" = x"yes"])
876
if test x"${install_real_avx_block4}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
877
878
879
880
 AC_DEFINE([WITH_REAL_AVX_BLOCK4_KERNEL],[1],[can use real_avx_block4 kernel])
fi

AM_CONDITIONAL([WITH_REAL_AVX_BLOCK6_KERNEL],[test x"$install_real_avx_block6" = x"yes"])
881
if test x"${install_real_avx_block6}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
882
883
884
885
 AC_DEFINE([WITH_REAL_AVX_BLOCK6_KERNEL],[1],[can use real_avx_block6 kernel])
fi

AM_CONDITIONAL([WITH_COMPLEX_AVX_BLOCK1_KERNEL],[test x"$install_complex_avx_block1" = x"yes"])
886
if test x"${install_complex_avx_block1}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
887
888
889
890
 AC_DEFINE([WITH_COMPLEX_AVX_BLOCK1_KERNEL],[1],[can use complex_avx_block1 kernel])
fi

AM_CONDITIONAL([WITH_COMPLEX_AVX_BLOCK2_KERNEL],[test x"$install_complex_avx_block2" = x"yes"])
891
if test x"${install_complex_avx_block2}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
892
893
894
895
 AC_DEFINE([WITH_COMPLEX_AVX_BLOCK2_KERNEL],[1],[can use complex_avx_block2 kernel])
fi

AM_CONDITIONAL([WITH_REAL_BGP_KERNEL],[test x"$install_real_bgp" = x"yes"])
896
if test x"${install_real_bgp}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
897
898
899
900
 AC_DEFINE([WITH_REAL_BGP_KERNEL],[1],[can use real BGP kernel])
fi

AM_CONDITIONAL([WITH_REAL_BGQ_KERNEL],[test x"$install_real_bgq" = x"yes"])
901
if test x"${install_real_bgq}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
902
903
904
 AC_DEFINE([WITH_REAL_BGQ_KERNEL],[1],[can use real BGQ kernel])
fi

905
906
if test x"${use_specific_complex_kernel}" = x"no" ; then
 AC_DEFINE([WITH_NO_SPECIFIC_COMPLEX_KERNEL],[1],[do not use only one specific complex kernel (set at compile time)])
Andreas Marek's avatar
Andreas Marek committed
907
908
fi

909
910
if test x"${use_specific_real_kernel}" = x"no" ; then
 AC_DEFINE([WITH_NO_SPECIFIC_REAL_KERNEL],[1],[do not use only one specific real kernel (set at compile time)])
Andreas Marek's avatar
Andreas Marek committed
911
912
fi

913
914
915
916
917
918
919
LT_INIT

AC_SUBST([WITH_MKL])
AC_SUBST([WITH_BLACS])
AC_SUBST([with_amd_bulldozer_kernel])
AC_SUBST([FC_MODINC])
AC_SUBST([FC_MODOUT])
920
921
922
AC_SUBST([OPENMP_CFLAGS])
AC_SUBST([OPENMP_FCFLAGS])
AC_SUBST([OPENMP_LDFLAGS])
923
924
#AC_SUBST(OPT_FCFLAGS)

925
rm -rf modules/ .fortran_dependencies/
926
927
928
929
930
931
932
933
934
935
936
mkdir modules

#gl_VISIBILITY
#AH_BOTTOM([#if HAVE_VISIBILITY
#define EXPORTED __attribute__((__visibility__("default")))
#define HIDDEN   __attribute__((__visibility__("hidden")))
#else
#define EXPORTED
#define HIDDEN
#endif])

937
938
939
940
941
942
943
944
945

# Some part of libtool is too smart and tries to parse the output of
#   gfortran -v
# and catches anything that resembles a -l library link specification.
# Unfortunately, recent versions of gfortran emit
#   -l gfortran
# with a space between -l and gfortran. The empty -l is then included
# into "postdeps_FC" and causes linking errors later on.
postdeps_FC=$(echo $postdeps_FC | sed 's/-l //g')
946

947
if test x"${enable_openmp}" = x"yes"; then
948
	SUFFIX="_openmp"
949
else
950
	SUFFIX=""
951
fi
952
953
AC_SUBST([SUFFIX])
AC_SUBST([PKG_CONFIG_FILE],[elpa${SUFFIX}-${PACKAGE_VERSION}.pc])
954

955
956
AC_CONFIG_FILES([
  Makefile
957
  ${PKG_CONFIG_FILE}:elpa.pc.in
958
])
959

960
AC_OUTPUT
961
962
963
964
965
966


if test -e config.h ; then
  grep "^#define" config.h > config-f90.h
else
  echo "Warning! No config.h was generated, check for errors and re-run configure!"
Andreas Marek's avatar
Andreas Marek committed
967
  exit 1
968
fi
Andreas Marek's avatar
Andreas Marek committed
969
970
971
972
973

echo "Generating elpa/elpa_generated.h..."
mkdir -p elpa
grep "^ *!c>" $srcdir/src/elpa_c_interface.F90 | sed 's/^ *!c>//;' > elpa/elpa_generated.h || exit 1

974
975
976
if test "${can_compile_avx}" = "no" ; then
  AC_MSG_WARN([Could not compile AVX instructions])
fi