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

3
AC_INIT([elpa],[2015.11.001], [elpa-library@mpcdf.mpg.de])
4
AC_SUBST([PACKAGE_VERSION])
5

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

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

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

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

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

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

40

41 42 43 44 45
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
46 47 48 49
#AC_CHECK_PROG(CPP_FOUND,cpp,yes,no)
#if test x"${CPP_FOUND}" = xno; then
#  AC_MSG_ERROR([no cpp found])
#fi
50 51 52 53 54

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

55 56
###

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

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

71 72 73 74 75 76 77 78 79 80 81 82
AC_MSG_CHECKING(whether --enable-shared-memory-only is specified)
AC_ARG_ENABLE([shared-memory-only],
		AS_HELP_STRING([--enable-shared-memory-only],
			       [do not use MPI; ELPA will be build for one node shared-memory runs only]),
	      [],
	      [enable_shared_memory_only=no])
AC_MSG_RESULT([${enable_shared_memory_only}])
AM_CONDITIONAL([WITH_MPI],[test x"$enable_shared_memory_only" = x"no"])
if test x"${enable_shared_memory_only}" = x"no"; then
	AC_DEFINE([WITH_MPI], [1], [use MPI])
fi

Andreas Marek's avatar
Andreas Marek committed
83 84 85
dnl check whether mpi compilers are available;
dnl if not abort since it is mandatory

86

Andreas Marek's avatar
Andreas Marek committed
87 88
# C
AC_LANG([C])
89 90
AX_PROG_CC_MPI([test x"$enable_shared_memory_only" = xno],[use_mpi=yes],[use_mpi=no])

91
if test x"${enable_openmp}" = x"yes"; then
92 93 94 95 96
  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"
97
fi
98

99
AC_PROG_INSTALL
100 101
AM_PROG_AR
AM_PROG_AS
Andreas Marek's avatar
Andreas Marek committed
102 103

# Fortran
104 105 106 107 108 109 110 111

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
112 113
AC_LANG([Fortran])
m4_include([m4/ax_prog_fc_mpi.m4])
114
AX_PROG_FC_MPI([test x"$enable_shared_memory_only" = xno],[use_mpi=yes],[use_mpi=no])
115
if test x"${enable_openmp}" = x"yes"; then
116 117 118 119 120
  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"
121 122
fi

Andreas Marek's avatar
Andreas Marek committed
123 124 125 126 127 128 129 130 131 132 133
## 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
134 135 136



Andreas Marek's avatar
Andreas Marek committed
137 138
dnl variables needed for the tests

Andreas Marek's avatar
Andreas Marek committed
139 140 141 142 143 144 145 146
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
147 148 149 150 151 152

install_real_generic=yes
install_real_generic_simple=yes

install_complex_generic=yes
install_complex_generic_simple=yes
153

154 155 156 157
#want_avx=yes
#want_avx2=yes
#want_sse=yes

Andreas Marek's avatar
Andreas Marek committed
158 159
AC_LANG([C])

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

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

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

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

205
AC_MSG_CHECKING(whether double-precision SSE assembler kernel can be compiled)
Andreas Marek's avatar
Andreas Marek committed
206

207
$CC -c $srcdir/src/elpa2_kernels/elpa2_kernels_asm_x86_64_double_precision.s -o test.o 2>/dev/null
208
if test "$?" == 0; then
Andreas Marek's avatar
Andreas Marek committed
209 210
  can_compile_sse=yes
  install_real_sse=yes
211 212 213 214
  install_real_sse_block2=yes
  install_real_sse_block4=yes
  install_real_sse_block6=yes

Andreas Marek's avatar
Andreas Marek committed
215
  install_complex_sse=yes
216 217 218
  install_complex_sse_block1=yes
  install_complex_sse_block2=yes

219
else
Andreas Marek's avatar
Andreas Marek committed
220 221
  can_compile_sse=no
  install_real_sse=no
222 223 224 225
  install_real_sse_block2=no
  install_real_sse_block4=no
  install_real_sse_block6=no

Andreas Marek's avatar
Andreas Marek committed
226
  install_complex_sse=no
227 228
  install_complex_sse_block1=no
  install_complex_sse_block2=no
229
fi
230

231
rm -f ./test.o
Andreas Marek's avatar
Andreas Marek committed
232
AC_MSG_RESULT([${can_compile_sse}])
233

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

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

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

