HPCE/spack-psi
0
0
Fork 0
Code Issues Pull Requests Actions 4 Packages Projects Releases Wiki Activity

ADD: own version of cp2k (fix oneapi)

Browse Source
This commit is contained in:
Germann Elsa Sylvia
2022-10-04 16:01:08 +02:00
parent 6a880c9bc5
commit d135d8cc45
3 changed files with 799 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files

792
env/merlin/all/packages/cp2k/package.py vendored Normal file
View File

@ -0,0 +1,792 @@
# Copyright 2013-2022 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
from spack.package import *
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("2022.1", sha256="2c34f1a7972973c62d471cd35856f444f11ab22f2ff930f6ead20f3454fd228b")
version("9.1", sha256="fedb4c684a98ad857cd49b69a3ae51a73f85a9c36e9cb63e3b02320c74454ce6")
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")
with when("+cuda"):
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,
when="@:7", # req in CP2K v8+
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("cray-fftw+openmp", when="^cray-fftw")
depends_on("openblas threads=openmp", when="^openblas")
# The Cray compiler wrappers will automatically add libsci_mp with
# -fopenmp. Since CP2K unconditionally links blas/lapack/scalapack
# we have to be consistent.
depends_on("cray-libsci+openmp", when="^cray-libsci")
with when("smm=libxsmm"):
depends_on("libxsmm@1.17:~header-only", when="@9.1:")
# require libxsmm-1.11+ since 1.10 can leak file descriptors in Fortran
depends_on("libxsmm@1.11:~header-only", when="@:8.9")
# 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:8")
depends_on("libxc@5.1.7:5.1", when="@9:")
with when("+mpi"):
depends_on("mpi@2:")
depends_on("scalapack")
with when("+cosma"):
depends_on("cosma+scalapack")
depends_on("cosma@2.5.1:", when="@9:")
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:")
depends_on("elpa@2021.11.001:", when="@9.1:")
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:8.9")
depends_on("sirius@7.3:", when="@9.1")
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")
# 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?full_index=1",
sha256="3617abb877812c4b933f601438c70f95e21c6161bea177277b1d4125fd1c0bf9",
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",
],
"oneapi": [
"-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" or "%oneapi" 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" or "%oneapi" 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.libs.directories[0],
(
"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 "+cuda" in spec and "+cuda" in elpa:
cppflags += ["-D__ELPA_NVIDIA_GPU"]
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"):
libs += [
"-L{}".format(spec["cuda"].libs.directories[0]),
"-L{}/stubs".format(spec["cuda"].libs.directories[0]),
"-lcuda",
"-lcudart",
"-lnvrtc",
"-lstdc++",
]
if spec.satisfies("@9:"):
acc_compiler_var = "OFFLOAD_CC"
acc_flags_var = "OFFLOAD_FLAGS"
cppflags += [
"-D__DBCSR_ACC",
"-D__GRID_CUDA",
"-DOFFLOAD_TARGET=cuda",
]
libs += ["-lcublas"]
else:
acc_compiler_var = "NVCC"
acc_flags_var = "NVFLAGS"
cppflags += ["-D__ACC"]
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 "+cuda" in spec:
mkf.write(
"{0} = {1}\n".format(
acc_compiler_var, 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))
if "+cuda" in spec:
mkf.write(fflags(acc_flags_var, nvflags))
mkf.write(fflags("FCFLAGS", fcflags))
mkf.write(fflags("LDFLAGS", ldflags))
mkf.write(fflags("LIBS", libs))
if "%intel" or "%oneapi" 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 "+cuda" in spec and 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)
with working_dir(self.build_directory):
make("libcp2k", *self.build_targets)
def install(self, spec, prefix):
exe_dir = join_path("exe", self.makefile_architecture)
lib_dir = join_path("lib", self.makefile_architecture, self.makefile_version)
install_tree(exe_dir, self.prefix.bin)
install_tree("data", self.prefix.share.data)
install_tree(lib_dir, self.prefix.lib)
mkdirp(self.prefix.include)
install("src/start/libcp2k.h", join_path(self.prefix.include, "libcp2k.h"))
@run_after("install")
def fix_package_config(self):
"""
Default build procedure generates libcp2k.pc with invalid paths,
because they are collected from temporary directory.
Ignoring invalid paths, most library-related switches are correct
except for fftw and openblas.
This procedure is appending two missing switches (tested with GROMACS 2022.2 + CP2K).
In case such approach causes issues in the future, it might be necessary
to generate and override entire libcp2k.pc.
"""
if self.spec.satisfies("@9.1:"):
with open(join_path(self.prefix.lib.pkgconfig, "libcp2k.pc"), "r+") as handle:
content = handle.read().rstrip()
content += " " + self.spec["blas"].libs.ld_flags
content += " " + self.spec["lapack"].libs.ld_flags
content += " " + self.spec["fftw-api"].libs.ld_flags
if "^fftw+openmp" in self.spec:
content += " -lfftw3_omp"
content += "\n"
handle.seek(0)
handle.write(content)
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)

2
env/merlin/all/repo.yaml vendored Normal file
View File

@ -0,0 +1,2 @@
repo:
namespace: all

8
env/merlin/all/spack.yaml vendored
View File

@ -150,9 +150,11 @@ spack:
- xmlto
- xz
include:
- sysconfigs/config.yaml
- sysconfigs/compilers.yaml
- sysconfigs/packages.yaml
- sysconfigs/config.yaml
- sysconfigs/compilers.yaml
- sysconfigs/packages.yaml
repos:
- .
#>>> modules.yaml
modules:
Batchsystem: