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

3 4
# The version is set in elpa.spec, to have a single point of reference
AC_INIT([elpa],m4_esyscmd_s([awk '/^ *Version:/ {print $2;}' elpa.spec]), [elpa-library@mpcdf.mpg.de])
5
AC_SUBST([PACKAGE_VERSION])
6

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

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

# 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])

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

23 24 25 26 27 28 29 30 31 32 33 34 35
# 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)
#
36
AC_SUBST([ELPA_SO_VERSION], [6:0:2])
37 38
#

39

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

Andreas Marek's avatar
Andreas Marek committed
45 46 47 48
#AC_CHECK_PROG(CPP_FOUND,cpp,yes,no)
#if test x"${CPP_FOUND}" = xno; then
#  AC_MSG_ERROR([no cpp found])
#fi
49 50 51 52 53

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

54 55
###

56 57
m4_include([m4/ax_elpa_openmp.m4])

58 59
AC_MSG_CHECKING(whether --enable-openmp is specified)
AC_ARG_ENABLE([openmp],
60
		AS_HELP_STRING([--enable-openmp],
61 62 63 64 65 66 67 68 69
			       [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

70 71
dnl mpi
AC_ARG_WITH(mpi, [AS_HELP_STRING([--with-mpi=[[yes|no]]], [compile with MPI. Default: yes])],,[with_mpi=yes])
72
AM_CONDITIONAL([WITH_MPI],[test x"$with_mpi" = x"yes"])
73 74
if test x"${with_mpi}" = x"yes"; then
       AC_DEFINE([WITH_MPI], [1], [use MPI])
75 76
fi

Andreas Marek's avatar
Andreas Marek committed
77 78
# C
AC_LANG([C])
79 80 81 82 83 84
AX_PROG_CC_MPI([test x"$with_mpi" = x"yes"],[found_mpi_c=yes],[found_mpi_c=no])
if test x"$with_mpi" = x"yes"; then
  if test x"$found_mpi_c" = x"no"; then
    AC_MSG_ERROR([Could not compile an MPI C program])
  fi
fi
85

86
if test x"${enable_openmp}" = x"yes"; then
87 88 89 90 91
  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"
92
fi
93

94
AC_PROG_INSTALL
95 96
AM_PROG_AR
AM_PROG_AS
97
AM_PROG_CC_C_O
Andreas Marek's avatar
Andreas Marek committed
98 99

# Fortran
100 101 102 103 104 105 106 107

dnl check whether single precision is requested
AC_MSG_CHECKING(whether ELPA library should contain also single precision functions)
AC_ARG_ENABLE(single-precision,[AS_HELP_STRING([--enable-single-precision],
	                                   [build with single precision])],
              want_single_precision="yes", want_single_precision="no")
AC_MSG_RESULT([${want_single_precision}])

Andreas Marek's avatar
Andreas Marek committed
108 109
AC_LANG([Fortran])
m4_include([m4/ax_prog_fc_mpi.m4])
110 111 112 113 114 115
AX_PROG_FC_MPI([test x"$with_mpi" = x"yes"],[found_mpi_f=yes],[found_mpi_f=no])
if test x"$with_mpi" = x"yes"; then
  if test x"$found_mpi_f" = x"no"; then
    AC_MSG_ERROR([Could not compile an MPI Fortran program])
  fi
fi
116
if test x"${enable_openmp}" = x"yes"; then
117 118 119 120 121
  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"
122 123
fi

124 125 126 127 128 129 130 131
dnl check which MPI binray invokes a MPI job
if test x"$with_mpi" = x"yes"; then
  AC_CHECK_PROGS([MPI_BINARY], [mpiexec.hydra mpiexec mpirun], [no])
  if test x"$MPI_BINARY" = x"no"; then
    AC_MSG_ERROR([Could not find either of the MPI binaries: mpiexec.hydra, mpiexec, mpirun])
  fi
fi

Andreas Marek's avatar
Andreas Marek committed
132 133 134 135 136 137 138 139 140 141 142
## C++
#AC_LANG([C++])
#AC_PROG_CXX
#
#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
143 144 145



Andreas Marek's avatar
Andreas Marek committed
146 147
dnl variables needed for the tests

Andreas Marek's avatar
Andreas Marek committed
148 149 150 151 152 153 154 155
dnl do NOT remove any variables here, until
dnl 1. you know 100% what you are doing
dnl 2. you tested ALL configure functionality afterwards
dnl Otherwise, you most likely break some functionality

dnl as default always define the generic kernels to be build
dnl this is only unset if gpu_support_only is defined, or
dnl other specific real/complex kernels are wanted
Andreas Marek's avatar
Andreas Marek committed
156 157 158 159 160 161

install_real_generic=yes
install_real_generic_simple=yes

install_complex_generic=yes
install_complex_generic_simple=yes
162

163 164 165
#want_avx=yes
#want_avx2=yes
#want_sse=yes
166
#want_avx512=yes
167

Andreas Marek's avatar
Andreas Marek committed
168 169
AC_LANG([C])

170 171 172
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)
173 174 175 176 177 178 179 180 181
AC_ARG_ENABLE([redirect],
		AS_HELP_STRING([--enable-redirect],
			       [for test programs, allow redirection of stdout/stderr per MPI taks in a file (useful for timing), default no.]),
	      [],
	      [enable_redirect=no])
AC_MSG_RESULT([${enable_redirect}])

dnl redirect
if test x"${enable_redirect}" = x"yes"; then
182 183
  AC_DEFINE([HAVE_REDIRECT], [1], [Redirect stdout and stderr of test programs per MPI tasks to a file])
fi
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
AM_CONDITIONAL([HAVE_REDIRECT],[test x"$enable_redirect" = x"yes"])

dnl build with ftimings support
AC_MSG_CHECKING(whether ELPA should be build with more detailed timing support)
AC_ARG_ENABLE([timing],
		AS_HELP_STRING([--enable-timing],
			       [more detailed timing, default no.]),
	      [],
	      [enable_timings=no])
AC_MSG_RESULT([${enable_timings}])

if test x"${enable_timings}" = x"yes"; then
  AC_DEFINE([HAVE_DETAILED_TIMINGS], [1], [Enable more timing])
fi
AM_CONDITIONAL([HAVE_DETAILED_TIMINGS],[test x"$enable_timings" = x"yes"])

dnl PAPI for ftimings
AC_ARG_WITH([papi],
		[AS_HELP_STRING([--with-papi],[Use PAPI to also measure flop count in the detailed timing (--enable-timing), disabled by default])],
		[],
		[with_papi="no"])
if test x"${enable_timings}" = x"yes"; then
  if test x"$with_papi" = x"yes" ; then
    AC_SEARCH_LIBS([PAPI_library_init],[papi],
                  [papi_found=yes],[papi_found=no])
    if test x"$papi_found" = x"no" ; then
      AC_MSG_ERROR(["Could not find usable PAPI installation, please install or adjust CFLAGS, LDFLAGS"])
211 212 213 214 215
    fi
    AC_DEFINE([HAVE_LIBPAPI], [1], [Use the PAPI library])
  fi
fi

216
AC_MSG_CHECKING(whether double-precision SSE assembly kernel can be compiled)
Andreas Marek's avatar
Andreas Marek committed
217

218
$CC -c $srcdir/src/elpa2_kernels/elpa2_kernels_asm_x86_64_double_precision.s -o test.o 2>/dev/null
219
if test "$?" == 0; then
220 221 222 223 224 225 226 227 228 229 230 231
  can_compile_sse_assembly=yes
  install_real_sse_assembly=yes
  install_complex_sse_assembly=yes
else
  can_compile_sse_assembly=no
  install_real_sse_assembly=no
  install_complex_sse_assembly=no
fi

rm -f ./test.o
AC_MSG_RESULT([${can_compile_sse_assembly}])

232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251
if test x"${want_single_precision}" = x"yes" ; then
  AC_MSG_CHECKING(whether single-precision SSE assembly kernel can be compiled)

  $CC -c $srcdir/src/elpa2_kernels/elpa2_kernels_asm_x86_64_single_precision.s -o test.o 2>/dev/null
  if test "$?" == 0; then
    can_compile_sse_assembly=yes
    install_real_sse_assembly=yes
    install_complex_sse_assembly=yes
  else
    can_compile_sse_assembly=no
    install_real_sse_assembly=no
    install_complex_sse_assembly=no
  fi
  rm -f ./test.o
  AC_MSG_RESULT([${can_compile_sse_assembly}])
  if test x"${can_compile_sse_assembly}" = x"no" ; then
    AC_MSG_WARN([Cannot compile single-precision SSE assembly kernel: disabling SSE assembly kernels alltogether])
  fi
fi

252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268
dnl check whether on can compile with sse-gcc intrinsics
AC_MSG_CHECKING(whether we can compile SSE with gcc intrinsics in C)
AC_COMPILE_IFELSE([AC_LANG_SOURCE([
 #include <x86intrin.h>
 int main(int argc, char **argv){
 double* q;
 __m128d h1 = _mm_loaddup_pd(q);
 return 0;
 }
 ])],
 [can_compile_sse_intrinsics=yes],
 [can_compile_sse_intrinsics=no]
)
AC_MSG_RESULT([${can_compile_sse_intrinsics}])

if test "${can_compile_sse_intrinsics}" = "yes"; then
  install_real_sse_intrinsics=yes
269 270 271 272
  install_real_sse_block2=yes
  install_real_sse_block4=yes
  install_real_sse_block6=yes

273
  install_complex_sse_intrinsics=yes
274 275
  install_complex_sse_block1=yes
  install_complex_sse_block2=yes
276
else
277
  install_real_sse_intrinsics=no
278 279 280 281
  install_real_sse_block2=no
  install_real_sse_block4=no
  install_real_sse_block6=no

282
  install_complex_sse_intrinsics=no
283 284
  install_complex_sse_block1=no
  install_complex_sse_block2=no
285
fi
286

Andreas Marek's avatar
Andreas Marek committed
287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313
AC_MSG_CHECKING(whether --enable-avx is specified)
AC_ARG_ENABLE([avx],
		AS_HELP_STRING([--enable-avx],
			       [check whether AVX kernels can be build, default yes]),
	      [check_avx=no],
	      [check_avx=yes])
AC_MSG_RESULT([$check_avx])

if test "${check_avx}" = "yes"; then
  dnl check whether one can compile with avx - gcc intrinsics
  dnl first pass: try with specified CFLAGS and CXXFLAGS
  AC_MSG_CHECKING([whether we can compile AVX gcc intrinsics in C])
  AC_COMPILE_IFELSE([AC_LANG_SOURCE([
   #include <x86intrin.h>
   int main(int argc, char **argv){
   double* q;
   __m256d a1_1 = _mm256_load_pd(q);
   return 0;
   }
   ])],
   [can_compile_avx=yes],
   [can_compile_avx=no]
  )
  AC_MSG_RESULT([${can_compile_avx}])
else
  can_compile_avx=no
fi
314

Andreas Marek's avatar
Andreas Marek committed
315
#if test "${can_compile_avx}" = "yes" ; then
316
#  AC_MSG_CHECKING([whether we can compile AVX gcc intrinsics in C++])
Andreas Marek's avatar
Andreas Marek committed
317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334
#  AC_LANG_PUSH([C++])
#  AC_COMPILE_IFELSE([AC_LANG_SOURCE([
#   #include <x86intrin.h>
#   int main(int argc, char **argv){
#   double* q;
#   __m256d a1_1 = _mm256_load_pd(q);
#   return 0;
#   }
#   ])],
#   [can_compile_avx=yes],
#   [can_compile_avx=no]
#  )
#  AC_LANG_POP([C++])
#  AC_MSG_RESULT([${can_compile_avx}])
#  if test "${can_compile_avx}" = "no" ; then
#    AC_MSG_WARN([Cannot compile C++ with AVX: disabling AVX alltogether])
#  fi
#fi
335

Andreas Marek's avatar
Andreas Marek committed
336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362
AC_MSG_CHECKING(whether --enable-avx2 is specified)
AC_ARG_ENABLE([avx2],
		AS_HELP_STRING([--enable-avx2],
			       [check whether AVX2 kernels can be build, default yes]),
	      [check_avx2=no],
	      [check_avx2=yes])
AC_MSG_RESULT([$check_avx2])

if test "${check_avx2}" = "yes"; then
  AC_MSG_CHECKING([whether we can compile AVX2 gcc intrinsics in C])
  AC_COMPILE_IFELSE([AC_LANG_SOURCE([
   #include <x86intrin.h>
   int main(int argc, char **argv){
   double* q;
   __m256d q1 = _mm256_load_pd(q);
   __m256d y1 = _mm256_fmadd_pd(q1, q1, q1);
   return 0;
   }
   ])],
   [can_compile_avx2=yes],
   [can_compile_avx2=no]
  )
  AC_MSG_RESULT([${can_compile_avx2}])
else
  can_compile_avx2=no
fi

Andreas Marek's avatar
Andreas Marek committed
363
#if test "${can_compile_avx2}" = "yes" ; then
364
#  AC_MSG_CHECKING([whether we can compile AVX2 gcc intrinsics in C++])
Andreas Marek's avatar
Andreas Marek committed
365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383
#  AC_LANG_PUSH([C++])
#  AC_COMPILE_IFELSE([AC_LANG_SOURCE([
#   #include <x86intrin.h>
#   int main(int argc, char **argv){
#   double* q;
#   __m256d q1 = _mm256_load_pd(q);
#   __m256d y1 = _mm256_fmadd_pd(q1, q1, q1);
#   return 0;
#   }
#   ])],
#   [can_compile_avx2=yes],
#   [can_compile_avx2=no]
#  )
#  AC_LANG_POP([C++])
#  AC_MSG_RESULT([${can_compile_avx2}])
#  if test "${can_compile_avx2}" = "no" ; then
#    AC_MSG_WARN([Cannot compile C++ with AVX2!])
#  fi
#fi
384

Andreas Marek's avatar
Andreas Marek committed
385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410
AC_MSG_CHECKING(whether --enable-avx512 is specified)
AC_ARG_ENABLE([avx512],
		AS_HELP_STRING([--enable-avx512],
			       [check whether AVX512 kernels can be build, default yes]),
	      [check_avx512=no],
	      [check_avx512=yes])
AC_MSG_RESULT([$check_avx512])

if test "${check_avx512}" = "yes"; then
  AC_MSG_CHECKING([whether we can compile AVX512 gcc intrinsics in C])
  AC_COMPILE_IFELSE([AC_LANG_SOURCE([
   #include <x86intrin.h>
   int main(int argc, char **argv){
   double* q;
   __m512d q1 = _mm512_load_pd(q);
   __m512d y1 = _mm512_fmadd_pd(q1, q1, q1);
   return 0;
   }
   ])],
   [can_compile_avx512=yes],
   [can_compile_avx512=no]
  )
  AC_MSG_RESULT([${can_compile_avx512}])
else
  can_compile_avx512=no
fi
411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433

#if test "${can_compile_avx512}" = "yes" ; then
#  AC_MSG_CHECKING([whether we can compile AVX512 gcc intrinsics in C++])
#  AC_LANG_PUSH([C++])
#  AC_COMPILE_IFELSE([AC_LANG_SOURCE([
#   #include <x86intrin.h>
#   int main(int argc, char **argv){
#   double* q;
#   __m512d q1 = _mm512_load_pd(q);
#   __m512d y1 = _mm512_fmadd_pd(q1, q1, q1);
#   return 0;
#   }
#   ])],
#   [can_compile_avx512=yes],
#   [can_compile_avx512=no]
#  )
#  AC_LANG_POP([C++])
#  AC_MSG_RESULT([${can_compile_avx512}])
#  if test "${can_compile_avx512}" = "no" ; then
#    AC_MSG_WARN([Cannot compile C++ with AVX512!])
#  fi
#fi

434
if test "${can_compile_avx}" = "yes" ; then
Andreas Marek's avatar
Andreas Marek committed
435 436 437 438 439 440
  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
Andreas Marek's avatar
Andreas Marek committed
441 442 443 444 445 446 447
else
  install_real_avx_block2=no
  install_real_avx_block4=no
  install_real_avx_block6=no

  install_complex_avx_block1=no
  install_complex_avx_block2=no
448 449
fi

450 451 452 453
if test "${can_compile_avx2}" = "yes" ; then
  install_real_avx2_block2=yes
  install_real_avx2_block4=yes
  install_real_avx2_block6=yes
Andreas Marek's avatar
Andreas Marek committed
454

455 456 457 458 459 460 461 462 463 464
  install_complex_avx2_block1=yes
  install_complex_avx2_block2=yes
else
  install_real_avx2_block2=no
  install_real_avx2_block4=no
  install_real_avx2_block6=no

  install_complex_avx2_block1=no
  install_complex_avx2_block2=no
fi
465

466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482
if test "${can_compile_avx512}" = "yes" ; then
  install_real_avx512_block2=yes
  install_real_avx512_block4=yes
  install_real_avx512_block6=yes

  install_complex_avx512_block1=yes
  install_complex_avx512_block2=yes
else
  install_real_avx512_block2=no
  install_real_avx512_block4=no
  install_real_avx512_block6=no

  install_complex_avx512_block1=no
  install_complex_avx512_block2=no
fi


483 484 485
AM_CONDITIONAL([HAVE_SSE_ASSEMBLY],[test x"$can_compile_sse_assembly" = x"yes"])
if test x"${can_compile_sse_assembly}" = x"yes" ; then
  AC_DEFINE([HAVE_SSE_ASSEMBLY],[1],[assembly SSE is supported on this CPU])
486
fi
487 488 489
AM_CONDITIONAL([HAVE_SSE_INTRINSICS],[test x"$can_compile_sse_intrinsics" = x"yes"])
if test x"${can_compile_sse_intrinsics}" = x"yes" ; then
  AC_DEFINE([HAVE_SSE_INTRINSICS],[1],[gcc intrinsics SSE is supported on this CPU])
490
fi
491

492 493 494 495 496 497 498
AM_CONDITIONAL([HAVE_AVX],[test x"$can_compile_avx" = x"yes"])
if test x"${can_compile_avx}" = x"yes" ; then
  AC_DEFINE([HAVE_AVX],[1],[AVX is supported on this CPU])
fi
AM_CONDITIONAL([HAVE_AVX2],[test x"$can_compile_avx2" = x"yes"])
if test x"${can_compile_avx2}" = x"yes" ; then
  AC_DEFINE([HAVE_AVX2],[1],[AVX2 is supported on this CPU])
499
fi
500 501 502 503
AM_CONDITIONAL([HAVE_AVX512],[test x"$can_compile_avx512" = x"yes"])
if test x"${can_compile_avx512}" = x"yes" ; then
  AC_DEFINE([HAVE_AVX512],[1],[AVX512 is supported on this CPU])
fi
504 505 506 507 508 509 510 511

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
512
AC_MSG_RESULT([${with_avx_optimization}])
513
if test x"${with_avx_optimization}" = x"yes"; then
Andreas Marek's avatar
Andreas Marek committed
514 515 516
 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
517

518
AC_LANG([Fortran])
519 520 521
AC_FC_FREEFORM
AC_FC_MODULE_FLAG
AC_FC_MODULE_OUTPUT_FLAG
522
AC_FC_LIBRARY_LDFLAGS
523 524 525 526

save_FCFLAGS=$FCFLAGS
save_LDFLAGS=$LDFLAGS

527 528 529
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])

