There is a maintenance of MPCDF Gitlab on Thursday, April 22st 2020, 9:00 am CEST - Expect some service interruptions during this time

configure.ac 37.9 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], [8:0:0])
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

117
if test x"${enable_openmp}" = x"yes"; then
118 119 120 121 122
  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"
123 124
fi

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

Andreas Marek's avatar
Andreas Marek committed
133 134 135 136 137 138 139 140 141 142 143
## 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
144 145 146



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

Andreas Marek's avatar
Andreas Marek committed
149 150 151 152 153 154 155 156
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
157 158 159 160 161 162

install_real_generic=yes
install_real_generic_simple=yes

install_complex_generic=yes
install_complex_generic_simple=yes
163

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

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
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)
Andreas Marek's avatar
Andreas Marek committed
188
AC_ARG_ENABLE([timings],
189 190
		AS_HELP_STRING([--enable-timing],
			       [more detailed timing, default no.]),
191
	      [enable_timings=yes],
192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210
	      [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
dnl check whether on can compile with sse-gcc intrinsics
253
AC_MSG_CHECKING(whether we can compile SSE3 with gcc intrinsics in C)
254 255 256 257 258 259 260 261 262 263 264 265 266 267 268
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
dnl check whether one can compile with avx - gcc intrinsics
288

289
dnl first pass: try with specified CFLAGS and CXXFLAGS
Andreas Marek's avatar
Andreas Marek committed
290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315

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
  AC_MSG_CHECKING([whether we can compile AVX 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
316

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

Andreas Marek's avatar
Andreas Marek committed
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 363
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 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
364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385

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

387
if test "${can_compile_avx}" = "yes" ; then
Andreas Marek's avatar
Andreas Marek committed
388 389 390 391 392 393
  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
394 395 396 397 398 399 400
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
401 402
fi

403 404 405 406
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
407

408 409 410 411 412 413 414 415 416 417
  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
418 419 420 421

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])
422
fi
423 424 425
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])
426
fi
427

428 429 430 431 432 433 434
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])
435 436 437 438 439 440 441 442 443
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
444
AC_MSG_RESULT([${with_avx_optimization}])
445
if test x"${with_avx_optimization}" = x"yes"; then
Andreas Marek's avatar
Andreas Marek committed
446 447 448
 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
449

450
AC_LANG([Fortran])
451 452 453
AC_FC_FREEFORM
AC_FC_MODULE_FLAG
AC_FC_MODULE_OUTPUT_FLAG
454
AC_FC_LIBRARY_LDFLAGS
455 456 457 458

save_FCFLAGS=$FCFLAGS
save_LDFLAGS=$LDFLAGS

459 460 461
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])

462 463
FCFLAGS="$FCFLAGS $SCALAPACK_FCFLAGS"
LDFLAGS="$LDFLAGS $SCALAPACK_LDFLAGS"
464

465
dnl check whether fortran error_unit is defined
466
AC_MSG_CHECKING([whether Fortran module iso_fortran_env is available])
467
AC_COMPILE_IFELSE([AC_LANG_SOURCE([
468 469 470 471 472 473 474 475 476 477
  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]
)
478
AC_MSG_RESULT([${can_use_iso_fortran_env}])
479

480 481 482 483
dnl check whether one can link with specified MKL (desired method)
AC_MSG_CHECKING([whether we can compile a Fortran program using MKL])


484
AC_COMPILE_IFELSE([AC_LANG_SOURCE([
485
  program test_mkl
486
    use mkl_service
487 488 489 490 491 492 493 494 495 496 497 498
    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])
499
  AC_LINK_IFELSE([AC_LANG_SOURCE([
500
    program test_mkl
501
      use mkl_service
502 503 504 505 506
      character*198 :: string
      call mkl_get_version_string(string)
      write(*,'(a)') string
    end program
  ])],
Andreas Marek's avatar
Andreas Marek committed
507 508
    [have_mkl=yes],
    [have_mkl=no]
509
  )
Andreas Marek's avatar
Andreas Marek committed
510
  AC_MSG_RESULT([${have_mkl}])
511 512 513
fi

dnl if not mkl, check all the necessary individually
514
if test x"${have_mkl}" = x"yes" ; then
515 516 517 518
  WITH_MKL=1
else

  dnl first check blas
519
  AC_SEARCH_LIBS([dgemm],[openblas satlas blas],[have_blas=yes],[have_blas=no])
Andreas Marek's avatar
Andreas Marek committed
520 521
  AC_MSG_CHECKING([whether we can link a program with a blas lib])
  AC_MSG_RESULT([${have_blas}])
522

523
  if test x"${have_blas}" = x"no" ; then
524
    AC_MSG_ERROR([could not link with blas: specify path])
525
  fi
526
  dnl now lapack
Andreas Marek's avatar
Andreas Marek committed
527 528 529
  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}])
530

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

535
  if test x"${with_mpi}" = x"yes"; then
536
    dnl test whether scalapack already contains blacs
537
    scalapack_libs="mpiscalapack scalapack scalapack-openmpi"
538 539 540 541 542 543 544 545 546 547
    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
548

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

552 553
      dnl Test for stand-alone blacs
      AC_SEARCH_LIBS([bi_f77_init],[mpiblacsF77init],[],[],[-lmpiblacs])
554 555 556 557 558 559

      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
560
      AC_SEARCH_LIBS([blacs_gridinit],[mpiblacs blacs],[have_blacs=yes],[have_blacs=no])
Andreas Marek's avatar
Andreas Marek committed
561

562 563 564
      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
565
    fi
566

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

569 570 571
    if test x"${have_scalapack}" = x"no" ; then
      AC_MSG_ERROR([could not link with scalapack: specify path])
    fi
572 573 574 575
  fi

  dnl check whether we can link alltogehter
  AC_MSG_CHECKING([whether we can link a Fortran program with all blacs/scalapack])
576
  AC_LINK_IFELSE([AC_LANG_SOURCE([
577 578
    program dgemm_test

579 580
      integer , parameter:: M = 4, N = 3, K = 2
      real :: A(M,K), B(K,N), C(M,N)
581

582
      call dgemm('N','N',M,N,K,1.0,A,M,B,K,0.0,C,M)
583 584 585 586 587 588 589 590

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

591
   if test x"${can_link_with_blacs_scalapack}" = x"yes" ; then
592 593
     WITH_BLACS=1
   else
594
   AC_MSG_ERROR([We can neither link with MKL or another Scalpack. Please specify SCALAPACK_LDFLAGS and SCALAPACK_FCFLAGS!])
595 596 597
   fi
fi

598 599 600 601
dnl important: reset them again!
FCFLAGS=$save_FCFLAGS
LDFLAGS=$save_LDFLAGS

Andreas Marek's avatar
Andreas Marek committed
602 603 604 605
dnl check for intrinsic fortran function of 2003 standard
AC_MSG_CHECKING([whether we can use the intrinsic Fortran function "get_environment_variable"])


606
AC_COMPILE_IFELSE([AC_LANG_SOURCE([
Andreas Marek's avatar
Andreas Marek committed
607 608 609 610 611 612 613 614 615
  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}])
616 617 618
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
619

620
dnl check whether BAND_TO_FULL_BLOCKING is set
621
use_band_to_full_blocking=yes
622 623
AC_MSG_CHECKING(whether BAND_TO_FLULL_BLOCKING is requested)
AC_ARG_ENABLE(band-to-full-blocking,[AS_HELP_STRING([--enable-band-to-full-blocking],
624
	                                            [build ELPA2 with blocking in band_to_full (default: enabled)])],
625 626
	      want_band_to_full_blocking="yes", want_to_full_blocking="no")
AC_MSG_RESULT([${want_band_to_full_blocking}])
627 628 629 630 631 632 633 634

if test x"${enableval}" = x"no" ; then
  use_band_to_full_blocking=no
fi

AM_CONDITIONAL([BAND_TO_FULL_BLOCKING],[test x"$use_band_to_full_blocking" = x"yes"])
if test x"${use_band_to_full_blocking}" = x"yes"; then
       AC_DEFINE([BAND_TO_FULL_BLOCKING], [1], [use blocking in trans_ev_band_to_full])
635 636
fi

637 638
dnl check whether GPU version is requested

639
#CUDA_INSTALL_PATH="/usr/local/cuda/"
640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655
#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
656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674
user_sets_gpu_compute_capability="no"
AC_MSG_CHECKING(whether a GPU compute capability is specified)
AC_ARG_WITH([GPU-compute-capability],
            [AS_HELP_STRING([--with-GPU-compute-capability=value],
	       	            [use compute capability "value" for GPU version (default sm_35)])],
	    [user_sets_gpu_compute_capability="yes"],[cuda_compute_capability="sm_35"])
AC_MSG_RESULT([${user_sets_gpu_compute_capability}])

dnl sanity check whether compute capability setting by user is reasonable
if test x"${user_sets_gpu_compute_capability}" = x"yes" ; then
  dnl the user must set a value which starts with "sm_"
  value=$(echo $withval | cut -c1-3)
  if test x"${value}" = x"sm_" ; then
    cuda_compute_capability=$withval
  else
    AC_MSG_ERROR([Unknown GPU compute capability set: ${withval}])
  fi
fi

675 676
if test x"${want_gpu}" = x"yes" ; then
  AC_LANG_PUSH([C])
677
  CUDA_CFLAGS="$CUDA_CFLAGS -arch $cuda_compute_capability -O2 -I$CUDA_INSTALL_PATH/include"
678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700
  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
701
  can_compile_gpu=yes
702 703
fi

Andreas Marek's avatar
Andreas Marek committed
704 705 706 707 708 709 710 711
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])

712
AC_LINK_IFELSE([AC_LANG_SOURCE([
Andreas Marek's avatar
Andreas Marek committed
713 714 715
  program test_bgp
    complex*16 :: y3,q3,h2
    y3 = fxcpmadd(y3,q3,h2)
716

Andreas Marek's avatar
Andreas Marek committed
717 718 719 720 721 722 723
  end program
])],
  [can_compile_bgp=yes],
  [can_compile_bgp=no]
)
AC_MSG_RESULT([${can_compile_bgp}])

724
if test x"${can_compile_bgp}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
725 726
  install_real_bgp=yes
  install_complex_bgp=yes
Andreas Marek's avatar
Andreas Marek committed
727 728 729
else
  install_real_bgp=no
  install_complex_bgp=no
Andreas Marek's avatar
Andreas Marek committed
730 731 732 733 734
fi

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

735
AC_LINK_IFELSE([AC_LANG_SOURCE([
Andreas Marek's avatar
Andreas Marek committed
736
  program test_bgq
Andreas Marek's avatar
Andreas Marek committed
737 738
    VECTOR(REAL(8))::QPX_h2
    real*8         :: hh(10,2)
Andreas Marek's avatar
Andreas Marek committed
739
    QPX_h2 = VEC_SPLATS(hh(2,2))
740

Andreas Marek's avatar
Andreas Marek committed
741 742 743 744 745 746 747
  end program
])],
  [can_compile_bgq=yes],
  [can_compile_bgq=no]
)
AC_MSG_RESULT([${can_compile_bgq}])

748
if test x"${can_compile_bgq}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
749 750
  install_real_bgq=yes
  install_complex_bgq=yes
Andreas Marek's avatar
Andreas Marek committed
751 752 753
else
  install_real_bgq=no
  install_complex_bgq=no
Andreas Marek's avatar
Andreas Marek committed
754 755
fi

756 757
dnl Test possibility of 'use mpi', if requested
if test x"${with_mpi}" = x"yes" ; then
758 759 760
  AC_ARG_ENABLE([mpi-module],
                AS_HELP_STRING([--disable-mpi-module],
                               [Do not use the Fortran MPI module, get interfaces by 'include "mpif.h')]),
761
                [],
762 763
                [enable_mpi_module=yes])
  if test x"${enable_mpi_module}" = x"yes" ; then
764 765 766 767 768 769 770 771 772 773 774 775 776 777 778
    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
779
      AC_MSG_ERROR([Could not compile a Fortran program with an 'use mpi' statement. You can try again with --disable-mpi-module])
780
    fi
781
  fi
Andreas Marek's avatar
Andreas Marek committed
782 783
fi

784 785 786 787
dnl default value
use_specific_real_kernel=no
use_specific_complex_kernel=no

788 789 790
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
791

792 793
dnl last check whether user wants to compile only a specific kernel
dnl
794
m4_include([m4/ax_elpa_specific_kernels.m4])
Andreas Marek's avatar
Andreas Marek committed
795

796
dnl real kernels
797
dnl do not remove this variable it is needed in the macros
798

799 800
dnl generic kernel
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-generic-kernel-only],[generic-kernel],[install_real_generic])
Andreas Marek's avatar
Andreas Marek committed
801

802 803
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
804

805
dnl sse kernel
806
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-sse-assembly-kernel-only],[sse-assembly-kernel],[install_real_sse_assembly])
Andreas Marek's avatar
Andreas Marek committed
807

808 809
dnl bgp kernel
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-bgp-kernel-only],[bgp-kernel],[install_real_bgp])
Andreas Marek's avatar
Andreas Marek committed
810

811 812
dnl bgq kernel
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-bgq-kernel-only],[bgq-kernel],[install_real_bgq])
Andreas Marek's avatar
Andreas Marek committed
813

814 815
dnl real-sse-block2 kernel
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-sse-block2-kernel-only],[real-sse-block2-kernel],[install_real_sse_block2])
816

817
dnl real-sse-block4 kernel
Andreas Marek's avatar
Andreas Marek committed
818
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-sse-block4-kernel-only],[real-sse-block4-kernel],[install_real_sse_block4])
819

820 821
dnl real-sse-block6 kernel
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-sse-block6-kernel-only],[real-sse-block6-kernel],[install_real_sse_block6])
822

823 824
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
825

826
dnl real-avx-block4 kernel
Andreas Marek's avatar
Andreas Marek committed
827
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-avx-block4-kernel-only],[real-avx-block4-kernel],[install_real_avx_block4])
828

829 830
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
831

832 833
dnl real-avx2-block2 kernel
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-avx2-block2-kernel-only],[real-avx2-block2-kernel],[install_real_avx2_block2])
834

835
dnl real-avx2-block4 kernel
Andreas Marek's avatar
Andreas Marek committed
836
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-avx2-block4-kernel-only],[real-avx2-block4-kernel],[install_real_avx2_block4])
837

838 839
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
840

Andreas Marek's avatar
Andreas Marek committed
841
dnl complex kernels
842

843 844
dnl generic kernel
DEFINE_OPTION_SPECIFIC_COMPLEX_KERNEL([complex-generic-kernel-only],[generic-kernel],[install_complex_generic])
Andreas Marek's avatar
Andreas Marek committed
845

846 847
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
848

849
dnl sse kernel
850
DEFINE_OPTION_SPECIFIC_COMPLEX_KERNEL([complex-sse-assembly-kernel-only],[sse-assembly-kernel],[install_complex_sse_assembly])
Andreas Marek's avatar
Andreas Marek committed
851

852 853
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
854

855 856
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
857

858 859
dnl complex-sse-block1 kernel
DEFINE_OPTION_SPECIFIC_COMPLEX_KERNEL([complex-sse-block1-kernel-only],[complex-sse-block1-kernel],[install_complex_sse_block1])
860

861 862
dnl complex-sse-block2 kernel
DEFINE_OPTION_SPECIFIC_COMPLEX_KERNEL([complex-sse-block2-kernel-only],[complex-sse-block2-kernel],[install_complex_sse_block2])
863

864 865
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
866

867 868
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
869

870 871
dnl complex-avx2-block1 kernel
DEFINE_OPTION_SPECIFIC_COMPLEX_KERNEL([complex-avx2-block1-kernel-only],[complex-avx2-block1-kernel],[install_complex_avx2_block1])
872

873 874
dnl complex-avx2-block2 kernel
DEFINE_OPTION_SPECIFIC_COMPLEX_KERNEL([complex-avx2-block2-kernel-only],[complex-avx2-block2-kernel],[install_complex_avx2_block2])
875 876


877
dnl set the conditionals according to the previous tests
878