256
dnl first pass: try with specified CFLAGS and CXXFLAGS
257
AC_MSG_CHECKING([whether we can compile AVX intrinsics in C])
258 259
AC_COMPILE_IFELSE([AC_LANG_SOURCE([
 #include <x86intrin.h>
260
 int main(int argc, char **argv){
261 262
 double* q;
 __m256d a1_1 = _mm256_load_pd(q);
263
 return 0;
264 265 266 267 268
 }
 ])],
 [can_compile_avx=yes],
 [can_compile_avx=no]
)
Andreas Marek's avatar
Andreas Marek committed
269
AC_MSG_RESULT([${can_compile_avx}])
270

Andreas Marek's avatar
Andreas Marek committed
271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290
#if test "${can_compile_avx}" = "yes" ; then
#  AC_MSG_CHECKING([whether we can compile AVX intrinsics in C++])
#  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
291

292 293 294 295 296 297 298 299 300 301 302 303 304 305
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}])
Andreas Marek's avatar
Andreas Marek committed
306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326
#if test "${can_compile_avx2}" = "yes" ; then
#  AC_MSG_CHECKING([whether we can compile AVX2 intrinsics in C++])
#  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
327

328
if test "${can_compile_avx}" = "yes" ; then
Andreas Marek's avatar
Andreas Marek committed
329 330 331 332 333 334
  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
335 336 337 338 339 340 341
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
342 343
fi

344 345 346 347
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
348

349 350 351 352 353 354 355 356 357 358
  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
359 360 361 362 363 364 365 366 367 368 369
AM_CONDITIONAL([HAVE_SSE],[test x"$can_compile_sse" = x"yes"])
if test x"${can_compile_sse}" = x"yes" ; then
  AC_DEFINE([HAVE_SSE],[1],[SSE is supported on this CPU])
fi
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])
370 371 372 373 374 375 376 377 378
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
379
AC_MSG_RESULT([${with_avx_optimization}])
380
if test x"${with_avx_optimization}" = x"yes"; then
Andreas Marek's avatar
Andreas Marek committed
381 382 383
 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
384

385
AC_LANG([Fortran])
386 387 388
AC_FC_FREEFORM
AC_FC_MODULE_FLAG
AC_FC_MODULE_OUTPUT_FLAG
389
AC_FC_LIBRARY_LDFLAGS
390 391 392 393

save_FCFLAGS=$FCFLAGS
save_LDFLAGS=$LDFLAGS

394 395 396
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])

397 398
FCFLAGS="$FCFLAGS $SCALAPACK_FCFLAGS"
LDFLAGS="$LDFLAGS $SCALAPACK_LDFLAGS"
399

400
dnl check whether fortran error_unit is defined
401
AC_MSG_CHECKING([whether Fortran module iso_fortran_env is available])
402
AC_COMPILE_IFELSE([AC_LANG_SOURCE([
403 404 405 406 407 408 409 410 411 412
  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]
)
413
AC_MSG_RESULT([${can_use_iso_fortran_env}])
414

415 416 417 418
dnl check whether one can link with specified MKL (desired method)
AC_MSG_CHECKING([whether we can compile a Fortran program using MKL])


419
AC_COMPILE_IFELSE([AC_LANG_SOURCE([
420
  program test_mkl
421
    use mkl_service
422 423 424 425 426 427 428 429 430 431 432 433
    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])
434
  AC_LINK_IFELSE([AC_LANG_SOURCE([
435
    program test_mkl
436
      use mkl_service
437 438 439 440 441
      character*198 :: string
      call mkl_get_version_string(string)
      write(*,'(a)') string
    end program
  ])],
Andreas Marek's avatar
Andreas Marek committed
442 443
    [have_mkl=yes],
    [have_mkl=no]
444
  )
Andreas Marek's avatar
Andreas Marek committed
445
  AC_MSG_RESULT([${have_mkl}])
446 447 448
fi

dnl if not mkl, check all the necessary individually
449
if test x"${have_mkl}" = x"yes" ; then
450 451 452 453
  WITH_MKL=1
else

  dnl first check blas
Andreas Marek's avatar
Andreas Marek committed
454 455 456
  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}])
457

458
  if test x"${have_blas}" = x"no" ; then
459
    AC_MSG_ERROR([could not link with blas: specify path])
460
  fi
461
  dnl now lapack
Andreas Marek's avatar
Andreas Marek committed
462 463 464
  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}])
465

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

470 471 472 473 474 475 476 477 478 479 480 481 482
  if test x"${enable_shared_memory_only}" = x"no"; then
    dnl test whether scalapack already contains blacs
    scalapack_libs="mpiscalapack scalapack"
    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
483

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

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

491 492 493
      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
494
    fi
495

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

498 499 500
    if test x"${have_scalapack}" = x"no" ; then
      AC_MSG_ERROR([could not link with scalapack: specify path])
    fi
501 502 503 504
  fi

  dnl check whether we can link alltogehter
  AC_MSG_CHECKING([whether we can link a Fortran program with all blacs/scalapack])
505
  AC_LINK_IFELSE([AC_LANG_SOURCE([
506 507
    program dgemm_test

508 509
      integer , parameter:: M = 4, N = 3, K = 2
      real :: A(M,K), B(K,N), C(M,N)
510

511
      call dgemm('N','N',M,N,K,1.0,A,M,B,K,0.0,C,M)
512 513 514 515 516 517 518 519

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

520
   if test x"${can_link_with_blacs_scalapack}" = x"yes" ; then
521 522
     WITH_BLACS=1
   else
523
   AC_MSG_ERROR([We can neither link with MKL or another Scalpack. Please specify SCALAPACK_LDFLAGS and SCALAPACK_FCFLAGS!])
524 525 526
   fi
fi

527 528 529 530
dnl important: reset them again!
FCFLAGS=$save_FCFLAGS
LDFLAGS=$save_LDFLAGS

Andreas Marek's avatar
Andreas Marek committed
531 532 533 534
dnl check for intrinsic fortran function of 2003 standard
AC_MSG_CHECKING([whether we can use the intrinsic Fortran function "get_environment_variable"])


535
AC_COMPILE_IFELSE([AC_LANG_SOURCE([
Andreas Marek's avatar
Andreas Marek committed
536 537 538 539 540 541 542 543 544 545
  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}])

546 547
dnl check whether GPU version is requested

548
#CUDA_INSTALL_PATH="/usr/local/cuda/"
549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566
#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])
567
  CUDA_CFLAGS="$CUDA_CFLAGS -arch sm_35 -O2 -I$CUDA_INSTALL_PATH/include"
568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590
  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
591
  can_compile_gpu=yes
592 593
fi

Andreas Marek's avatar
Andreas Marek committed
594 595 596 597 598 599 600 601
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])

602
AC_LINK_IFELSE([AC_LANG_SOURCE([
Andreas Marek's avatar
Andreas Marek committed
603 604 605
  program test_bgp
    complex*16 :: y3,q3,h2
    y3 = fxcpmadd(y3,q3,h2)
606

Andreas Marek's avatar
Andreas Marek committed
607 608 609 610 611 612 613
  end program
])],
  [can_compile_bgp=yes],
  [can_compile_bgp=no]
)
AC_MSG_RESULT([${can_compile_bgp}])

614
if test x"${can_compile_bgp}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
615 616
  install_real_bgp=yes
  install_complex_bgp=yes
Andreas Marek's avatar
Andreas Marek committed
617 618 619
else
  install_real_bgp=no
  install_complex_bgp=no
Andreas Marek's avatar
Andreas Marek committed
620 621 622 623 624
fi

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

625
AC_LINK_IFELSE([AC_LANG_SOURCE([
Andreas Marek's avatar
Andreas Marek committed
626
  program test_bgq
Andreas Marek's avatar
Andreas Marek committed
627 628
    VECTOR(REAL(8))::QPX_h2
    real*8         :: hh(10,2)
Andreas Marek's avatar
Andreas Marek committed
629
    QPX_h2 = VEC_SPLATS(hh(2,2))
630

Andreas Marek's avatar
Andreas Marek committed
631 632 633 634 635 636 637
  end program
])],
  [can_compile_bgq=yes],
  [can_compile_bgq=no]
)
AC_MSG_RESULT([${can_compile_bgq}])

638
if test x"${can_compile_bgq}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
639 640
  install_real_bgq=yes
  install_complex_bgq=yes
Andreas Marek's avatar
Andreas Marek committed
641 642 643
else
  install_real_bgq=no
  install_complex_bgq=no
Andreas Marek's avatar
Andreas Marek committed
644 645 646 647
fi


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

652 653 654 655
dnl default value
use_specific_real_kernel=no
use_specific_complex_kernel=no

656 657 658
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
659

660 661
dnl last check whether user wants to compile only a specific kernel
dnl
662
m4_include([m4/ax_elpa_specific_kernels.m4])
Andreas Marek's avatar
Andreas Marek committed
663

664
dnl real kernels
665
dnl do not remove this variable it is needed in the macros
666

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

670 671
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
672

673 674
dnl sse kernel
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-sse-kernel-only],[sse-kernel],[install_real_sse])
Andreas Marek's avatar
Andreas Marek committed
675

676 677
dnl bgp kernel
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-bgp-kernel-only],[bgp-kernel],[install_real_bgp])
Andreas Marek's avatar
Andreas Marek committed
678

679 680
dnl bgq kernel
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-bgq-kernel-only],[bgq-kernel],[install_real_bgq])
Andreas Marek's avatar
Andreas Marek committed
681

682 683
dnl real-sse-block2 kernel
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-sse-block2-kernel-only],[real-sse-block2-kernel],[install_real_sse_block2])
684

685 686
dnl real-sse-block4 kernel
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-sse-block4-kernel]-only,[real-sse-block4-kernel],[install_real_sse_block4])
687

688 689
dnl real-sse-block6 kernel
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-sse-block6-kernel-only],[real-sse-block6-kernel],[install_real_sse_block6])
690

691 692
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
693

694 695
dnl real-avx-block4 kernel
DEFINE_OPTION_SPECIFIC_REAL_KERNEL([real-avx-block4-kernel]-only,[real-avx-block4-kernel],[install_real_avx_block4])
696

697 698
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
699 700

dnl complex kernels
701

702 703
dnl generic kernel
DEFINE_OPTION_SPECIFIC_COMPLEX_KERNEL([complex-generic-kernel-only],[generic-kernel],[install_complex_generic])
Andreas Marek's avatar
Andreas Marek committed
704

705 706
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
707

708 709
dnl sse kernel
DEFINE_OPTION_SPECIFIC_COMPLEX_KERNEL([complex-sse-kernel-only],[sse-kernel],[install_complex_sse])
Andreas Marek's avatar
Andreas Marek committed
710

711 712
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
713

714 715
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
716

717 718
dnl complex-sse-block1 kernel
DEFINE_OPTION_SPECIFIC_COMPLEX_KERNEL([complex-sse-block1-kernel-only],[complex-sse-block1-kernel],[install_complex_sse_block1])
719

720 721
dnl complex-sse-block2 kernel
DEFINE_OPTION_SPECIFIC_COMPLEX_KERNEL([complex-sse-block2-kernel-only],[complex-sse-block2-kernel],[install_complex_sse_block2])
722

723 724
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
725

726 727
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
728

729
dnl set the conditionals according to the previous tests
730

731
if test x"${can_use_iso_fortran_env}" = x"yes" ; then
732 733 734
 AC_DEFINE([HAVE_ISO_FORTRAN_ENV],[1],[can use module iso_fortran_env])
fi

735 736 737
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])
738
fi
739

Andreas Marek's avatar
Andreas Marek committed
740
AM_CONDITIONAL([WITH_REAL_GENERIC_KERNEL],[test x"$install_real_generic" = x"yes"])
741
if test x"${install_real_generic}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
742 743 744 745
 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"])
746
if test x"${install_complex_generic}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
747 748 749 750
 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"])
751
if test x"${install_real_generic_simple}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
752 753 754 755
 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"])
756
if test x"${install_complex_generic_simple}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
757 758 759 760
 AC_DEFINE([WITH_COMPLEX_GENERIC_SIMPLE_KERNEL],[1],[can use complex generic-simple kernel])
fi

AM_CONDITIONAL([WITH_REAL_SSE_KERNEL],[test x"$install_real_sse" = x"yes"])
761
if test x"${install_real_sse}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
762 763 764 765
 AC_DEFINE([WITH_REAL_SSE_KERNEL],[1],[can use real SSE kernel])
fi

AM_CONDITIONAL([WITH_COMPLEX_SSE_KERNEL],[test x"$install_complex_sse" = x"yes"])
766
if test x"${install_complex_sse}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
767 768 769
 AC_DEFINE([WITH_COMPLEX_SSE_KERNEL],[1],[can use complex SSE kernel])
fi

770 771 772 773 774 775 776 777 778 779 780 781 782 783 784
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
785
AM_CONDITIONAL([WITH_REAL_AVX_BLOCK2_KERNEL],[test x"$install_real_avx_block2" = x"yes"])
786
if test x"${install_real_avx_block2}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
787 788 789 790
 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"])
791
if test x"${install_real_avx_block4}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
792 793 794 795
 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"])
796
if test x"${install_real_avx_block6}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
797 798 799
 AC_DEFINE([WITH_REAL_AVX_BLOCK6_KERNEL],[1],[can use real_avx_block6 kernel])
fi

800 801 802 803 804 805 806 807 808 809 810 811 812 813 814
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

815 816 817 818 819 820 821 822 823 824
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
825
AM_CONDITIONAL([WITH_COMPLEX_AVX_BLOCK1_KERNEL],[test x"$install_complex_avx_block1" = x"yes"])
826
if test x"${install_complex_avx_block1}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
827 828 829 830
 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"])
831
if test x"${install_complex_avx_block2}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
832 833 834
 AC_DEFINE([WITH_COMPLEX_AVX_BLOCK2_KERNEL],[1],[can use complex_avx_block2 kernel])
fi

835 836 837 838 839 840 841 842 843 844
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
845
AM_CONDITIONAL([WITH_REAL_BGP_KERNEL],[test x"$install_real_bgp" = x"yes"])
846
if test x"${install_real_bgp}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
847 848 849 850
 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"])
851
if test x"${install_real_bgq}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
852 853 854
 AC_DEFINE([WITH_REAL_BGQ_KERNEL],[1],[can use real BGQ kernel])
fi

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

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

863 864
LT_INIT

865 866 867 868 869 870
DX_PDF_FEATURE(OFF)
DX_PS_FEATURE(OFF)
DX_MAN_FEATURE(ON)
DX_HTML_FEATURE(ON)
DX_INIT_DOXYGEN([ELPA], [Doxyfile], [docs])

871
DESPERATELY_WANT_ASSUMED_SIZE=0
872
if test x"${DESPERATELY_WANT_ASSUMED_SIZE}" = x"yes" ; then
873 874 875
  AC_DEFINE([DESPERATELY_WANT_ASSUMED_SIZE],[1],[use assumed size arrays, even if not debuggable])
fi

876 877 878
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])
879
fi
880 881
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"])
882

883 884 885 886 887
AC_SUBST([WITH_MKL])
AC_SUBST([WITH_BLACS])
AC_SUBST([with_amd_bulldozer_kernel])
AC_SUBST([FC_MODINC])
AC_SUBST([FC_MODOUT])
888 889 890
AC_SUBST([OPENMP_CFLAGS])
AC_SUBST([OPENMP_FCFLAGS])
AC_SUBST([OPENMP_LDFLAGS])
891
#AC_SUBST(OPT_FCFLAGS)
892
AC_SUBST([DOXYGEN_OUTPUT_DIR], [docs])
893

894
rm -rf modules/ .fortran_dependencies/
895 896 897 898 899 900 901 902 903 904 905
mkdir modules

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

906 907 908 909 910 911 912 913 914

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

916
if test x"${enable_openmp}" = x"yes"; then
917
	SUFFIX="_openmp"
918
else
919
	SUFFIX=""
920
fi
921 922
AC_SUBST([SUFFIX])
AC_SUBST([PKG_CONFIG_FILE],[elpa${SUFFIX}-${PACKAGE_VERSION}.pc])
923

924 925
AC_CONFIG_FILES([
  Makefile
926
  Doxyfile
927
  ${PKG_CONFIG_FILE}:elpa.pc.in
928
])
929

930
AC_OUTPUT
931 932 933 934 935 936


if test -e config.h ; then
  grep "^#define" config.h > config-f90.h
else
  echo "Warning! No config.h was generated, check for errors and re-run configure!"
Andreas Marek's avatar
Andreas Marek committed
937
  exit 1
938
fi
Andreas Marek's avatar
Andreas Marek committed
939 940 941

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

944 945
echo "Generating Fortran interfaces for C kernels"
grep -h "^ *!f>" $srcdir/src/elpa2_kernels/*.c | sed 's/^ *!f>//;' > elpa/elpa_generated_fortran_interfaces.h || exit 1
Andreas Marek's avatar
Andreas Marek committed
946
#grep -h "^ *!f>" $srcdir/src/elpa2_kernels/*.cpp | sed 's/^ *!f>//;' >> elpa/elpa_generated_fortran_interfaces.h || exit 1
947

948 949 950
echo "Generating test/shared_sources/generated.h..."
mkdir -p test/shared_sources
grep -h "^ *!c>" $srcdir/test/shared_sources/*.F90 | sed 's/^ *!c>//;' > test/shared_sources/generated.h || exit 1
Andreas Marek's avatar
Andreas Marek committed
951

952
if test "${can_compile_avx}" = "no" ; then
953
#  if test x"${want_avx}" = x"yes" ; then
Andreas Marek's avatar
Andreas Marek committed
954
    AC_MSG_WARN([Could not compile AVX instructions])
955
#  fi
956
fi
957
if test "${can_compile_avx2}" = "no" ; then
958
#  if test x"${want_avx2}" = x"yes" ; then
959
    AC_MSG_WARN([Could not compile AVX2 instructions])
960
#  fi
961
fi
962 963 964 965

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