687 lines
27 KiB
Python
687 lines
27 KiB
Python
# Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
|
|
# Spack Project Developers. See the top-level COPYRIGHT file for details.
|
|
#
|
|
# SPDX-License-Identifier: (Apache-2.0 OR MIT)
|
|
import copy
|
|
import os
|
|
import os.path
|
|
|
|
import spack.util.environment
|
|
|
|
|
|
class Cp2k(MakefilePackage, CudaPackage):
|
|
"""CP2K is a quantum chemistry and solid state physics software package
|
|
that can perform atomistic simulations of solid state, liquid, molecular,
|
|
periodic, material, crystal, and biological systems
|
|
"""
|
|
homepage = 'https://www.cp2k.org'
|
|
url = 'https://github.com/cp2k/cp2k/releases/download/v3.0.0/cp2k-3.0.tar.bz2'
|
|
git = 'https://github.com/cp2k/cp2k.git'
|
|
list_url = 'https://github.com/cp2k/cp2k/releases'
|
|
|
|
maintainers = ['dev-zero']
|
|
|
|
version('8.2', sha256='2e24768720efed1a5a4a58e83e2aca502cd8b95544c21695eb0de71ed652f20a')
|
|
version('8.1', sha256='7f37aead120730234a60b2989d0547ae5e5498d93b1e9b5eb548c041ee8e7772')
|
|
version('7.1', sha256='ccd711a09a426145440e666310dd01cc5772ab103493c4ae6a3470898cd0addb')
|
|
version('6.1', sha256='af803558e0a6b9e9d9ce8a3ab955ba32bacd179922455424e061c82c9fefa34b')
|
|
version('5.1', sha256='e23613b593354fa82e0b8410e17d94c607a0b8c6d9b5d843528403ab09904412')
|
|
version('4.1', sha256='4a3e4a101d8a35ebd80a9e9ecb02697fb8256364f1eccdbe4e5a85d31fe21343')
|
|
version('3.0', sha256='1acfacef643141045b7cbade7006f9b7538476d861eeecd9658c9e468dc61151')
|
|
version('master', branch='master', submodules="True")
|
|
|
|
variant('mpi', default=True, description='Enable MPI support')
|
|
variant('openmp', default=True, description='Enable OpenMP support')
|
|
variant('smm', default='libxsmm', values=('libxsmm', 'libsmm', 'blas'),
|
|
description='Library for small matrix multiplications')
|
|
variant('plumed', default=False, description='Enable PLUMED support')
|
|
variant('libint', default=True,
|
|
description='Use libint, required for HFX (and possibly others)')
|
|
variant('libxc', default=True,
|
|
description='Support additional functionals via libxc')
|
|
variant('pexsi', default=False,
|
|
description=('Enable the alternative PEXSI method'
|
|
'for density matrix evaluation'))
|
|
variant('elpa', default=False,
|
|
description='Enable optimised diagonalisation routines from ELPA')
|
|
variant('sirius', default=False,
|
|
description=('Enable planewave electronic structure'
|
|
' calculations via SIRIUS'))
|
|
variant('cosma', default=False, description='Use COSMA for p?gemm')
|
|
variant('libvori', default=False,
|
|
description=('Enable support for Voronoi integration'
|
|
' and BQB compression'))
|
|
variant('spglib', default=False, description='Enable support for spglib')
|
|
|
|
variant('cuda_arch_35_k20x', default=False,
|
|
description=('CP2K (resp. DBCSR) has specific parameter sets for'
|
|
' different GPU models. Enable this when building'
|
|
' with cuda_arch=35 for a K20x instead of a K40'))
|
|
variant('cuda_fft', default=False,
|
|
description=('Use CUDA also for FFTs in the PW part of CP2K'))
|
|
variant('cuda_blas', default=False,
|
|
description=('Use CUBLAS for general matrix operations in DBCSR'))
|
|
|
|
HFX_LMAX_RANGE = range(4, 8)
|
|
|
|
variant('lmax',
|
|
description='Maximum supported angular momentum (HFX and others)',
|
|
default='5',
|
|
values=[str(x) for x in HFX_LMAX_RANGE],
|
|
multi=False)
|
|
|
|
depends_on('python', type='build')
|
|
depends_on('python@3:', when='@8:', type='build')
|
|
|
|
depends_on('blas')
|
|
depends_on('lapack')
|
|
depends_on('fftw-api@3')
|
|
|
|
# Force openmp propagation on some providers of blas / fftw-api
|
|
with when('+openmp'):
|
|
depends_on('fftw+openmp', when='^fftw')
|
|
depends_on('amdfftw+openmp', when='^amdfftw')
|
|
depends_on('openblas threads=openmp', when='^openblas')
|
|
|
|
with when('smm=libxsmm'):
|
|
# require libxsmm-1.11+ since 1.10 can leak file descriptors in Fortran
|
|
depends_on('libxsmm@1.11:~header-only')
|
|
# use pkg-config (support added in libxsmm-1.10) to link to libxsmm
|
|
depends_on('pkgconfig', type='build')
|
|
# please set variants: smm=blas by configuring packages.yaml or install
|
|
# cp2k with option smm=blas on aarch64
|
|
conflicts('target=aarch64:', msg='libxsmm is not available on arm')
|
|
|
|
with when('+libint'):
|
|
# ... and in CP2K 7.0+ for linking to libint2
|
|
depends_on('pkgconfig', type='build', when='@7.0:')
|
|
# libint & libxc are always statically linked
|
|
depends_on('libint@1.1.4:1.2', when='@3.0:6.9')
|
|
for lmax in HFX_LMAX_RANGE:
|
|
# libint2 can be linked dynamically again
|
|
depends_on('libint@2.6.0:+fortran tune=cp2k-lmax-{0}'.format(lmax),
|
|
when='@7.0: lmax={0}'.format(lmax))
|
|
|
|
with when('+libxc'):
|
|
depends_on('pkgconfig', type='build', when='@7.0:')
|
|
depends_on('libxc@2.2.2:3', when='@:5', type='build')
|
|
depends_on('libxc@4.0.3:4', when='@6.0:6.9', type='build')
|
|
depends_on('libxc@4.0.3:4', when='@7.0:8.1')
|
|
depends_on('libxc@5.1.3:5.1', when='@8.2:')
|
|
|
|
with when('+mpi'):
|
|
depends_on('mpi@2:')
|
|
depends_on('scalapack')
|
|
|
|
with when('+cosma'):
|
|
depends_on('cosma+scalapack')
|
|
depends_on('cosma+cuda', when='+cuda')
|
|
conflicts('~mpi')
|
|
# COSMA support was introduced in 8+
|
|
conflicts('@:7')
|
|
|
|
with when('+elpa'):
|
|
conflicts('~mpi', msg='elpa requires MPI')
|
|
depends_on('elpa+openmp', when='+openmp')
|
|
depends_on('elpa~openmp', when='~openmp')
|
|
depends_on('elpa@2011.12:2016.13', when='@:5')
|
|
depends_on('elpa@2011.12:2017.11', when='@6.0:6')
|
|
depends_on('elpa@2018.05:2020.11.001', when='@7.0:8.2')
|
|
depends_on('elpa@2021.05:', when='@8.3:')
|
|
|
|
with when('+plumed'):
|
|
depends_on('plumed+shared')
|
|
depends_on('plumed+mpi', when='+mpi')
|
|
depends_on('plumed~mpi', when='~mpi')
|
|
|
|
# while we link statically against PEXSI, its own deps may be linked in
|
|
# dynamically, therefore can't set this as pure build-type dependency.
|
|
with when('+pexsi'):
|
|
conflicts('~mpi', msg='pexsi requires MPI')
|
|
depends_on('pexsi+fortran@0.9.0:0.9', when='@:4')
|
|
depends_on('pexsi+fortran@0.10.0:', when='@5.0:')
|
|
|
|
# only OpenMP should be consistently used, all other common things
|
|
# like ELPA, SCALAPACK are independent and Spack will ensure that
|
|
# a consistent/compatible combination is pulled into the dependency graph.
|
|
with when('+sirius'):
|
|
depends_on('sirius+fortran+shared')
|
|
depends_on('sirius+openmp', when='+openmp')
|
|
depends_on('sirius~openmp', when='~openmp')
|
|
depends_on('sirius@:6', when='@:7')
|
|
depends_on('sirius@7.0.0:7.0', when='@8:8.2')
|
|
depends_on('sirius@7.2:', when='@8.3:')
|
|
conflicts('~mpi')
|
|
# sirius support was introduced in 7+
|
|
conflicts('@:6')
|
|
|
|
with when('+libvori'):
|
|
depends_on('libvori@201219:', when='@8.1', type='build')
|
|
depends_on('libvori@210412:', when='@8.2:', type='build')
|
|
# libvori support was introduced in 8+
|
|
conflicts('@:7')
|
|
|
|
# the bundled libcusmm uses numpy in the parameter prediction (v7+)
|
|
# which is written using Python 3
|
|
depends_on('py-numpy', when='@7:+cuda', type='build')
|
|
depends_on('python@3.6:', when='@7:+cuda', type='build')
|
|
|
|
depends_on('spglib', when='+spglib')
|
|
conflicts('~cuda', '+cuda_fft')
|
|
conflicts('~cuda', '+cuda_blas')
|
|
|
|
# Apparently cp2k@4.1 needs an "experimental" version of libwannier.a
|
|
# which is only available contacting the developer directly. See INSTALL
|
|
# in the stage of cp2k@4.1
|
|
depends_on('wannier90', when='@3.0+mpi', type='build')
|
|
|
|
# CP2K needs compiler specific compilation flags, e.g. optflags
|
|
conflicts('%apple-clang')
|
|
conflicts('%clang')
|
|
conflicts('%nag')
|
|
|
|
conflicts('~openmp', when='@8:', msg='Building without OpenMP is not supported in CP2K 8+')
|
|
|
|
# We only support specific cuda_archs for which we have parameter files
|
|
# for optimal kernels. Note that we don't override the cuda_archs property
|
|
# from the parent class, since the parent class defines constraints for all
|
|
# versions. Instead just mark all unsupported cuda archs as conflicting.
|
|
dbcsr_cuda_archs = ('35', '37', '60', '70')
|
|
cuda_msg = 'cp2k only supports cuda_arch {0}'.format(dbcsr_cuda_archs)
|
|
|
|
for arch in CudaPackage.cuda_arch_values:
|
|
if arch not in dbcsr_cuda_archs:
|
|
conflicts('+cuda', when='cuda_arch={0}'.format(arch), msg=cuda_msg)
|
|
|
|
conflicts('+cuda', when='cuda_arch=none', msg=cuda_msg)
|
|
|
|
# Fix 2- and 3-center integral calls to libint
|
|
patch("https://github.com/cp2k/cp2k/commit/5eaf864ed2bd21fb1b05a9173bb77a815ad4deda.patch",
|
|
sha256="18e58ba8fdde5c507bece48ec064f7f2b80e59d1b7cfe6b7a639e5f64f84d43f",
|
|
when="@8.2")
|
|
|
|
@property
|
|
def makefile_architecture(self):
|
|
return '{0.architecture}-{0.compiler.name}'.format(self.spec)
|
|
|
|
@property
|
|
def makefile_version(self):
|
|
return '{prefix}{suffix}'.format(
|
|
prefix='p' if '+mpi' in self.spec else 's',
|
|
suffix='smp' if '+openmp' in self.spec else 'opt'
|
|
)
|
|
|
|
@property
|
|
def makefile(self):
|
|
makefile_basename = '.'.join([
|
|
self.makefile_architecture, self.makefile_version
|
|
])
|
|
return join_path('arch', makefile_basename)
|
|
|
|
@property
|
|
def archive_files(self):
|
|
return [join_path(self.stage.source_path, self.makefile)]
|
|
|
|
def edit(self, spec, prefix):
|
|
pkgconf = which('pkg-config')
|
|
|
|
if '^fftw' in spec:
|
|
fftw = spec['fftw:openmp' if '+openmp' in spec else 'fftw']
|
|
fftw_header_dir = fftw.headers.directories[0]
|
|
elif '^amdfftw' in spec:
|
|
fftw = spec['amdfftw:openmp' if '+openmp' in spec else 'amdfftw']
|
|
fftw_header_dir = fftw.headers.directories[0]
|
|
elif '^intel-mkl' in spec:
|
|
fftw = spec['intel-mkl']
|
|
fftw_header_dir = fftw.headers.directories[0] + '/fftw'
|
|
elif '^intel-oneapi-mkl' in spec:
|
|
fftw = spec['intel-oneapi-mkl']
|
|
fftw_header_dir = fftw.headers.directories[0] + '/fftw'
|
|
elif '^intel-parallel-studio+mkl' in spec:
|
|
fftw = spec['intel-parallel-studio']
|
|
fftw_header_dir = '<NOTFOUND>'
|
|
for incdir in [join_path(f, 'fftw')
|
|
for f in fftw.headers.directories]:
|
|
if os.path.exists(incdir):
|
|
fftw_header_dir = incdir
|
|
break
|
|
elif '^cray-fftw' in spec:
|
|
fftw = spec['cray-fftw']
|
|
fftw_header_dir = fftw.headers.directories[0]
|
|
|
|
optimization_flags = {
|
|
'gcc': [
|
|
'-O2',
|
|
'-funroll-loops',
|
|
'-ftree-vectorize',
|
|
],
|
|
'intel': ['-O2', '-pc64', '-unroll', ],
|
|
'pgi': ['-fast'],
|
|
'nvhpc': ['-fast'],
|
|
'cce': ['-O2'],
|
|
'xl': ['-O3'],
|
|
'aocc': ['-O1'],
|
|
}
|
|
|
|
dflags = ['-DNDEBUG']
|
|
cppflags = [
|
|
'-D__FFTW3',
|
|
'-I{0}'.format(fftw_header_dir),
|
|
]
|
|
|
|
if '^mpi@3:' in spec:
|
|
cppflags.append('-D__MPI_VERSION=3')
|
|
elif '^mpi@2:' in spec:
|
|
cppflags.append('-D__MPI_VERSION=2')
|
|
|
|
cflags = optimization_flags[self.spec.compiler.name][:]
|
|
cxxflags = optimization_flags[self.spec.compiler.name][:]
|
|
fcflags = optimization_flags[self.spec.compiler.name][:]
|
|
nvflags = ['-O3']
|
|
ldflags = []
|
|
libs = []
|
|
gpuver = ''
|
|
|
|
if '%intel' in spec:
|
|
cflags.append('-fp-model precise')
|
|
cxxflags.append('-fp-model precise')
|
|
fcflags += [
|
|
'-fp-model precise',
|
|
'-heap-arrays 64',
|
|
'-g',
|
|
'-traceback',
|
|
]
|
|
elif '%gcc' in spec:
|
|
fcflags += [
|
|
'-ffree-form',
|
|
'-ffree-line-length-none',
|
|
'-ggdb', # make sure we get proper Fortran backtraces
|
|
]
|
|
elif '%aocc' in spec:
|
|
fcflags += [
|
|
'-ffree-form',
|
|
'-Mbackslash',
|
|
]
|
|
elif '%pgi' in spec or '%nvhpc' in spec:
|
|
fcflags += ['-Mfreeform', '-Mextend']
|
|
elif '%cce' in spec:
|
|
fcflags += ['-emf', '-ffree', '-hflex_mp=strict']
|
|
elif '%xl' in spec:
|
|
fcflags += ['-qpreprocess', '-qstrict', '-q64']
|
|
ldflags += ['-Wl,--allow-multiple-definition']
|
|
|
|
if '%gcc@10: +mpi' in spec and spec['mpi'].name in ['mpich', 'cray-mpich']:
|
|
fcflags += ['-fallow-argument-mismatch'] # https://github.com/pmodels/mpich/issues/4300
|
|
|
|
if '+openmp' in spec:
|
|
cflags.append(self.compiler.openmp_flag)
|
|
cxxflags.append(self.compiler.openmp_flag)
|
|
fcflags.append(self.compiler.openmp_flag)
|
|
ldflags.append(self.compiler.openmp_flag)
|
|
nvflags.append('-Xcompiler="{0}"'.format(
|
|
self.compiler.openmp_flag))
|
|
elif '%cce' in spec: # Cray enables OpenMP by default
|
|
cflags += ['-hnoomp']
|
|
cxxflags += ['-hnoomp']
|
|
fcflags += ['-hnoomp']
|
|
ldflags += ['-hnoomp']
|
|
|
|
if '@7:' in spec: # recent versions of CP2K use C++14 CUDA code
|
|
cxxflags.append(self.compiler.cxx14_flag)
|
|
nvflags.append(self.compiler.cxx14_flag)
|
|
|
|
ldflags.append(fftw.libs.search_flags)
|
|
|
|
if 'superlu-dist@4.3' in spec:
|
|
ldflags.insert(0, '-Wl,--allow-multiple-definition')
|
|
|
|
if '+plumed' in self.spec:
|
|
dflags.extend(['-D__PLUMED2'])
|
|
cppflags.extend(['-D__PLUMED2'])
|
|
libs.extend([
|
|
join_path(self.spec['plumed'].prefix.lib,
|
|
'libplumed.{0}'.format(dso_suffix))
|
|
])
|
|
|
|
cc = spack_cc if '~mpi' in spec else spec['mpi'].mpicc
|
|
cxx = spack_cxx if '~mpi' in spec else spec['mpi'].mpicxx
|
|
fc = spack_fc if '~mpi' in spec else spec['mpi'].mpifc
|
|
|
|
# Intel
|
|
if '%intel' in spec:
|
|
cppflags.extend([
|
|
'-D__INTEL',
|
|
'-D__HAS_ISO_C_BINDING',
|
|
'-D__USE_CP2K_TRACE',
|
|
])
|
|
fcflags.extend([
|
|
'-diag-disable 8290,8291,10010,10212,11060',
|
|
'-free',
|
|
'-fpp'
|
|
])
|
|
|
|
# FFTW, LAPACK, BLAS
|
|
lapack = spec['lapack'].libs
|
|
blas = spec['blas'].libs
|
|
ldflags.append((lapack + blas).search_flags)
|
|
libs.extend([str(x) for x in (fftw.libs, lapack, blas)])
|
|
|
|
if any(p in spec for p in ('^intel-mkl',
|
|
'^intel-parallel-studio+mkl',
|
|
'^intel-oneapi-mkl')):
|
|
cppflags += ['-D__MKL']
|
|
elif '^accelerate' in spec:
|
|
cppflags += ['-D__ACCELERATE']
|
|
|
|
if '+cosma' in spec:
|
|
# add before ScaLAPACK to override the p?gemm symbols
|
|
cosma = spec['cosma'].libs
|
|
ldflags.append(cosma.search_flags)
|
|
libs.extend(cosma)
|
|
|
|
# MPI
|
|
if '+mpi' in spec:
|
|
cppflags.extend([
|
|
'-D__parallel',
|
|
'-D__SCALAPACK'
|
|
])
|
|
|
|
if '^intel-oneapi-mpi' in spec:
|
|
mpi = [join_path(
|
|
spec['intel-oneapi-mpi'].libs.directories[0],
|
|
'libmpi.so')]
|
|
else:
|
|
mpi = spec['mpi:cxx'].libs
|
|
|
|
# while intel-mkl has a mpi variant and adds the scalapack
|
|
# libs to its libs, intel-oneapi-mkl does not.
|
|
if '^intel-oneapi-mkl' in spec:
|
|
mpi_impl = 'openmpi' if '^openmpi' in spec else 'intelmpi'
|
|
scalapack = [
|
|
join_path(
|
|
spec['intel-oneapi-mkl'].libs.directories[0],
|
|
'libmkl_scalapack_lp64.so'),
|
|
join_path(
|
|
spec['intel-oneapi-mkl'].libs.directories[0],
|
|
'libmkl_blacs_{0}_lp64.so'.format(mpi_impl)
|
|
)
|
|
]
|
|
else:
|
|
scalapack = spec['scalapack'].libs
|
|
ldflags.append(scalapack.search_flags)
|
|
|
|
libs.extend(scalapack)
|
|
libs.extend(mpi)
|
|
libs.extend(self.compiler.stdcxx_libs)
|
|
|
|
if 'wannier90' in spec:
|
|
cppflags.append('-D__WANNIER90')
|
|
wannier = join_path(
|
|
spec['wannier90'].libs.directories[0], 'libwannier.a'
|
|
)
|
|
libs.append(wannier)
|
|
|
|
if '+libint' in spec:
|
|
cppflags += ['-D__LIBINT']
|
|
|
|
if '@:6.9' in spec:
|
|
cppflags += [
|
|
'-D__LIBINT_MAX_AM=6',
|
|
'-D__LIBDERIV_MAX_AM1=5',
|
|
]
|
|
|
|
# libint-1.x.y has to be linked statically to work around
|
|
# inconsistencies in its Fortran interface definition
|
|
# (short-int vs int) which otherwise causes segfaults at
|
|
# runtime due to wrong offsets into the shared library
|
|
# symbols.
|
|
libs.extend([
|
|
join_path(
|
|
spec['libint'].libs.directories[0], 'libderiv.a'),
|
|
join_path(
|
|
spec['libint'].libs.directories[0], 'libint.a'),
|
|
])
|
|
else:
|
|
fcflags += pkgconf('--cflags', 'libint2', output=str).split()
|
|
libs += pkgconf('--libs', 'libint2', output=str).split()
|
|
|
|
if '+libxc' in spec:
|
|
cppflags += ['-D__LIBXC']
|
|
|
|
if '@:6.9' in spec:
|
|
libxc = spec['libxc:fortran,static']
|
|
cppflags += [libxc.headers.cpp_flags]
|
|
ldflags.append(libxc.libs.search_flags)
|
|
libs.append(str(libxc.libs))
|
|
else:
|
|
fcflags += pkgconf('--cflags', 'libxcf03', output=str).split()
|
|
# some Fortran functions seem to be direct wrappers of the
|
|
# C functions such that we get a direct dependency on them,
|
|
# requiring `-lxc` to be present in addition to `-lxcf03`
|
|
libs += pkgconf('--libs', 'libxcf03', 'libxc', output=str).split()
|
|
|
|
if '+pexsi' in spec:
|
|
cppflags.append('-D__LIBPEXSI')
|
|
fcflags.append('-I' + join_path(
|
|
spec['pexsi'].prefix, 'fortran'))
|
|
libs.extend([
|
|
join_path(spec['pexsi'].libs.directories[0], 'libpexsi.a'),
|
|
join_path(spec['superlu-dist'].libs.directories[0],
|
|
'libsuperlu_dist.a'),
|
|
join_path(
|
|
spec['parmetis'].libs.directories[0],
|
|
'libparmetis.{0}'.format(dso_suffix)
|
|
),
|
|
join_path(
|
|
spec['metis'].libs.directories[0],
|
|
'libmetis.{0}'.format(dso_suffix)
|
|
),
|
|
])
|
|
|
|
if '+elpa' in spec:
|
|
elpa = spec['elpa']
|
|
elpa_suffix = '_openmp' if '+openmp' in elpa else ''
|
|
elpa_incdir = elpa.headers.directories[0]
|
|
|
|
fcflags += ['-I{0}'.format(join_path(elpa_incdir, 'modules'))]
|
|
|
|
# Currently AOCC support only static libraries of ELPA
|
|
if '%aocc' in spec:
|
|
libs.append(join_path(elpa.prefix.lib,
|
|
('libelpa{elpa_suffix}.a'
|
|
.format(elpa_suffix=elpa_suffix))))
|
|
else:
|
|
libs.append(join_path(elpa.prefix.lib,
|
|
('libelpa{elpa_suffix}.{dso_suffix}'
|
|
.format(elpa_suffix=elpa_suffix,
|
|
dso_suffix=dso_suffix))))
|
|
|
|
if spec.satisfies('@:4'):
|
|
if elpa.satisfies('@:2014.5'):
|
|
cppflags.append('-D__ELPA')
|
|
elif elpa.satisfies('@2014.6:2015.10'):
|
|
cppflags.append('-D__ELPA2')
|
|
else:
|
|
cppflags.append('-D__ELPA3')
|
|
else:
|
|
cppflags.append('-D__ELPA={0}{1:02d}'
|
|
.format(elpa.version[0],
|
|
int(elpa.version[1])))
|
|
fcflags += ['-I{0}'.format(join_path(elpa_incdir, 'elpa'))]
|
|
|
|
if spec.satisfies('+sirius'):
|
|
sirius = spec['sirius']
|
|
cppflags.append('-D__SIRIUS')
|
|
fcflags += ['-I{0}'.format(sirius.prefix.include.sirius)]
|
|
libs += list(sirius.libs)
|
|
|
|
if spec.satisfies('+cuda'):
|
|
cppflags += ['-D__ACC']
|
|
libs += ['-lcudart', '-lnvrtc', '-lcuda']
|
|
|
|
if spec.satisfies('+cuda_blas'):
|
|
cppflags += ['-D__DBCSR_ACC=2']
|
|
libs += ['-lcublas']
|
|
else:
|
|
cppflags += ['-D__DBCSR_ACC']
|
|
|
|
if spec.satisfies('+cuda_fft'):
|
|
cppflags += ['-D__PW_CUDA']
|
|
libs += ['-lcufft', '-lcublas']
|
|
|
|
cuda_arch = spec.variants['cuda_arch'].value[0]
|
|
if cuda_arch:
|
|
gpuver = {
|
|
'35': 'K40',
|
|
'37': 'K80',
|
|
'60': 'P100',
|
|
'70': 'V100',
|
|
}[cuda_arch]
|
|
|
|
if (cuda_arch == '35'
|
|
and spec.satisfies('+cuda_arch_35_k20x')):
|
|
gpuver = 'K20X'
|
|
|
|
if 'smm=libsmm' in spec:
|
|
lib_dir = join_path(
|
|
'lib', self.makefile_architecture, self.makefile_version
|
|
)
|
|
mkdirp(lib_dir)
|
|
try:
|
|
copy(env['LIBSMM_PATH'], join_path(lib_dir, 'libsmm.a'))
|
|
except KeyError:
|
|
raise KeyError('Point environment variable LIBSMM_PATH to '
|
|
'the absolute path of the libsmm.a file')
|
|
except IOError:
|
|
raise IOError('The file LIBSMM_PATH pointed to does not '
|
|
'exist. Note that it must be absolute path.')
|
|
cppflags.extend([
|
|
'-D__HAS_smm_dnn',
|
|
'-D__HAS_smm_vec',
|
|
])
|
|
libs.append('-lsmm')
|
|
|
|
elif 'smm=libxsmm' in spec:
|
|
cppflags += ['-D__LIBXSMM']
|
|
cppflags += pkgconf('--cflags-only-other', 'libxsmmf',
|
|
output=str).split()
|
|
fcflags += pkgconf('--cflags-only-I', 'libxsmmf',
|
|
output=str).split()
|
|
libs += pkgconf('--libs', 'libxsmmf', output=str).split()
|
|
|
|
if '+libvori' in spec:
|
|
cppflags += ['-D__LIBVORI']
|
|
libvori = spec['libvori'].libs
|
|
ldflags += [libvori.search_flags]
|
|
libs += libvori
|
|
libs += ['-lstdc++']
|
|
|
|
if '+spglib' in spec:
|
|
cppflags += ['-D__SPGLIB']
|
|
spglib = spec['spglib'].libs
|
|
ldflags += [spglib.search_flags]
|
|
libs += spglib
|
|
|
|
dflags.extend(cppflags)
|
|
cflags.extend(cppflags)
|
|
cxxflags.extend(cppflags)
|
|
fcflags.extend(cppflags)
|
|
nvflags.extend(cppflags)
|
|
|
|
with open(self.makefile, 'w') as mkf:
|
|
if '+plumed' in spec:
|
|
mkf.write('# include Plumed.inc as recommended by'
|
|
'PLUMED to include libraries and flags')
|
|
mkf.write('include {0}\n'.format(
|
|
spec['plumed'].package.plumed_inc
|
|
))
|
|
|
|
mkf.write('\n# COMPILER, LINKER, TOOLS\n\n')
|
|
mkf.write('FC = {0}\n'
|
|
'CC = {1}\n'
|
|
'CXX = {2}\n'
|
|
'LD = {3}\n'
|
|
.format(fc, cc, cxx, fc))
|
|
|
|
if '%intel' in spec:
|
|
intel_bin_dir = ancestor(self.compiler.cc)
|
|
# CPP is a commented command in Intel arch of CP2K
|
|
# This is the hack through which cp2k developers avoid doing :
|
|
#
|
|
# ${CPP} <file>.F > <file>.f90
|
|
#
|
|
# and use `-fpp` instead
|
|
mkf.write('CPP = # {0} -P\n'.format(spack_cc))
|
|
mkf.write('AR = {0}/xiar -r\n'.format(intel_bin_dir))
|
|
else:
|
|
mkf.write('CPP = # {0} -E\n'.format(spack_cc))
|
|
mkf.write('AR = ar -r\n')
|
|
|
|
if spec.satisfies('+cuda'):
|
|
mkf.write('NVCC = {0}\n'.format(
|
|
join_path(spec['cuda'].prefix, 'bin', 'nvcc')))
|
|
|
|
# Write compiler flags to file
|
|
def fflags(var, lst):
|
|
return '{0} = {1}\n\n'.format(
|
|
var,
|
|
' \\\n\t'.join(lst))
|
|
|
|
mkf.write('\n# FLAGS & LIBRARIES\n')
|
|
mkf.write(fflags('DFLAGS', dflags))
|
|
mkf.write(fflags('CPPFLAGS', cppflags))
|
|
mkf.write(fflags('CFLAGS', cflags))
|
|
mkf.write(fflags('CXXFLAGS', cxxflags))
|
|
mkf.write(fflags('NVFLAGS', nvflags))
|
|
mkf.write(fflags('FCFLAGS', fcflags))
|
|
mkf.write(fflags('LDFLAGS', ldflags))
|
|
mkf.write(fflags('LIBS', libs))
|
|
|
|
if '%intel' in spec:
|
|
mkf.write(fflags('LDFLAGS_C', ldflags + ['-nofor-main']))
|
|
|
|
mkf.write('# CP2K-specific flags\n\n')
|
|
mkf.write('GPUVER = {0}\n'.format(gpuver))
|
|
mkf.write('DATA_DIR = {0}\n'.format(self.prefix.share.data))
|
|
|
|
@property
|
|
def build_directory(self):
|
|
build_dir = self.stage.source_path
|
|
|
|
if self.spec.satisfies('@:6'):
|
|
# prior to version 7.1 was the Makefile located in makefiles/
|
|
build_dir = join_path(build_dir, 'makefiles')
|
|
|
|
return build_dir
|
|
|
|
@property
|
|
def build_targets(self):
|
|
return [
|
|
'ARCH={0}'.format(self.makefile_architecture),
|
|
'VERSION={0}'.format(self.makefile_version)
|
|
]
|
|
|
|
def build(self, spec, prefix):
|
|
if len(spec.variants['cuda_arch'].value) > 1:
|
|
raise InstallError("cp2k supports only one cuda_arch at a time")
|
|
|
|
# Apparently the Makefile bases its paths on PWD
|
|
# so we need to set PWD = self.build_directory
|
|
with spack.util.environment.set_env(PWD=self.build_directory):
|
|
super(Cp2k, self).build(spec, prefix)
|
|
|
|
def install(self, spec, prefix):
|
|
exe_dir = join_path('exe', self.makefile_architecture)
|
|
install_tree(exe_dir, self.prefix.bin)
|
|
install_tree('data', self.prefix.share.data)
|
|
|
|
def check(self):
|
|
data_dir = join_path(self.stage.source_path, 'data')
|
|
|
|
# CP2K < 7 still uses $PWD to detect the current working dir
|
|
# and Makefile is in a subdir, account for both facts here:
|
|
with spack.util.environment.set_env(CP2K_DATA_DIR=data_dir,
|
|
PWD=self.build_directory):
|
|
with working_dir(self.build_directory):
|
|
make('test', *self.build_targets)
|