879
if test x"${can_use_iso_fortran_env}" = x"yes" ; then
880 881 882
 AC_DEFINE([HAVE_ISO_FORTRAN_ENV],[1],[can use module iso_fortran_env])
fi

883 884 885
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])
886
fi
887

Andreas Marek's avatar
Andreas Marek committed
888
AM_CONDITIONAL([WITH_REAL_GENERIC_KERNEL],[test x"$install_real_generic" = x"yes"])
889
if test x"${install_real_generic}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
890 891 892 893
 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"])
894
if test x"${install_complex_generic}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
895 896 897 898
 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"])
899
if test x"${install_real_generic_simple}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
900 901 902 903
 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"])
904
if test x"${install_complex_generic_simple}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
905 906 907
 AC_DEFINE([WITH_COMPLEX_GENERIC_SIMPLE_KERNEL],[1],[can use complex generic-simple kernel])
fi

908 909 910
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
911 912
fi

913 914 915
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
916 917
fi

918 919 920 921 922 923 924 925 926 927 928 929 930 931 932
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
933
AM_CONDITIONAL([WITH_REAL_AVX_BLOCK2_KERNEL],[test x"$install_real_avx_block2" = x"yes"])
934
if test x"${install_real_avx_block2}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
935 936 937 938
 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"])
939
if test x"${install_real_avx_block4}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
940 941 942 943
 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"])
944
if test x"${install_real_avx_block6}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
945 946 947
 AC_DEFINE([WITH_REAL_AVX_BLOCK6_KERNEL],[1],[can use real_avx_block6 kernel])
fi

948 949 950 951 952 953 954 955 956 957 958 959 960 961 962
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

963 964 965 966 967 968 969 970 971 972
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
973
AM_CONDITIONAL([WITH_COMPLEX_AVX_BLOCK1_KERNEL],[test x"$install_complex_avx_block1" = x"yes"])
974
if test x"${install_complex_avx_block1}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
975 976 977 978
 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"])
979
if test x"${install_complex_avx_block2}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
980 981 982
 AC_DEFINE([WITH_COMPLEX_AVX_BLOCK2_KERNEL],[1],[can use complex_avx_block2 kernel])
fi

983 984 985 986 987 988 989 990 991 992
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

Andreas Marek's avatar
Andreas Marek committed
993
AM_CONDITIONAL([WITH_REAL_BGP_KERNEL],[test x"$install_real_bgp" = x"yes"])
994
if test x"${install_real_bgp}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
995 996 997 998
 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"])
999
if test x"${install_real_bgq}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
1000 1001 1002
 AC_DEFINE([WITH_REAL_BGQ_KERNEL],[1],[can use real BGQ kernel])
fi

1003
if test x"${use_specific_complex_kernel}" = x"no" ; then
1004
  AC_DEFINE([WITH_NO_SPECIFIC_COMPLEX_KERNEL],[1],[do not use only one specific complex kernel (set at compile time)])
1005
else
1006
  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
1007 1008
fi

1009
if test x"${use_specific_real_kernel}" = x"no" ; then
1010
  AC_DEFINE([WITH_NO_SPECIFIC_REAL_KERNEL],[1],[do not use only one specific real kernel (set at compile time)])
1011 1012
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
1013 1014
fi

1015 1016
LT_INIT

1017 1018 1019 1020 1021 1022
DX_PDF_FEATURE(OFF)
DX_PS_FEATURE(OFF)
DX_MAN_FEATURE(ON)
DX_HTML_FEATURE(ON)
DX_INIT_DOXYGEN([ELPA], [Doxyfile], [docs])

1023
USE_ASSUMED_SIZE=yes
Andreas Marek's avatar
Andreas Marek committed
1024
AC_MSG_CHECKING(whether assumed size Fortran arrays should be used)
1025
AC_ARG_ENABLE([assumed-size],
1026 1027
                AS_HELP_STRING([--disable-assumed-size],
			       [do NOT use assumed-size Fortran arrays]),
Andreas Marek's avatar
Andreas Marek committed
1028 1029 1030 1031 1032
			       [if test x"$enableval" = x"yes"; then
                                  USE_ASSUMED_SIZE=yes
				else
			          USE_ASSUMED_SIZE=no
				fi],
1033
              [USE_ASSUMED_SIZE=yes])