530 531
FCFLAGS="$FCFLAGS $SCALAPACK_FCFLAGS"
LDFLAGS="$LDFLAGS $SCALAPACK_LDFLAGS"
532

533
dnl check whether fortran error_unit is defined
534
AC_MSG_CHECKING([whether Fortran module iso_fortran_env is available])
535
AC_COMPILE_IFELSE([AC_LANG_SOURCE([
536 537 538 539 540 541 542 543 544 545
  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]
)
546
AC_MSG_RESULT([${can_use_iso_fortran_env}])
547

548 549 550 551
dnl check whether one can link with specified MKL (desired method)
AC_MSG_CHECKING([whether we can compile a Fortran program using MKL])


552
AC_COMPILE_IFELSE([AC_LANG_SOURCE([
553
  program test_mkl
554
    use mkl_service
555 556 557 558 559 560 561 562 563 564 565 566
    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])
567
  AC_LINK_IFELSE([AC_LANG_SOURCE([
568
    program test_mkl
569
      use mkl_service
570 571 572 573 574
      character*198 :: string
      call mkl_get_version_string(string)
      write(*,'(a)') string
    end program
  ])],
Andreas Marek's avatar
Andreas Marek committed
575 576
    [have_mkl=yes],
    [have_mkl=no]
577
  )
Andreas Marek's avatar
Andreas Marek committed
578
  AC_MSG_RESULT([${have_mkl}])
579 580 581
fi

dnl if not mkl, check all the necessary individually
582
if test x"${have_mkl}" = x"yes" ; then
583 584 585 586
  WITH_MKL=1
else

  dnl first check blas
Andreas Marek's avatar
Andreas Marek committed
587 588 589
  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}])
590

591
  if test x"${have_blas}" = x"no" ; then
592
    AC_MSG_ERROR([could not link with blas: specify path])
593
  fi
594
  dnl now lapack
Andreas Marek's avatar
Andreas Marek committed
595 596 597
  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}])
