configure.ac 33.7 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
AC_CONFIG_SRCDIR([src/elpa.F90])
8 9

AM_INIT_AUTOMAKE([foreign -Wall subdir-objects])
10

11 12 13 14
AC_CONFIG_MACRO_DIR([m4])
AC_CONFIG_HEADERS([config.h])
AM_SILENT_RULES([yes])

15 16
# ABI version
#
17 18 19 20 21 22 23 24 25 26 27 28 29
# 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)
#
30
AC_SUBST([ELPA_SO_VERSION], [8:0:0])
31 32 33 34

# API Version
AC_DEFINE([EARLIEST_API_VERSION], [20170403], [Earliest supported ELPA API version])
AC_DEFINE([CURRENT_API_VERSION], [20170403], [Current ELPA API version])
35

36

37 38 39 40 41
AX_CHECK_GNU_MAKE()
if test x$_cv_gnu_make_command = x ; then
        AC_MSG_ERROR([Need GNU Make])
fi

42 43 44 45 46 47
AC_ARG_ENABLE([legacy],
              AS_HELP_STRING([--disable-legacy],
                             [do not build legacy API, default yes]),
              [],
              [enable_legacy=yes])
AM_CONDITIONAL([ENABLE_LEGACY],[test x"$enable_legacy" = x"yes"])
48 49 50 51 52

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

53 54
###

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

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

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

Andreas Marek's avatar
Andreas Marek committed
76
# C
77
AC_LANG_PUSH([C])
78 79 80 81 82 83
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
84

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

93
AC_PROG_INSTALL
94 95
AM_PROG_AR
AM_PROG_AS
96
AC_PROG_CC_C99
97
AM_PROG_CC_C_O
98
AC_LANG_POP([C])
Andreas Marek's avatar
Andreas Marek committed
99 100

# Fortran
101
AC_LANG_PUSH([Fortran])
Andreas Marek's avatar
Andreas Marek committed
102
m4_include([m4/ax_prog_fc_mpi.m4])
103 104 105 106 107 108
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
109

110
AC_FC_SRCEXT([F90])
111 112 113 114 115
AC_FC_FREEFORM
AC_FC_MODULE_FLAG
AC_FC_MODULE_OUTPUT_FLAG
AC_FC_LIBRARY_LDFLAGS

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], [srun mpiexec.hydra mpiexec mpirun poe runjob], [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

133 134 135
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)
136
AC_ARG_ENABLE([redirect],
137 138 139 140
              [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])
141 142
AC_MSG_RESULT([${enable_redirect}])

143 144 145 146 147 148 149 150 151 152
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="$enableval"],
              [want_single_precision="no"])
AC_MSG_RESULT([${want_single_precision}])


153 154
dnl redirect
if test x"${enable_redirect}" = x"yes"; then
155 156
  AC_DEFINE([HAVE_REDIRECT], [1], [Redirect stdout and stderr of test programs per MPI tasks to a file])
fi
157 158 159 160
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
161
AC_ARG_ENABLE([timings],
162 163 164 165
              [AS_HELP_STRING([--enable-timings],
                              [more detailed timing, default no.])],
              [enable_timings="$enableval"],
              [enable_timings=no])
166 167 168 169 170
AC_MSG_RESULT([${enable_timings}])

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

dnl PAPI for ftimings
AC_ARG_WITH([papi],
175 176 177 178
            [AS_HELP_STRING([--with-papi],
                            [Use PAPI to also measure flop count in the detailed timing (--enable-timing), disabled by default])],
            [],
            [with_papi="no"])
179 180
if test x"${enable_timings}" = x"yes"; then
  if test x"$with_papi" = x"yes" ; then
181
    AC_SEARCH_LIBS([PAPI_library_init], [papi], [papi_found=yes], [papi_found=no])
182 183
    if test x"$papi_found" = x"no" ; then
      AC_MSG_ERROR(["Could not find usable PAPI installation, please install or adjust CFLAGS, LDFLAGS"])
184 185 186 187 188
    fi
    AC_DEFINE([HAVE_LIBPAPI], [1], [Use the PAPI library])
  fi
fi

189 190 191
save_FCFLAGS=$FCFLAGS
save_LDFLAGS=$LDFLAGS

192 193 194
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])

195 196
FCFLAGS="$FCFLAGS $SCALAPACK_FCFLAGS"
LDFLAGS="$LDFLAGS $SCALAPACK_LDFLAGS"
197