1034 1035 1036
AC_MSG_RESULT([${USE_ASSUMED_SIZE}])
AM_CONDITIONAL([WITH_USE_ASSUMED_SIZE],[test x"$USE_ASSUMED_SIZE" = x"yes"])
if test x"${USE_ASSUMED_SIZE}" = x"yes" ; then
1037
  AC_DEFINE([USE_ASSUMED_SIZE],[1],[for performance reasons use assumed size Fortran arrays, even if not debuggable])
1038 1039
fi

1040 1041 1042
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])
1043
fi
1044 1045
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"])
1046

1047
AC_SUBST([MPI_BINARY])
1048 1049 1050 1051 1052
AC_SUBST([WITH_MKL])
AC_SUBST([WITH_BLACS])
AC_SUBST([with_amd_bulldozer_kernel])
AC_SUBST([FC_MODINC])
AC_SUBST([FC_MODOUT])
1053 1054 1055
AC_SUBST([OPENMP_CFLAGS])
AC_SUBST([OPENMP_FCFLAGS])
AC_SUBST([OPENMP_LDFLAGS])
1056
AC_SUBST([DOXYGEN_OUTPUT_DIR], [docs])
1057

1058 1059
rm -rf modules/ private_modules/ .fortran_dependencies/
mkdir modules private_modules
1060 1061 1062 1063 1064 1065 1066 1067 1068 1069

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

1070 1071 1072 1073 1074 1075 1076 1077 1078

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

1080 1081
if test x"${with_mpi}" = x"yes"; then
  if test x"${enable_openmp}" = x"yes"; then
1082
	SUFFIX="_openmp"
1083
  else
1084
	SUFFIX=""
1085 1086 1087
  fi
else
  if test x"${enable_openmp}" = x"yes"; then
Lorenz Huedepohl's avatar
Typo  
Lorenz Huedepohl committed
1088
	SUFFIX="_onenode_openmp"
1089 1090 1091
  else
	SUFFIX="_onenode"
  fi
1092
fi
1093

1094 1095
AC_SUBST([SUFFIX])
AC_SUBST([PKG_CONFIG_FILE],[elpa${SUFFIX}-${PACKAGE_VERSION}.pc])
1096

1097 1098
AC_CONFIG_FILES([
  Makefile
1099
  Doxyfile
1100
  ${PKG_CONFIG_FILE}:elpa.pc.in
1101
])
1102

1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116
AC_MSG_CHECKING([if workaround for Intel's broken preprocessor is needed])
if test x"$FC" = x"mpiifort" ; then
	need_manual_cpp=yes
fi
if test x"$FC" = x"ifort" ; then
	need_manual_cpp=yes
fi
if test x"$need_manual_cpp" = x"yes" ; then
	AC_MSG_RESULT([yes])
	FC="\$(top_srcdir)/manual_cpp $FC"
else
	AC_MSG_RESULT([no])
fi

1117
AC_OUTPUT
1118

1119
if test "${can_compile_avx}" = "no" ; then
1120
#  if test x"${want_avx}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
1121
    AC_MSG_WARN([Could not compile AVX instructions])
1122
#  fi
1123
fi
1124
if test "${can_compile_avx2}" = "no" ; then
1125
#  if test x"${want_avx2}" = x"yes" ; then
1126
    AC_MSG_WARN([Could not compile AVX2 instructions])
1127
#  fi
1128
fi
1129 1130 1131 1132

if test "${can_compile_sse}" = "no" ; then
  AC_MSG_WARN([Could not compile SSE instructions])
fi
1133 1134 1135 1136 1137 1138 1139
echo " "
echo "***********************************************************************"
echo "*  This is a prerelease of the ELPA library 2016.11.001.pre library!  *"
echo "*  It contains an experimental API which will most likely change with *"
echo "*  the next stable release.                                           *"
echo "***********************************************************************"
echo " "
1140
make -f $srcdir/generated_headers.am generated-headers top_srcdir="$srcdir"