598

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

603
  if test x"${with_mpi}" = x"yes"; then
604
    dnl test whether scalapack already contains blacs
605
    scalapack_libs="mpiscalapack scalapack scalapack-openmpi"
606 607 608 609 610 611 612 613 614 615
    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
616

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

620 621
      dnl Test for stand-alone blacs
      AC_SEARCH_LIBS([bi_f77_init],[mpiblacsF77init],[],[],[-lmpiblacs])
622 623 624 625 626 627

      dnl for debian
      AC_SEARCH_LIBS([blacs_gridinit],[blacs-openmpi],[have_blacs=yes],[have_blacs=no],[-lblacsCinit-openmpi -lscalapack-openmpi])
      if test x"${have_blacs}" = x"no"; then
        unset ac_cv_search_blacs_gridinit
      fi
628
      AC_SEARCH_LIBS([blacs_gridinit],[mpiblacs blacs],[have_blacs=yes],[have_blacs=no])
Andreas Marek's avatar
Andreas Marek committed
629

630 631 632
      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
633
    fi
634

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

637 638 639
    if test x"${have_scalapack}" = x"no" ; then
      AC_MSG_ERROR([could not link with scalapack: specify path])
    fi
640 641 642 643
  fi

  dnl check whether we can link alltogehter
  AC_MSG_CHECKING([whether we can link a Fortran program with all blacs/scalapack])
644
  AC_LINK_IFELSE([AC_LANG_SOURCE([
645 646
    program dgemm_test

647 648
      integer , parameter:: M = 4, N = 3, K = 2
      real :: A(M,K), B(K,N), C(M,N)
649

650
      call dgemm('N','N',M,N,K,1.0,A,M,B,K,0.0,C,M)
651 652 653 654 655 656 657 658

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

659
   if test x"${can_link_with_blacs_scalapack}" = x"yes" ; then
660 661
     WITH_BLACS=1
   else
662
   AC_MSG_ERROR([We can neither link with MKL or another Scalpack. Please specify SCALAPACK_LDFLAGS and SCALAPACK_FCFLAGS!])
663 664 665
   fi
fi

666 667 668 669
dnl important: reset them again!
FCFLAGS=$save_FCFLAGS
LDFLAGS=$save_LDFLAGS

Andreas Marek's avatar
Andreas Marek committed
670 671 672 673
dnl check for intrinsic fortran function of 2003 standard
AC_MSG_CHECKING([whether we can use the intrinsic Fortran function "get_environment_variable"])


674
AC_COMPILE_IFELSE([AC_LANG_SOURCE([
Andreas Marek's avatar
Andreas Marek committed
675 676 677 678 679 680 681 682 683
  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}])
684 685 686
if test x"${fortran_can_check_environment}" = x"yes" ; then
 AC_DEFINE([HAVE_ENVIRONMENT_CHECKING],[1],[Fortran can query environment variables])
fi
Andreas Marek's avatar
Andreas Marek committed
687

688 689
dnl check whether GPU version is requested

690
#CUDA_INSTALL_PATH="/usr/local/cuda/"
691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708
#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])
709
  CUDA_CFLAGS="$CUDA_CFLAGS -arch sm_35 -O2 -I$CUDA_INSTALL_PATH/include"
710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732
  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
Andreas Marek's avatar
Andreas Marek committed
733
  can_compile_gpu=yes
734 735
fi

Andreas Marek's avatar
Andreas Marek committed
736 737 738 739 740 741 742 743
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])

744
AC_LINK_IFELSE([AC_LANG_SOURCE([
Andreas Marek's avatar
Andreas Marek committed
745 746 747
  program test_bgp
    complex*16 :: y3,q3,h2
    y3 = fxcpmadd(y3,q3,h2)
748

Andreas Marek's avatar
Andreas Marek committed
749 750 751 752 753 754 755
  end program
])],
  [can_compile_bgp=yes],
  [can_compile_bgp=no]
)
AC_MSG_RESULT([${can_compile_bgp}])

756
if test x"${can_compile_bgp}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
757 758
  install_real_bgp=yes
  install_complex_bgp=yes
Andreas Marek's avatar
Andreas Marek committed
759 760 761
else
  install_real_bgp=no
  install_complex_bgp=no
Andreas Marek's avatar
Andreas Marek committed
762 763 764 765 766
fi

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

767
AC_LINK_IFELSE([AC_LANG_SOURCE([
Andreas Marek's avatar
Andreas Marek committed
768
  program test_bgq
Andreas Marek's avatar
Andreas Marek committed
769 770
    VECTOR(REAL(8))::QPX_h2
    real*8         :: hh(10,2)
Andreas Marek's avatar
Andreas Marek committed
771
    QPX_h2 = VEC_SPLATS(hh(2,2))
772

Andreas Marek's avatar
Andreas Marek committed
773 774 775 776 777 778 779
  end program
])],
  [can_compile_bgq=yes],
  [can_compile_bgq=no]
)
AC_MSG_RESULT([${can_compile_bgq}])

780
if test x"${can_compile_bgq}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
781 782
  install_real_bgq=yes
  install_complex_bgq=yes
Andreas Marek's avatar
Andreas Marek committed
783 784 785
else
  install_real_bgq=no
  install_complex_bgq=no
Andreas Marek's avatar
Andreas Marek committed
786 787
fi

788 789
dnl Test possibility of 'use mpi', if requested
if test x"${with_mpi}" = x"yes" ; then
790 791 792
  AC_ARG_ENABLE([mpi-module],
                AS_HELP_STRING([--disable-mpi-module],
                               [Do not use the Fortran MPI module, get interfaces by 'include "mpif.h')]),
793
                [],
794 795
                [enable_mpi_module=yes])
  if test x"${enable_mpi_module}" = x"yes" ; then
796 797 798 799 800 801 802 803 804 805 806 807 808 809 810
    AC_MSG_CHECKING(whether Fortran mpi module can be used)
    AC_COMPILE_IFELSE([AC_LANG_SOURCE([
      program test_mpi_module
        use mpi
        real :: time
        time = MPI_WTime()
      end program
    ])],
      [can_use_fortran_mpi_module=yes],
      [can_use_fortran_mpi_module=no]
    )
    AC_MSG_RESULT([${can_use_fortran_mpi_module}])
    if test x"${can_use_fortran_mpi_module}" = x"yes" ; then
      AC_DEFINE([HAVE_MPI_MODULE],[1],[can use the Fortran mpi module])
    else
811
      AC_MSG_ERROR([Could not compile a Fortran program with an 'use mpi' statement. You can try again with --disable-mpi-module])
812
    fi
813
  fi
Andreas Marek's avatar
Andreas Marek committed
814 815
fi

816 817 818 819
dnl default value
use_specific_real_kernel=no
use_specific_complex_kernel=no

820 821 822
dnl GPU version only
m4_include([m4/ax_elpa_gpu_version_only.m4])
DEFINE_OPTION_GPU_SUPPORT_ONLY([gpu-version-only],[gpu-support],[install_gpu])
Andreas Marek's avatar
Andreas Marek committed
823

824 825
dnl last check whether user wants to compile only a specific kernel
dnl
826
m4_include([m4/ax_elpa_specific_kernels.m4])
Andreas Marek's avatar
Andreas Marek committed
827

828
dnl real kernels
829
dnl do not remove this variable it is needed in the macros
830

831 832
dnl generic kernel
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-generic-kernel-only],[generic-kernel],[install_real_generic])
Andreas Marek's avatar
Andreas Marek committed
833

834 835
dnl generic-simple kernel
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-generic-simple-kernel-only],[generic-simple-kernel],[install_real_generic_simple])
Andreas Marek's avatar
Andreas Marek committed
836

837
dnl sse kernel
838
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-sse-assembly-kernel-only],[sse-assembly-kernel],[install_real_sse_assembly])
Andreas Marek's avatar
Andreas Marek committed
839

840 841
dnl bgp kernel
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-bgp-kernel-only],[bgp-kernel],[install_real_bgp])
Andreas Marek's avatar
Andreas Marek committed
842

843 844
dnl bgq kernel
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-bgq-kernel-only],[bgq-kernel],[install_real_bgq])
Andreas Marek's avatar
Andreas Marek committed
845

846 847
dnl real-sse-block2 kernel
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-sse-block2-kernel-only],[real-sse-block2-kernel],[install_real_sse_block2])
848

849 850
dnl real-sse-block4 kernel
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-sse-block4-kernel]-only,[real-sse-block4-kernel],[install_real_sse_block4])
851

852 853
dnl real-sse-block6 kernel
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-sse-block6-kernel-only],[real-sse-block6-kernel],[install_real_sse_block6])
854

855 856
dnl real-avx-block2 kernel
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-avx-block2-kernel-only],[real-avx-block2-kernel],[install_real_avx_block2])
Andreas Marek's avatar
Andreas Marek committed
857

858 859
dnl real-avx-block4 kernel
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-avx-block4-kernel]-only,[real-avx-block4-kernel],[install_real_avx_block4])
860

861 862
dnl real-avx-block6 kernel
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-avx-block6-kernel-only],[real-avx-block6-kernel],[install_real_avx_block6])
Andreas Marek's avatar
Andreas Marek committed
863

864 865
dnl real-avx2-block2 kernel
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-avx2-block2-kernel-only],[real-avx2-block2-kernel],[install_real_avx2_block2])
866

867 868
dnl real-avx2-block4 kernel
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-avx2-block4-kernel]-only,[real-avx2-block4-kernel],[install_real_avx2_block4])
869

870 871
dnl real-avx2-block6 kernel
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-avx2-block6-kernel-only],[real-avx2-block6-kernel],[install_real_avx2_block6])
Andreas Marek's avatar
Andreas Marek committed
872

873 874 875 876 877 878 879 880 881 882
dnl real-avx512-block2 kernel
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-avx512-block2-kernel-only],[real-avx512-block2-kernel],[install_real_avx512_block2])

dnl real-avx512-block4 kernel
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-avx512-block4-kernel]-only,[real-avx512-block4-kernel],[install_real_avx512_block4])

dnl real-avx512-block6 kernel
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-avx512-block6-kernel-only],[real-avx512-block6-kernel],[install_real_avx512_block6])


Andreas Marek's avatar
Andreas Marek committed
883
dnl complex kernels
884

885 886
dnl generic kernel
DEFINE_OPTION_SPECIFIC_COMPLEX_KERNEL([complex-generic-kernel-only],[generic-kernel],[install_complex_generic])
Andreas Marek's avatar
Andreas Marek committed
887

888 889
dnl generic-simple kernel
DEFINE_OPTION_SPECIFIC_COMPLEX_KERNEL([complex-generic-simple-kernel-only],[generic-simple-kernel],[install_complex_generic_simple])
Andreas Marek's avatar
Andreas Marek committed
890

891
dnl sse kernel
892
DEFINE_OPTION_SPECIFIC_COMPLEX_KERNEL([complex-sse-assembly-kernel-only],[sse-assembly-kernel],[install_complex_sse_assembly])
Andreas Marek's avatar
Andreas Marek committed
893

894 895
dnl complex-bqp kernel
DEFINE_OPTION_SPECIFIC_COMPLEX_KERNEL([complex-bgp-kernel-only],[bgp-kernel],[install_complex_bgp])
Andreas Marek's avatar
Andreas Marek committed
896

897 898
dnl complex-bqq kernel
DEFINE_OPTION_SPECIFIC_COMPLEX_KERNEL([complex-bgq-kernel-only],[bgq-kernel],[install_complex_bgq])
Andreas Marek's avatar
Andreas Marek committed
899

900 901
dnl complex-sse-block1 kernel
DEFINE_OPTION_SPECIFIC_COMPLEX_KERNEL([complex-sse-block1-kernel-only],[complex-sse-block1-kernel],[install_complex_sse_block1])
902

903 904
dnl complex-sse-block2 kernel
DEFINE_OPTION_SPECIFIC_COMPLEX_KERNEL([complex-sse-block2-kernel-only],[complex-sse-block2-kernel],[install_complex_sse_block2])
905

906 907
dnl complex-avx-block1 kernel
DEFINE_OPTION_SPECIFIC_COMPLEX_KERNEL([complex-avx-block1-kernel-only],[complex-avx-block1-kernel],[install_complex_avx_block1])
Andreas Marek's avatar
Andreas Marek committed
908

909 910
dnl complex-avx-block2 kernel
DEFINE_OPTION_SPECIFIC_COMPLEX_KERNEL([complex-avx-block2-kernel-only],[complex-avx-block2-kernel],[install_complex_avx_block2])
Andreas Marek's avatar
Andreas Marek committed
911

912 913
dnl complex-avx2-block1 kernel
DEFINE_OPTION_SPECIFIC_COMPLEX_KERNEL([complex-avx2-block1-kernel-only],[complex-avx2-block1-kernel],[install_complex_avx2_block1])
914

915 916
dnl complex-avx2-block2 kernel
DEFINE_OPTION_SPECIFIC_COMPLEX_KERNEL([complex-avx2-block2-kernel-only],[complex-avx2-block2-kernel],[install_complex_avx2_block2])
917

918 919 920 921 922 923 924
dnl complex-avx512-block1 kernel
DEFINE_OPTION_SPECIFIC_COMPLEX_KERNEL([complex-avx512-block1-kernel-only],[complex-avx512-block1-kernel],[install_complex_avx512_block1])

dnl complex-avx512-block2 kernel
DEFINE_OPTION_SPECIFIC_COMPLEX_KERNEL([complex-avx512-block2-kernel-only],[complex-avx512-block2-kernel],[install_complex_avx512_block2])


925

926
dnl set the conditionals according to the previous tests
927

928
if test x"${can_use_iso_fortran_env}" = x"yes" ; then
929 930 931
 AC_DEFINE([HAVE_ISO_FORTRAN_ENV],[1],[can use module iso_fortran_env])
fi

932 933 934
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])
935
fi
936

Andreas Marek's avatar
Andreas Marek committed
937
AM_CONDITIONAL([WITH_REAL_GENERIC_KERNEL],[test x"$install_real_generic" = x"yes"])
938
if test x"${install_real_generic}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
939 940 941 942
 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"])
943
if test x"${install_complex_generic}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
944 945 946 947
 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"])
948
if test x"${install_real_generic_simple}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
949 950 951 952
 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"])
953
if test x"${install_complex_generic_simple}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
954 955 956
 AC_DEFINE([WITH_COMPLEX_GENERIC_SIMPLE_KERNEL],[1],[can use complex generic-simple kernel])
fi

957 958 959
AM_CONDITIONAL([WITH_REAL_SSE_ASSEMBLY_KERNEL],[test x"$install_real_sse_assembly" = x"yes"])
if test x"${install_real_sse_assembly}" = x"yes" ; then
 AC_DEFINE([WITH_REAL_SSE_ASSEMBLY_KERNEL],[1],[can use real SSE assembly kernel])
Andreas Marek's avatar
Andreas Marek committed
960 961
fi

962 963 964
AM_CONDITIONAL([WITH_COMPLEX_SSE_ASSEMBLY_KERNEL],[test x"$install_complex_sse_assembly" = x"yes"])
if test x"${install_complex_sse_assembly}" = x"yes" ; then
 AC_DEFINE([WITH_COMPLEX_SSE_ASSEMBLY_KERNEL],[1],[can use complex SSE assembly kernel])
Andreas Marek's avatar
Andreas Marek committed
965 966
fi

967 968 969 970 971 972 973 974 975 976 977 978 979 980 981
AM_CONDITIONAL([WITH_REAL_SSE_BLOCK2_KERNEL],[test x"$install_real_sse_block2" = x"yes"])
if test x"${install_real_sse_block2}" = x"yes" ; then
 AC_DEFINE([WITH_REAL_SSE_BLOCK2_KERNEL],[1],[can use real_sse_block2 kernel])
fi