198
dnl check whether fortran error_unit is defined
199
AC_MSG_CHECKING([whether Fortran module iso_fortran_env is available])
200
AC_COMPILE_IFELSE([AC_LANG_SOURCE([
201
  program test_error_unit
202
    use iso_fortran_env, only : error_unit
203 204 205 206 207 208 209 210
    implicit none

    write(error_unit,*) "error_unit is defined"
  end program
])],
  [can_use_iso_fortran_env=yes],
  [can_use_iso_fortran_env=no]
)
211
AC_MSG_RESULT([${can_use_iso_fortran_env}])
212 213 214 215
if test x"${can_use_iso_fortran_env}" = x"yes" ; then
 AC_DEFINE([HAVE_ISO_FORTRAN_ENV],[1],[can use module iso_fortran_env])
fi

216

217 218
dnl check whether one can link with specified MKL (desired method)
AC_MSG_CHECKING([whether we can compile a Fortran program using MKL])
219
AC_COMPILE_IFELSE([AC_LANG_SOURCE([
220
  program test_mkl
221
    use mkl_service
222 223 224 225 226 227 228 229 230 231 232 233
    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])
234
  AC_LINK_IFELSE([AC_LANG_SOURCE([
235
    program test_mkl
236
      use mkl_service
237 238 239 240 241
      character*198 :: string
      call mkl_get_version_string(string)
      write(*,'(a)') string
    end program
  ])],
Andreas Marek's avatar
Andreas Marek committed
242 243
    [have_mkl=yes],
    [have_mkl=no]
244
  )
Andreas Marek's avatar
Andreas Marek committed
245
  AC_MSG_RESULT([${have_mkl}])
246 247 248
fi

dnl if not mkl, check all the necessary individually
249
if test x"${have_mkl}" = x"yes" ; then
250 251 252 253
  WITH_MKL=1
else

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

258
  if test x"${have_blas}" = x"no" ; then
259
    AC_MSG_ERROR([could not link with blas: specify path])
260
  fi
261
  dnl now lapack
Andreas Marek's avatar
Andreas Marek committed
262 263 264
  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}])
265

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

270
  if test x"${with_mpi}" = x"yes"; then
271
    dnl test whether scalapack already contains blacs
272
    scalapack_libs="mpiscalapack scalapack scalapack-openmpi"
273 274 275 276 277 278 279 280 281 282
    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
283

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

287 288
      dnl Test for stand-alone blacs
      AC_SEARCH_LIBS([bi_f77_init],[mpiblacsF77init],[],[],[-lmpiblacs])
289 290 291 292 293 294

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

297 298 299
      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
300
    fi
301

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

304 305 306
    if test x"${have_scalapack}" = x"no" ; then
      AC_MSG_ERROR([could not link with scalapack: specify path])
    fi
307 308 309 310
  fi

  dnl check whether we can link alltogehter
  AC_MSG_CHECKING([whether we can link a Fortran program with all blacs/scalapack])
311
  AC_LINK_IFELSE([AC_LANG_SOURCE([
312 313
    program dgemm_test

314 315
      integer , parameter:: M = 4, N = 3, K = 2
      real :: A(M,K), B(K,N), C(M,N)
316

317
      call dgemm('N','N',M,N,K,1.0,A,M,B,K,0.0,C,M)
318 319 320 321 322 323 324 325

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

326
   if test x"${can_link_with_blacs_scalapack}" = x"yes" ; then
327 328
     WITH_BLACS=1
   else
329
   AC_MSG_ERROR([We can neither link with MKL or another Scalpack. Please specify SCALAPACK_LDFLAGS and SCALAPACK_FCFLAGS!])
330 331 332
   fi
fi

333 334 335 336
dnl important: reset them again!
FCFLAGS=$save_FCFLAGS
LDFLAGS=$save_LDFLAGS

337

Andreas Marek's avatar
Andreas Marek committed
338 339 340 341
dnl check for intrinsic fortran function of 2003 standard
AC_MSG_CHECKING([whether we can use the intrinsic Fortran function "get_environment_variable"])


342
AC_COMPILE_IFELSE([AC_LANG_SOURCE([
Andreas Marek's avatar
Andreas Marek committed
343 344 345 346 347 348 349 350 351
  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}])
352 353 354
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
355

356

357 358
dnl check whether BAND_TO_FULL_BLOCKING is set
AC_MSG_CHECKING(whether BAND_TO_FLULL_BLOCKING is requested)
359
AC_ARG_ENABLE(band-to-full-blocking,[AS_HELP_STRING([--disable-band-to-full-blocking],
360
                                                    [build ELPA2 with blocking in band_to_full (default: enabled)])],
361 362 363
              [],
	      [enable_band_to_full_blocking="yes"])
AC_MSG_RESULT([${enable_band_to_full_blocking}])
364

365 366
AM_CONDITIONAL([BAND_TO_FULL_BLOCKING],[test x"$enable_band_to_full_blocking" = x"yes"])
if test x"${enable_band_to_full_blocking}" = x"yes"; then
367
       AC_DEFINE([BAND_TO_FULL_BLOCKING], [1], [use blocking in trans_ev_band_to_full])
368 369
fi

370 371 372 373 374 375 376

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

377

378
dnl setup nvcc flags and use them in later tests
379 380 381
user_sets_gpu_compute_capability="no"
AC_MSG_CHECKING(whether a GPU compute capability is specified)
AC_ARG_WITH([GPU-compute-capability],
382 383 384
            [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"])
385 386
AC_MSG_RESULT([${user_sets_gpu_compute_capability}])

387

388 389 390 391 392 393 394 395 396 397 398
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

Andreas Marek's avatar
Andreas Marek committed
399

400 401
dnl Test possibility of 'use mpi', if requested
if test x"${with_mpi}" = x"yes" ; then
402 403
  AC_ARG_ENABLE([mpi-module],
                AS_HELP_STRING([--disable-mpi-module],
404
                               [do not use the Fortran MPI module, get interfaces by 'include "mpif.h')]),
405
                [],
406 407
                [enable_mpi_module=yes])
  if test x"${enable_mpi_module}" = x"yes" ; then
408 409 410 411 412 413 414 415 416 417 418 419 420 421 422
    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
423
      AC_MSG_ERROR([Could not compile a Fortran program with an 'use mpi' statement. You can try again with --disable-mpi-module])
424
    fi
425
  fi
Andreas Marek's avatar
Andreas Marek committed
426
fi
427
AC_LANG_POP([Fortran])
Andreas Marek's avatar
Andreas Marek committed
428

429 430
dnl Assemble the list of kernels to build
m4_pattern_forbid([elpa_m4])
Andreas Marek's avatar
Andreas Marek committed
431

432 433 434 435 436 437
m4_define(elpa_m4_generic_kernels, [
        real_generic
        real_generic_simple
        complex_generic
        complex_generic_simple
])
438

439 440 441 442
m4_define(elpa_m4_sse_assembly_kernels, [
        real_sse_assembly
        complex_sse_assembly
])
443

444 445 446 447 448 449 450
m4_define(elpa_m4_sse_kernels, [
        real_sse_block2
        real_sse_block4
        real_sse_block6
        complex_sse_block1
        complex_sse_block2
])
451

452 453 454 455 456 457 458
m4_define(elpa_m4_avx_kernels, [
        real_avx_block2
        real_avx_block4
        real_avx_block6
        complex_avx_block1
        complex_avx_block2
])
Andreas Marek's avatar
Andreas Marek committed
459

460 461 462 463 464 465 466
m4_define(elpa_m4_avx2_kernels, [
        real_avx2_block2
        real_avx2_block4
        real_avx2_block6
        complex_avx2_block1
        complex_avx2_block2
])
Andreas Marek's avatar
Andreas Marek committed
467

468 469 470 471 472 473 474
m4_define(elpa_m4_avx512_kernels, [
        real_avx512_block2
        real_avx512_block4
        real_avx512_block6
        complex_avx512_block1
        complex_avx512_block2
])
Andreas Marek's avatar
Andreas Marek committed
475

476 477 478 479
m4_define(elpa_m4_bgp_kernels, [
        real_bgp
        complex_bgp
])
Andreas Marek's avatar
Andreas Marek committed
480

481 482 483 484
m4_define(elpa_m4_bgq_kernels, [
        real_bgq
        complex_bgq
])
Andreas Marek's avatar
Andreas Marek committed
485

486 487 488
m4_define(elpa_m4_gpu_kernels, [
        gpu
])
489

490
m4_define(elpa_m4_kernel_types, [generic sse sse_assembly avx avx2 avx512 bgp bgq gpu])
491

492 493 494 495
m4_define(elpa_m4_all_kernels,
          m4_foreach_w([elpa_m4_type],
                       elpa_m4_kernel_types,
                       [m4_foreach_w([elpa_m4_kernel],[elpa_m4_]elpa_m4_type[_kernels],elpa_m4_kernel )]))
Andreas Marek's avatar
Andreas Marek committed
496

497 498 499 500
m4_define(elpa_m4_real_kernels,
          m4_foreach_w(elpa_m4_kernel,
                       elpa_m4_all_kernels,
                       [m4_bmatch(elpa_m4_kernel,real,elpa_m4_kernel) ]))
Andreas Marek's avatar
Andreas Marek committed
501

502 503 504 505
m4_define(elpa_m4_complex_kernels,
          m4_foreach_w(elpa_m4_kernel,
                       elpa_m4_all_kernels,
                       [m4_bmatch(elpa_m4_kernel,complex,elpa_m4_kernel) ]))
506

507 508 509 510 511 512 513 514 515 516 517 518 519
dnl
dnl ELPA_SELECT_KERNELS([flagname],[default])
dnl
dnl  default should be one of `enable' or `disable'
dnl
AC_DEFUN([ELPA_SELECT_KERNELS], [
        AC_ARG_ENABLE(m4_bpatsubst($1,[_],[-]),[AS_HELP_STRING([--]m4_case([$2],[enable],[disable],[disable],[enable])[-]m4_bpatsubst($1,[_],[-]),
                m4_case([$2],[enable],[do not build],[disable],[build])[ ]m4_toupper($1)[ kernels, default: $2d])],
                      [],[enable_$1=]m4_case([$2],[enable],[yes],[disable],[no]))
        m4_foreach_w(elpa_m4_kernel,elpa_m4_$1_kernels,[
                use_[]elpa_m4_kernel[=$enable_$1]
        ])
])
520

521 522 523 524 525 526 527 528 529 530 531 532 533 534
dnl Modify list of kernels with configure arguments
ELPA_SELECT_KERNELS([generic],[enable])
ELPA_SELECT_KERNELS([sse],[enable])
ELPA_SELECT_KERNELS([sse_assembly],[enable])
ELPA_SELECT_KERNELS([avx],[enable])
ELPA_SELECT_KERNELS([avx2],[enable])
ELPA_SELECT_KERNELS([avx512],[disable])
ELPA_SELECT_KERNELS([gpu],[disable])
ELPA_SELECT_KERNELS([bgp],[disable])
ELPA_SELECT_KERNELS([bgq],[disable])

m4_foreach_w([elpa_m4_kind],[real complex],[
        default_[]elpa_m4_kind[]_kernel=""
])
535

536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563
if test x"${enable_bgp}" = x"yes" -o x"$enable_bgq" = x"yes"; then
        m4_foreach_w([elpa_m4_kernel], elpa_m4_sse_kernels elpa_m4_avx_kernels elpa_m4_avx2_kernels elpa_m4_avx512_kernels, [
                if x"$use_[]elpa_m4_kernel[]" = x"yes" ; then
                        echo "Disabling elpa_m4_kernel due to BGP/BGQ option"
                fi
                use_[]elpa_m4_kernel[]=no
        ])
fi


dnl Deal with --with-fixed-[real|complex]-kernel arguments
m4_foreach_w([elpa_m4_kind],[real complex],[
        AC_ARG_WITH([fixed-]elpa_m4_kind[-kernel], m4_expand([AS_HELP_STRING([--with-fixed-]elpa_m4_kind[-kernel]=KERNEL,
                [compile with only a single specific ]elpa_m4_kind[ kernel. Available kernels are:]
                 m4_expand(elpa_m4_[]elpa_m4_kind[]_kernels))]),
                 [fixed_]elpa_m4_kind[_kernel="$withval"],[fixed_]elpa_m4_kind[_kernel=""])
        if test -n "$fixed_[]elpa_m4_kind[]_kernel" ; then
                m4_foreach_w([elpa_m4_otherkernel],m4_expand(elpa_m4_[]elpa_m4_kind[]_kernels),[
                        if test "$fixed_]elpa_m4_kind[_kernel" = "]elpa_m4_otherkernel[" ; then
                                use_[]elpa_m4_otherkernel[]=yes
                        else
                                use_[]elpa_m4_otherkernel[]=no
                        fi
                ])
                default_[]elpa_m4_kind[]_kernel="$fixed_[]elpa_m4_kind[]_kernel"
                AC_DEFINE([WITH_FIXED_]m4_toupper(elpa_m4_kind)[_KERNEL],[1],[use only one specific ]elpa_m4_kind[ kernel (set at compile time)])
        fi
])
564

565 566 567 568 569 570 571 572 573
AC_ARG_WITH(gpu-support-only, [AS_HELP_STRING([--with-gpu-support-only],
            [Compile and always use the GPU version])],
            [],[with_gpu_support_only=no])
if test x"$with_gpu_support_only" = x"yes" ; then
        m4_foreach_w([elpa_m4_kernel],elpa_m4_all_kernels,[
                      use_[]elpa_m4_kernel[]=no
        ])
        use_gpu=yes
fi
574

575

576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595
dnl
dnl  ELPA_KERNEL_DEPENDS([kernel],[other kernels])
dnl
dnl   Switch on each of the other kernels if the given kernel is selected
dnl
AC_DEFUN([ELPA_KERNEL_DEPENDS],[
          if test x"$use_$1" = x"yes"; then
                  m4_foreach_w([elpa_m4_requiredkernel],[$2],[
                               if test x"$use_[]elpa_m4_requiredkernel[]" = x"no" ; then
                                       echo "Enabling elpa_m4_requiredkernel kernel, is a prerequisite for $1"
                               fi
                               use_[]elpa_m4_requiredkernel[]=yes
                  ])
          fi
])
m4_foreach_w([elpa_m4_arch],[sse avx avx2 avx512],[
        ELPA_KERNEL_DEPENDS([real_]elpa_m4_arch[_block6], [real_]elpa_m4_arch[_block4 real_]elpa_m4_arch[_block2])
        ELPA_KERNEL_DEPENDS([real_]elpa_m4_arch[_block4], [real_]elpa_m4_arch[_block2])
        ELPA_KERNEL_DEPENDS([complex_]elpa_m4_arch[_block2], [complex_]elpa_m4_arch[_block1])
])
596

597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616
m4_foreach_w([elpa_m4_type],elpa_m4_kernel_types,[
        need_[]elpa_m4_type=no
        need_[]elpa_m4_type[]_kernels=""
        m4_foreach_w([elpa_m4_kernel],m4_expand([elpa_m4_]elpa_m4_type[_kernels]),[
                if test x"$use_[]elpa_m4_kernel" = x"yes" ; then
                        need_[]elpa_m4_type=yes
                        need_[]elpa_m4_type[]_kernels="$need_[]elpa_m4_type[]_kernels elpa_m4_kernel"
                fi
        ])
])
m4_foreach_w([elpa_m4_type],elpa_m4_kernel_types,[
        if test x"$need_[]elpa_m4_type[]" = x"yes" ; then
               echo "Using m4_toupper(elpa_m4_type) for kernels$need_[]elpa_m4_type[]_kernels"
        fi
])
m4_foreach_w([elpa_m4_type],elpa_m4_kernel_types,[
        if test x"$need_[]elpa_m4_type[]" != x"yes" ; then
               echo "Not using m4_toupper(elpa_m4_type) as no selected kernel needs it"
        fi
])
617

618

619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638
dnl the list of kernels is now assembled
dnl choosing a default kernel

m4_foreach_w([elpa_m4_kind],[real complex],[
        m4_foreach_w([elpa_m4_kernel],
                     m4_foreach_w([elpa_m4_cand_kernel],
                                  elpa_m4_avx512_kernels elpa_m4_avx2_kernels elpa_m4_avx_kernels elpa_m4_sse_kernels elpa_m4_sse_assembly_kernels elpa_m4_generic_kernels,
                                  [m4_bmatch(elpa_m4_cand_kernel,elpa_m4_kind,elpa_m4_cand_kernel)] ),
                     [
                     if test -z "$default_[]elpa_m4_kind[]_kernel"; then
                             if test x"$use_[]elpa_m4_kernel" = x"yes"; then
                                     default_[]elpa_m4_kind[]_kernel="elpa_m4_kernel"
                             fi
                     fi
                     ])
        if test -z "$default_[]elpa_m4_kind[]_kernel"; then
                AC_MSG_ERROR([Internal error, could not determine a default kernel])
        fi
        # find the number of this kernel
        ELPA_2STAGE_[]m4_toupper(elpa_m4_kind)[]_DEFAULT=`grep -i '^ *X(ELPA_2STAGE_'$default_[]elpa_m4_kind[]_kernel'\>' $srcdir/elpa/elpa_constants.h.in | \
639
                                                                awk '// { gsub(/^[[^,]]*, */, ""); gsub(/,.*/, ""); print;}'`
640 641
        AC_SUBST([ELPA_2STAGE_]m4_toupper(elpa_m4_kind)[_DEFAULT])
])
Andreas Marek's avatar
Andreas Marek committed
642

643
AC_LANG_PUSH([C])
Andreas Marek's avatar
Andreas Marek committed
644

645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662
if test x"${need_sse}" = x"yes"; then
  AC_MSG_CHECKING(whether we can compile SSE3 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=yes],
    [can_compile_sse=no]
  )
  AC_MSG_RESULT([${can_compile_sse}])
  if test x"$can_compile_sse" != x"yes"; then
    AC_MSG_ERROR([Could not compile test program, try with --disable-sse, or adjust the C compiler or CFLAGS])
  fi
  AC_DEFINE([HAVE_SSE_INTRINSICS],[1],[gcc intrinsics SSE is supported on this CPU])
Andreas Marek's avatar
Andreas Marek committed
663 664 665
fi


666 667
if test x"${need_sse_assembly}" = x"yes"; then
  AC_MSG_CHECKING(whether double-precision SSE assembly kernels can be compiled)
Andreas Marek's avatar
Andreas Marek committed
668

669
  $CC $CFLAGS -c $srcdir/src/elpa2/kernels/elpa2_kernels_asm_x86_64_double_precision.s -o conftest.o 2>&5
Andreas Marek's avatar
Andreas Marek committed
670

671 672 673 674 675 676 677 678 679 680
  if test "$?" == 0; then
    can_compile_sse_asm_double=yes
  else
    can_compile_sse_asm_double=no
  fi
  rm -f ./conftest.o
  AC_MSG_RESULT([${can_compile_sse_asm_double}])
  if test x"$can_compile_sse_asm_double" != x"yes"; then
    AC_MSG_ERROR([Could not compile test program, try with --disable-sse-assembly, or adjust the C compiler or CFLAGS])
  fi
681

682 683
  if test x"${want_single_precision}" = x"yes" ; then
    AC_MSG_CHECKING(whether single-precision SSE assembly kernels can be compiled)
684

685
    $CC $CFLAGS -c $srcdir/src/elpa2/kernels/elpa2_kernels_asm_x86_64_single_precision.s -o conftest.o 2>&5
686

687 688 689 690 691 692 693 694 695 696 697
    if test "$?" == 0; then
      can_compile_sse_asm_single=yes
    else
      can_compile_sse_asm_single=no
    fi
    rm -f ./conftest.o
    AC_MSG_RESULT([${can_compile_sse_asm_single}])
    if test x"$can_compile_sse_asm_single" != x"yes"; then
      AC_MSG_ERROR([Could not compile test program, try with --disable-sse-assembly, or adjust the C compiler or CFLAGS])
    fi
  fi
Andreas Marek's avatar
Andreas Marek committed
698 699 700 701
fi



702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720
if test x"${need_avx}" = x"yes"; then
  dnl check whether one can compile AVX gcc intrinsics
  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}])
  if test x"$can_compile_avx" != x"yes"; then
    AC_MSG_ERROR([Could not compile a test program with AVX, try with --disable-avx, or adjust the C compiler or CFLAGS])
  fi
  AC_DEFINE([HAVE_AVX],[1],[AVX is supported on this CPU])
721 722 723
fi


724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742
if test x"${need_avx2}" = x"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}])
  if test x"$can_compile_avx2" != x"yes"; then
    AC_MSG_ERROR([Could not compile a test program with AVX2, try with --disable-avx2, or adjust the C compiler or CFLAGS])
  fi
  AC_DEFINE([HAVE_AVX2],[1],[AVX2 is supported on this CPU])
743 744
fi

745

746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764
if test x"${need_avx512}" = x"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}])
  if test x"$can_compile_avx512" != x"yes"; then
    AC_MSG_ERROR([Could not compile a test program with AVX512, adjust the C compiler or CFLAGS])
  fi
  AC_DEFINE([HAVE_AVX512],[1],[AVX512 is supported on this CPU])
765
fi
766
AC_LANG_POP([C])
767 768


769 770 771 772 773 774 775
AC_LANG_PUSH([Fortran])
if test x"${need_bgp}" = x"yes"; then
  AC_MSG_CHECKING([whether we can compile with BGP intrinsics])
  AC_LINK_IFELSE([AC_LANG_SOURCE([
    program test_bgp
      complex*16 :: y3,q3,h2
      y3 = fxcpmadd(y3,q3,h2)
776

777 778 779 780 781 782 783 784 785
    end program
  ])],
    [can_compile_bgp=yes],
    [can_compile_bgp=no]
  )
  AC_MSG_RESULT([${can_compile_bgp}])
  if test x"$can_compile_bgp" != x"yes"; then
    AC_MSG_ERROR([Could not compile a test program with BGP intrinsics, adjust the FC compiler or FCFLAGS])
  fi
786 787
fi

Andreas Marek's avatar
Andreas Marek committed
788

789 790 791 792 793 794 795
if test x"${need_bgq}" = x"yes"; then
  AC_MSG_CHECKING([whether we can compile with BGQ intrinsics])
  AC_LINK_IFELSE([AC_LANG_SOURCE([
    program test_bgq
      VECTOR(REAL(8))::QPX_h2
      real*8         :: hh(10,2)
      QPX_h2 = VEC_SPLATS(hh(2,2))
Andreas Marek's avatar
Andreas Marek committed
796

797 798 799 800 801 802 803 804 805
    end program
  ])],
    [can_compile_bgq=yes],
    [can_compile_bgq=no]
  )
  AC_MSG_RESULT([${can_compile_bgq}])
  if test x"$can_compile_bgq" != x"yes"; then
    AC_MSG_ERROR([Could not compile a test program with BGQ intrinsics, adjust the FC compiler or FCFLAGS])
  fi
806
fi
807
AC_LANG_POP([Fortran])
808

809 810 811 812 813 814 815 816
if test x"${need_gpu}" = x"yes" ; then
  AC_LANG_PUSH([C])
  CUDA_CFLAGS="$CUDA_CFLAGS -arch $cuda_compute_capability -O2 -I$CUDA_INSTALL_PATH/include"
  LDFLAGS="$LDFLAGS -L$CUDA_INSTALL_PATH/lib64"
  NVCCFLAGS="$NVCCFLAGS $CUDA_CFLAGS $CUDA_LDFLAGS"
  NVCC="nvcc"
  AC_SUBST(NVCC)
  AC_SUBST(NVCCFLAGS)
817

818 819 820 821 822
  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
823

824 825 826 827 828 829 830 831 832 833
  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])
834 835
fi

Andreas Marek's avatar
Andreas Marek committed
836

837 838 839 840
m4_foreach_w([elpa_m4_kernel],elpa_m4_all_kernels,[
  AM_CONDITIONAL([WITH_]m4_toupper(elpa_m4_kernel)[_KERNEL],[test x"$use_[]elpa_m4_kernel[]" = x"yes"])
  if test x"$use_[]elpa_m4_kernel[]" = x"yes" ; then
    AC_DEFINE([WITH_]m4_toupper(elpa_m4_kernel)[_KERNEL],[1],[Build elpa_m4_kernel kernel])
841 842 843
    kernel_defined=1
  else
    kernel_defined=0
844
  fi
845 846
  [ELPA_2STAGE_]m4_toupper(elpa_m4_kernel)[_COMPILED]=$kernel_defined
  AC_SUBST([ELPA_2STAGE_]m4_toupper(elpa_m4_kernel)[_COMPILED])
847
])
Andreas Marek's avatar
Andreas Marek committed
848 849


850 851 852
AM_CONDITIONAL([WITH_GPU_VERSION],[test x"$use_gpu" = x"yes"])
if test x"${use_gpu}" = x"yes" ; then
  AC_DEFINE([WITH_GPU_VERSION],[1],[enable GPU support])
853 854 855 856 857
  ELPA_2STAGE_COMPLEX_GPU_COMPILED=1
  ELPA_2STAGE_REAL_GPU_COMPILED=1
else
  ELPA_2STAGE_COMPLEX_GPU_COMPILED=0
  ELPA_2STAGE_REAL_GPU_COMPILED=0
Andreas Marek's avatar
Andreas Marek committed
858
fi
859 860
AC_SUBST([ELPA_2STAGE_COMPLEX_GPU_COMPILED])
AC_SUBST([ELPA_2STAGE_REAL_GPU_COMPILED])
Andreas Marek's avatar
Andreas Marek committed
861

862 863
LT_INIT

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

870
USE_ASSUMED_SIZE=yes
Andreas Marek's avatar
Andreas Marek committed
871
AC_MSG_CHECKING(whether assumed size Fortran arrays should be used)
872
AC_ARG_ENABLE([assumed-size],
873
                AS_HELP_STRING([--disable-assumed-size],
874 875
                               [do NOT use assumed-size Fortran arrays]),
                               [if test x"$enableval" = x"yes"; then
Andreas Marek's avatar
Andreas Marek committed
876
                                  USE_ASSUMED_SIZE=yes
877 878 879
                                else
                                  USE_ASSUMED_SIZE=no
                                fi],
880
              [USE_ASSUMED_SIZE=yes])
881 882 883
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
884
  AC_DEFINE([USE_ASSUMED_SIZE],[1],[for performance reasons use assumed size Fortran arrays, even if not debuggable])
885 886
fi

887 888 889
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])
890
fi
891 892
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"])
893

894
AC_SUBST([MPI_BINARY])
895 896 897 898
AC_SUBST([WITH_MKL])
AC_SUBST([WITH_BLACS])
AC_SUBST([FC_MODINC])
AC_SUBST([FC_MODOUT])
899 900 901
AC_SUBST([OPENMP_CFLAGS])
AC_SUBST([OPENMP_FCFLAGS])
AC_SUBST([OPENMP_LDFLAGS])
902
AC_SUBST([DOXYGEN_OUTPUT_DIR], [docs])
903

904 905 906
#rm -rf modules/ private_modules/ .fortran_dependencies/
mkdir -p modules private_modules

907 908 909 910 911 912 913 914 915 916

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

917 918 919 920 921 922 923 924 925

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

927 928
if test x"${with_mpi}" = x"yes"; then
  if test x"${enable_openmp}" = x"yes"; then
929
        SUFFIX="_openmp"
930
  else
931
        SUFFIX=""
932 933 934
  fi
else
  if test x"${enable_openmp}" = x"yes"; then
935
        SUFFIX="_onenode_openmp"
936
  else
937
        SUFFIX="_onenode"
938
  fi
939
fi
940

941 942
AC_SUBST([SUFFIX])
AC_SUBST([PKG_CONFIG_FILE],[elpa${SUFFIX}-${PACKAGE_VERSION}.pc])
943

944 945
AC_CONFIG_FILES([
  Makefile
946
  Doxyfile
947
  ${PKG_CONFIG_FILE}:elpa.pc.in
948
  elpa/elpa_constants.h
949
])
950

951 952 953 954 955 956
m4_include([m4/ax_fc_check_define.m4])
AC_MSG_CHECKING([if workaround for broken preprocessor is needed])

need_manual_cpp=no
AX_FC_CHECK_DEFINE([__INTEL_COMPILER],[need_manual_cpp=yes],[])
AX_FC_CHECK_DEFINE([__PGI],[need_manual_cpp=yes],[])
Lorenz Huedepohl's avatar
Lorenz Huedepohl committed
957 958
ACTUAL_FC="$FC"
AC_SUBST([ACTUAL_FC])
959
if test x"$need_manual_cpp" = x"yes" ; then
960 961
        AC_MSG_RESULT([yes])
        FC="\$(top_srcdir)/manual_cpp $FC"
962
else
963
        AC_MSG_RESULT([no])