AM_CONDITIONAL([WITH_REAL_SSE_BLOCK4_KERNEL],[test x"$install_real_sse_block4" = x"yes"])
if test x"${install_real_sse_block4}" = x"yes" ; then
 AC_DEFINE([WITH_REAL_SSE_BLOCK4_KERNEL],[1],[can use real_sse_block4 kernel])
fi

AM_CONDITIONAL([WITH_REAL_SSE_BLOCK6_KERNEL],[test x"$install_real_sse_block6" = x"yes"])
if test x"${install_real_sse_block6}" = x"yes" ; then
 AC_DEFINE([WITH_REAL_SSE_BLOCK6_KERNEL],[1],[can use real_sse_block6 kernel])
fi

Andreas Marek's avatar
Andreas Marek committed
982
AM_CONDITIONAL([WITH_REAL_AVX_BLOCK2_KERNEL],[test x"$install_real_avx_block2" = x"yes"])
983
if test x"${install_real_avx_block2}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
984 985 986 987
 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"])
988
if test x"${install_real_avx_block4}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
989 990 991 992
 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"])
993
if test x"${install_real_avx_block6}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
994 995 996
 AC_DEFINE([WITH_REAL_AVX_BLOCK6_KERNEL],[1],[can use real_avx_block6 kernel])
fi

997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011
AM_CONDITIONAL([WITH_REAL_AVX2_BLOCK2_KERNEL],[test x"$install_real_avx2_block2" = x"yes"])
if test x"${install_real_avx2_block2}" = x"yes" ; then
 AC_DEFINE([WITH_REAL_AVX2_BLOCK2_KERNEL],[1],[can use real_avx2_block2 kernel])
fi

AM_CONDITIONAL([WITH_REAL_AVX2_BLOCK4_KERNEL],[test x"$install_real_avx2_block4" = x"yes"])
if test x"${install_real_avx2_block4}" = x"yes" ; then
 AC_DEFINE([WITH_REAL_AVX2_BLOCK4_KERNEL],[1],[can use real_avx2_block4 kernel])
fi

AM_CONDITIONAL([WITH_REAL_AVX2_BLOCK6_KERNEL],[test x"$install_real_avx2_block6" = x"yes"])
if test x"${install_real_avx2_block6}" = x"yes" ; then
 AC_DEFINE([WITH_REAL_AVX2_BLOCK6_KERNEL],[1],[can use real_avx2_block6 kernel])
fi

1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026
AM_CONDITIONAL([WITH_REAL_AVX512_BLOCK2_KERNEL],[test x"$install_real_avx512_block2" = x"yes"])
if test x"${install_real_avx512_block2}" = x"yes" ; then
 AC_DEFINE([WITH_REAL_AVX512_BLOCK2_KERNEL],[1],[can use real_avx512_block2 kernel])
fi

AM_CONDITIONAL([WITH_REAL_AVX512_BLOCK4_KERNEL],[test x"$install_real_avx512_block4" = x"yes"])
if test x"${install_real_avx512_block4}" = x"yes" ; then
 AC_DEFINE([WITH_REAL_AVX512_BLOCK4_KERNEL],[1],[can use real_avx512_block4 kernel])
fi

AM_CONDITIONAL([WITH_REAL_AVX512_BLOCK6_KERNEL],[test x"$install_real_avx512_block6" = x"yes"])
if test x"${install_real_avx512_block6}" = x"yes" ; then
 AC_DEFINE([WITH_REAL_AVX512_BLOCK6_KERNEL],[1],[can use real_avx512_block6 kernel])
fi

1027 1028 1029 1030 1031 1032 1033 1034 1035 1036
AM_CONDITIONAL([WITH_COMPLEX_SSE_BLOCK1_KERNEL],[test x"$install_complex_sse_block1" = x"yes"])
if test x"${install_complex_sse_block1}" = x"yes" ; then
 AC_DEFINE([WITH_COMPLEX_SSE_BLOCK1_KERNEL],[1],[can use complex_sse_block1 kernel])
fi

AM_CONDITIONAL([WITH_COMPLEX_SSE_BLOCK2_KERNEL],[test x"$install_complex_sse_block2" = x"yes"])
if test x"${install_complex_sse_block2}" = x"yes" ; then
 AC_DEFINE([WITH_COMPLEX_SSE_BLOCK2_KERNEL],[1],[can use complex_sse_block2 kernel])
fi

Andreas Marek's avatar
Andreas Marek committed
1037
AM_CONDITIONAL([WITH_COMPLEX_AVX_BLOCK1_KERNEL],[test x"$install_complex_avx_block1" = x"yes"])
1038
if test x"${install_complex_avx_block1}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
1039 1040 1041 1042
 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"])
1043
if test x"${install_complex_avx_block2}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
1044 1045 1046
 AC_DEFINE([WITH_COMPLEX_AVX_BLOCK2_KERNEL],[1],[can use complex_avx_block2 kernel])
fi

1047 1048 1049 1050 1051 1052 1053 1054 1055 1056
AM_CONDITIONAL([WITH_COMPLEX_AVX2_BLOCK1_KERNEL],[test x"$install_complex_avx2_block1" = x"yes"])
if test x"${install_complex_avx2_block1}" = x"yes" ; then
 AC_DEFINE([WITH_COMPLEX_AVX2_BLOCK1_KERNEL],[1],[can use complex_avx2_block1 kernel])
fi

AM_CONDITIONAL([WITH_COMPLEX_AVX2_BLOCK2_KERNEL],[test x"$install_complex_avx2_block2" = x"yes"])
if test x"${install_complex_avx2_block2}" = x"yes" ; then
 AC_DEFINE([WITH_COMPLEX_AVX2_BLOCK2_KERNEL],[1],[can use complex_avx2_block2 kernel])
fi

1057 1058 1059 1060 1061 1062 1063 1064 1065 1066
AM_CONDITIONAL([WITH_COMPLEX_AVX512_BLOCK1_KERNEL],[test x"$install_complex_avx512_block1" = x"yes"])
if test x"${install_complex_avx512_block1}" = x"yes" ; then
 AC_DEFINE([WITH_COMPLEX_AVX512_BLOCK1_KERNEL],[1],[can use complex_avx512_block1 kernel])
fi

AM_CONDITIONAL([WITH_COMPLEX_AVX512_BLOCK2_KERNEL],[test x"$install_complex_avx512_block2" = x"yes"])
if test x"${install_complex_avx512_block2}" = x"yes" ; then
 AC_DEFINE([WITH_COMPLEX_AVX512_BLOCK2_KERNEL],[1],[can use complex_avx512_block2 kernel])
fi

Andreas Marek's avatar
Andreas Marek committed
1067
AM_CONDITIONAL([WITH_REAL_BGP_KERNEL],[test x"$install_real_bgp" = x"yes"])
1068
if test x"${install_real_bgp}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
1069 1070 1071 1072
 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"])
1073
if test x"${install_real_bgq}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
1074 1075 1076
 AC_DEFINE([WITH_REAL_BGQ_KERNEL],[1],[can use real BGQ kernel])
fi

1077
if test x"${use_specific_complex_kernel}" = x"no" ; then
1078
  AC_DEFINE([WITH_NO_SPECIFIC_COMPLEX_KERNEL],[1],[do not use only one specific complex kernel (set at compile time)])
1079
else
1080
  AC_DEFINE([WITH_ONE_SPECIFIC_COMPLEX_KERNEL],[1],[use only one specific complex kernel (set at compile time)])
Andreas Marek's avatar
Andreas Marek committed
1081 1082
fi

1083
if test x"${use_specific_real_kernel}" = x"no" ; then
1084
  AC_DEFINE([WITH_NO_SPECIFIC_REAL_KERNEL],[1],[do not use only one specific real kernel (set at compile time)])
1085 1086
else
  AC_DEFINE([WITH_ONE_SPECIFIC_REAL_KERNEL],[1],[use only one specific real kernel (set at compile time)])
Andreas Marek's avatar
Andreas Marek committed
1087 1088
fi

1089 1090
LT_INIT

1091 1092 1093 1094 1095 1096
DX_PDF_FEATURE(OFF)
DX_PS_FEATURE(OFF)
DX_MAN_FEATURE(ON)
DX_HTML_FEATURE(ON)
DX_INIT_DOXYGEN([ELPA], [Doxyfile], [docs])

1097
DESPERATELY_WANT_ASSUMED_SIZE=no
1098
AC_MSG_CHECKING(whether --enable-assumed-size is specified)
1099
AC_ARG_ENABLE([assumed-size],
1100
                AS_HELP_STRING([--enable-assumed-size],
1101 1102 1103 1104 1105
                               [use assumed-size Fortran arrays]),
              [],
              [DESPERATELY_WANT_ASSUMED_SIZE=no])
AC_MSG_RESULT([${DESPERATELY_WANT_ASSUMED_SIZE}])
AM_CONDITIONAL([WITH_DESPERATELY_WANT_ASSUMED_SIZE],[test x"$DESPERATELY_WANT_ASSUMED_SIZE" = x"yes"])
1106
if test x"${DESPERATELY_WANT_ASSUMED_SIZE}" = x"yes" ; then
1107
  AC_DEFINE([DESPERATELY_WANT_ASSUMED_SIZE],[1],[use assumed size Fortran arrays, even if not debuggable])
1108 1109
fi

1110 1111 1112
if test x"${want_single_precision}" = x"yes" ; then
  AC_DEFINE([WANT_SINGLE_PRECISION_REAL],[1],[build also single-precision for real calculation])
  AC_DEFINE([WANT_SINGLE_PRECISION_COMPLEX],[1],[build also single-precision for complex calculation])
1113
fi
1114 1115
AM_CONDITIONAL([WANT_SINGLE_PRECISION_REAL],[test x"$want_single_precision" = x"yes"])
AM_CONDITIONAL([WANT_SINGLE_PRECISION_COMPLEX],[test x"$want_single_precision" = x"yes"])
1116

1117
AC_SUBST([MPI_BINARY])
1118 1119 1120 1121 1122
AC_SUBST([WITH_MKL])
AC_SUBST([WITH_BLACS])
AC_SUBST([with_amd_bulldozer_kernel])
AC_SUBST([FC_MODINC])
AC_SUBST([FC_MODOUT])
1123 1124 1125
AC_SUBST([OPENMP_CFLAGS])
AC_SUBST([OPENMP_FCFLAGS])
AC_SUBST([OPENMP_LDFLAGS])
1126
AC_SUBST([DOXYGEN_OUTPUT_DIR], [docs])
1127

1128 1129
rm -rf modules/ private_modules/ .fortran_dependencies/
mkdir modules private_modules
1130 1131 1132 1133 1134 1135 1136 1137 1138 1139

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

1140 1141 1142 1143 1144 1145 1146 1147 1148

# 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')
1149

1150 1151
if test x"${with_mpi}" = x"yes"; then
  if test x"${enable_openmp}" = x"yes"; then
1152
	SUFFIX="_openmp"
1153
  else
1154
	SUFFIX=""
1155 1156 1157
  fi
else
  if test x"${enable_openmp}" = x"yes"; then
Lorenz Huedepohl's avatar
Typo  
Lorenz Huedepohl committed
1158
	SUFFIX="_onenode_openmp"
1159 1160 1161
  else
	SUFFIX="_onenode"
  fi
1162
fi
1163

1164 1165
AC_SUBST([SUFFIX])
AC_SUBST([PKG_CONFIG_FILE],[elpa${SUFFIX}-${PACKAGE_VERSION}.pc])
1166

1167 1168
AC_CONFIG_FILES([
  Makefile
1169
  Doxyfile
1170
  ${PKG_CONFIG_FILE}:elpa.pc.in
1171
])
1172

1173
AC_OUTPUT
1174

1175
if test "${can_compile_avx}" = "no" ; then
1176
#  if test x"${want_avx}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
1177
    AC_MSG_WARN([Could not compile AVX instructions])
1178
#  fi
1179
fi
1180
if test "${can_compile_avx2}" = "no" ; then
1181
#  if test x"${want_avx2}" = x"yes" ; then
1182
    AC_MSG_WARN([Could not compile AVX2 instructions])
1183
#  fi
1184
fi
1185 1186 1187 1188 1189 1190
if test "${can_compile_avx512}" = "no" ; then
#  if test x"${want_avx512}" = x"yes" ; then
    AC_MSG_WARN([Could not compile AVX512 instructions])
#  fi
fi

1191 1192 1193 1194

if test "${can_compile_sse}" = "no" ; then
  AC_MSG_WARN([Could not compile SSE instructions])
fi
1195

1196
make -f $srcdir/generated_headers.am generated-headers top_srcdir="$srcdir"