964 965
fi

Lorenz Huedepohl's avatar
Lorenz Huedepohl committed
966 967 968 969 970 971 972 973 974 975 976 977 978

dnl PGI compiler uses -module to specify module output
dnl directory. This clashes with libtools -module link option
dnl => escape it for libtool with -Xcompiler -module
AC_MSG_CHECKING([whether we have to escape '-module' for libtool])
if test x"$FC_MODOUT" = x'-module ' ; then
        FC_MODOUT="-Xcompiler $FC_MODOUT -Xcompiler \$(ac_empty)"
        FC="\$(top_srcdir)/remove_xcompiler $FC"
        AC_MSG_RESULT([yes])
else
        AC_MSG_RESULT([no])
fi

979

980
AC_OUTPUT
981

982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998
echo ""
echo "The following ELPA2 kernels will be build:"
echo ""
m4_foreach_w([elpa_m4_kind],[real complex],[
        m4_foreach_w([elpa_m4_kernel],m4_expand(elpa_m4_[]elpa_m4_kind[]_kernels),[
                if test x"$use_[]elpa_m4_kernel" = x"yes" ; then
                        echo -n "  elpa_m4_kernel"
                        if test "$fixed_]elpa_m4_kind[_kernel" = "]elpa_m4_kernel[" ; then
                                echo -n " (selected as fixed kernel)"
                        fi
                        if test "$default_]elpa_m4_kind[_kernel" = "]elpa_m4_kernel[" ; then
                                echo -n " (default)"
                        fi
                        echo ""
                fi
        ])
])
999

1000 1001 1002 1003 1004 1005 1006
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 " "
1007
make -f $srcdir/generated_headers.am generated-headers top_srcdir="$srcdir"