summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--lib/spack/spack/build_systems/cached_cmake.py249
-rw-r--r--lib/spack/spack/pkgkit.py4
-rw-r--r--var/spack/repos/builtin/packages/axom/package.py540
-rw-r--r--var/spack/repos/builtin/packages/hdf5/package.py2
4 files changed, 357 insertions, 438 deletions
diff --git a/lib/spack/spack/build_systems/cached_cmake.py b/lib/spack/spack/build_systems/cached_cmake.py
deleted file mode 100644
index 0704a4aa09..0000000000
--- a/lib/spack/spack/build_systems/cached_cmake.py
+++ /dev/null
@@ -1,249 +0,0 @@
-# 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 os
-
-from llnl.util.filesystem import install, mkdirp
-import llnl.util.tty as tty
-
-from spack.build_systems.cmake import CMakePackage
-from spack.package import run_after
-
-
-def cmake_cache_path(name, value, comment=""):
- """Generate a string for a cmake cache variable"""
- return 'set({0} "{1}" CACHE PATH "{2}")\n'.format(name, value, comment)
-
-
-def cmake_cache_string(name, value, comment=""):
- """Generate a string for a cmake cache variable"""
- return 'set({0} "{1}" CACHE STRING "{2}")\n'.format(name, value, comment)
-
-
-def cmake_cache_option(name, boolean_value, comment=""):
- """Generate a string for a cmake configuration option"""
-
- value = "ON" if boolean_value else "OFF"
- return 'set({0} {1} CACHE BOOL "{2}")\n'.format(name, value, comment)
-
-
-class CachedCMakePackage(CMakePackage):
- """Specialized class for packages built using CMake initial cache.
-
- This feature of CMake allows packages to increase reproducibility,
- especially between Spack- and manual builds. It also allows packages to
- sidestep certain parsing bugs in extremely long ``cmake`` commands, and to
- avoid system limits on the length of the command line."""
-
- phases = ['initconfig', 'cmake', 'build', 'install']
-
- @property
- def cache_name(self):
- return "{0}-{1}-{2}@{3}.cmake".format(
- self.name,
- self.spec.architecture,
- self.spec.compiler.name,
- self.spec.compiler.version,
- )
-
- @property
- def cache_path(self):
- return os.path.join(self.stage.source_path, self.cache_name)
-
- def flag_handler(self, name, flags):
- if name in ('cflags', 'cxxflags', 'cppflags', 'fflags'):
- return (None, None, None) # handled in the cmake cache
- return (flags, None, None)
-
- def initconfig_compiler_entries(self):
- # This will tell cmake to use the Spack compiler wrappers when run
- # through Spack, but use the underlying compiler when run outside of
- # Spack
- spec = self.spec
-
- # Fortran compiler is optional
- if "FC" in os.environ:
- spack_fc_entry = cmake_cache_path(
- "CMAKE_Fortran_COMPILER", os.environ['FC'])
- system_fc_entry = cmake_cache_path(
- "CMAKE_Fortran_COMPILER", self.compiler.fc)
- else:
- spack_fc_entry = "# No Fortran compiler defined in spec"
- system_fc_entry = "# No Fortran compiler defined in spec"
-
- entries = [
- "#------------------{0}".format("-" * 60),
- "# Compilers",
- "#------------------{0}".format("-" * 60),
- "# Compiler Spec: {0}".format(spec.compiler),
- "#------------------{0}".format("-" * 60),
- 'if(DEFINED ENV{SPACK_CC})\n',
- ' ' + cmake_cache_path(
- "CMAKE_C_COMPILER", os.environ['CC']),
- ' ' + cmake_cache_path(
- "CMAKE_CXX_COMPILER", os.environ['CXX']),
- ' ' + spack_fc_entry,
- 'else()\n',
- ' ' + cmake_cache_path(
- "CMAKE_C_COMPILER", self.compiler.cc),
- ' ' + cmake_cache_path(
- "CMAKE_CXX_COMPILER", self.compiler.cxx),
- ' ' + system_fc_entry,
- 'endif()\n'
- ]
-
- # use global spack compiler flags
- cppflags = ' '.join(spec.compiler_flags['cppflags'])
- if cppflags:
- # avoid always ending up with ' ' with no flags defined
- cppflags += ' '
- cflags = cppflags + ' '.join(spec.compiler_flags['cflags'])
- if cflags:
- entries.append(cmake_cache_string("CMAKE_C_FLAGS", cflags))
- cxxflags = cppflags + ' '.join(spec.compiler_flags['cxxflags'])
- if cxxflags:
- entries.append(cmake_cache_string("CMAKE_CXX_FLAGS", cxxflags))
- fflags = ' '.join(spec.compiler_flags['fflags'])
- if fflags:
- entries.append(cmake_cache_string("CMAKE_Fortran_FLAGS", fflags))
-
- # Override XL compiler family
- familymsg = ("Override to proper compiler family for XL")
- if "xlf" in (self.compiler.fc or ''): # noqa: F821
- entries.append(cmake_cache_string(
- "CMAKE_Fortran_COMPILER_ID", "XL",
- familymsg))
- if "xlc" in self.compiler.cc: # noqa: F821
- entries.append(cmake_cache_string(
- "CMAKE_C_COMPILER_ID", "XL",
- familymsg))
- if "xlC" in self.compiler.cxx: # noqa: F821
- entries.append(cmake_cache_string(
- "CMAKE_CXX_COMPILER_ID", "XL",
- familymsg))
-
- return entries
-
- def initconfig_mpi_entries(self):
- spec = self.spec
-
- if "+mpi" not in spec:
- return []
-
- entries = [
- "#------------------{0}".format("-" * 60),
- "# MPI",
- "#------------------{0}\n".format("-" * 60),
- ]
-
- entries.append(cmake_cache_path("MPI_C_COMPILER",
- spec['mpi'].mpicc))
- entries.append(cmake_cache_path("MPI_CXX_COMPILER",
- spec['mpi'].mpicxx))
- entries.append(cmake_cache_path("MPI_Fortran_COMPILER",
- spec['mpi'].mpifc))
-
- # Check for slurm
- using_slurm = False
- slurm_checks = ['+slurm',
- 'schedulers=slurm',
- 'process_managers=slurm']
- if any(spec['mpi'].satisfies(variant) for variant in slurm_checks):
- using_slurm = True
-
- # Determine MPIEXEC
- if using_slurm:
- if spec['mpi'].external:
- # Heuristic until we have dependents on externals
- mpiexec = '/usr/bin/srun'
- else:
- mpiexec = os.path.join(spec['slurm'].prefix.bin, 'srun')
- else:
- mpiexec = os.path.join(spec['mpi'].prefix.bin, 'mpirun')
- if not os.path.exists(mpiexec):
- mpiexec = os.path.join(spec['mpi'].prefix.bin, 'mpiexec')
-
- if not os.path.exists(mpiexec):
- msg = "Unable to determine MPIEXEC, %s tests may fail" % self.name
- entries.append("# {0}\n".format(msg))
- tty.warn(msg)
- else:
- # starting with cmake 3.10, FindMPI expects MPIEXEC_EXECUTABLE
- # vs the older versions which expect MPIEXEC
- if self.spec["cmake"].satisfies('@3.10:'):
- entries.append(cmake_cache_path("MPIEXEC_EXECUTABLE",
- mpiexec))
- else:
- entries.append(cmake_cache_path("MPIEXEC", mpiexec))
-
- # Determine MPIEXEC_NUMPROC_FLAG
- if using_slurm:
- entries.append(cmake_cache_string("MPIEXEC_NUMPROC_FLAG", "-n"))
- else:
- entries.append(cmake_cache_string("MPIEXEC_NUMPROC_FLAG", "-np"))
-
- return entries
-
- def initconfig_hardware_entries(self):
- spec = self.spec
-
- entries = [
- "#------------------{0}".format("-" * 60),
- "# Hardware",
- "#------------------{0}\n".format("-" * 60),
- ]
-
- if '+cuda' in spec:
- entries.append("#------------------{0}".format("-" * 30))
- entries.append("# Cuda")
- entries.append("#------------------{0}\n".format("-" * 30))
-
- cudatoolkitdir = spec['cuda'].prefix
- entries.append(cmake_cache_path("CUDA_TOOLKIT_ROOT_DIR",
- cudatoolkitdir))
- cudacompiler = "${CUDA_TOOLKIT_ROOT_DIR}/bin/nvcc"
- entries.append(cmake_cache_path("CMAKE_CUDA_COMPILER",
- cudacompiler))
-
- if "+mpi" in spec:
- entries.append(cmake_cache_path("CMAKE_CUDA_HOST_COMPILER",
- "${MPI_CXX_COMPILER}"))
- else:
- entries.append(cmake_cache_path("CMAKE_CUDA_HOST_COMPILER",
- "${CMAKE_CXX_COMPILER}"))
-
- return entries
-
- def std_initconfig_entries(self):
- return [
- "#------------------{0}".format("-" * 60),
- "# !!!! This is a generated file, edit at own risk !!!!",
- "#------------------{0}".format("-" * 60),
- "# CMake executable path: {0}".format(
- self.spec['cmake'].command.path),
- "#------------------{0}\n".format("-" * 60),
- ]
-
- def initconfig(self, spec, prefix):
- cache_entries = (self.std_initconfig_entries() +
- self.initconfig_compiler_entries() +
- self.initconfig_mpi_entries() +
- self.initconfig_hardware_entries() +
- self.initconfig_package_entries())
-
- with open(self.cache_name, 'w') as f:
- for entry in cache_entries:
- f.write('%s\n' % entry)
- f.write('\n')
-
- @property
- def std_cmake_args(self):
- args = super(CachedCMakePackage, self).std_cmake_args
- args.extend(['-C', self.cache_path])
- return args
-
- @run_after('install')
- def install_cmake_cache(self):
- mkdirp(self.spec.prefix.share.cmake)
- install(self.cache_path, self.spec.prefix.share.cmake)
diff --git a/lib/spack/spack/pkgkit.py b/lib/spack/spack/pkgkit.py
index bc44d0b7b2..133a581e20 100644
--- a/lib/spack/spack/pkgkit.py
+++ b/lib/spack/spack/pkgkit.py
@@ -19,10 +19,6 @@ from spack.build_systems.makefile import MakefilePackage
from spack.build_systems.aspell_dict import AspellDictPackage
from spack.build_systems.autotools import AutotoolsPackage
from spack.build_systems.cmake import CMakePackage
-from spack.build_systems.cached_cmake import (
- CachedCMakePackage, cmake_cache_option, cmake_cache_path,
- cmake_cache_string
-)
from spack.build_systems.cuda import CudaPackage
from spack.build_systems.oneapi import IntelOneApiPackage
from spack.build_systems.oneapi import IntelOneApiLibraryPackage
diff --git a/var/spack/repos/builtin/packages/axom/package.py b/var/spack/repos/builtin/packages/axom/package.py
index a8609f2568..b15544ce68 100644
--- a/var/spack/repos/builtin/packages/axom/package.py
+++ b/var/spack/repos/builtin/packages/axom/package.py
@@ -9,6 +9,20 @@ import os
import socket
from os.path import join as pjoin
+import llnl.util.tty as tty
+
+
+def cmake_cache_entry(name, value, comment=""):
+ """Generate a string for a cmake cache variable"""
+ return 'set({0} "{1}" CACHE PATH "{2}")\n\n'.format(name, value, comment)
+
+
+def cmake_cache_option(name, boolean_value, comment=""):
+ """Generate a string for a cmake configuration option"""
+
+ value = "ON" if boolean_value else "OFF"
+ return 'set({0} {1} CACHE BOOL "{2}")\n\n'.format(name, value, comment)
+
def get_spec_path(spec, package_name, path_replacements={}, use_bin=False):
"""Extracts the prefix path for the given spack package
@@ -28,7 +42,7 @@ def get_spec_path(spec, package_name, path_replacements={}, use_bin=False):
return path
-class Axom(CachedCMakePackage, CudaPackage):
+class Axom(CMakePackage, CudaPackage):
"""Axom provides a robust, flexible software infrastructure for the development
of multi-physics applications and computational tools."""
@@ -46,6 +60,7 @@ class Axom(CachedCMakePackage, CudaPackage):
version('0.3.0', tag='v0.3.0', submodules=True)
version('0.2.9', tag='v0.2.9', submodules=True)
+ phases = ["hostconfig", "cmake", "build", "install"]
root_cmakelists_dir = 'src'
# -----------------------------------------------------------------------
@@ -56,7 +71,7 @@ class Axom(CachedCMakePackage, CudaPackage):
variant('debug', default=False,
description='Build debug instead of optimized version')
- variant('cpp14', default=True, description="Build with C++14 support")
+ variant('cpp14', default=True, description="Build with C++14 support")
variant('fortran', default=True, description="Build with Fortran support")
@@ -102,7 +117,7 @@ class Axom(CachedCMakePackage, CudaPackage):
depends_on("umpire~openmp", when="+umpire~openmp")
depends_on("umpire+openmp", when="+umpire+openmp")
- depends_on("umpire+cuda", when="+umpire+cuda")
+ depends_on("umpire+cuda+deviceconst", when="+umpire+cuda")
for sm_ in CudaPackage.cuda_arch_values:
depends_on('raja cuda_arch={0}'.format(sm_),
@@ -124,6 +139,12 @@ class Axom(CachedCMakePackage, CudaPackage):
depends_on("py-shroud", when="+devtools")
depends_on("llvm+clang@10.0.0", when="+devtools", type='build')
+ def flag_handler(self, name, flags):
+ if name in ('cflags', 'cxxflags', 'fflags'):
+ # the package manages these flags in another way
+ return (None, None, None)
+ return (flags, None, None)
+
def _get_sys_type(self, spec):
sys_type = spec.architecture
# if on llnl systems, we can use the SYS_TYPE
@@ -131,159 +152,108 @@ class Axom(CachedCMakePackage, CudaPackage):
sys_type = env["SYS_TYPE"]
return sys_type
- @property
- def cache_name(self):
+ def _get_host_config_path(self, spec):
hostname = socket.gethostname()
if "SYS_TYPE" in env:
# Are we on a LLNL system then strip node number
hostname = hostname.rstrip('1234567890')
- return "{0}-{1}-{2}@{3}.cmake".format(
- hostname,
- self._get_sys_type(self.spec),
- self.spec.compiler.name,
- self.spec.compiler.version
- )
-
- def initconfig_compiler_entries(self):
- spec = self.spec
- entries = super(Axom, self).initconfig_compiler_entries()
-
- if "+fortran" in spec or self.compiler.fc is not None:
- entries.append(cmake_cache_option("ENABLE_FORTRAN", True))
+ filename = "{0}-{1}-{2}.cmake".format(hostname,
+ self._get_sys_type(spec),
+ spec.compiler)
+ dest_dir = self.stage.source_path
+ fullpath = os.path.abspath(pjoin(dest_dir, filename))
+ return fullpath
+
+ def hostconfig(self, spec, prefix):
+ """
+ This method creates a 'host-config' file that specifies
+ all of the options used to configure and build Axom.
+ """
+
+ c_compiler = env["SPACK_CC"]
+ cpp_compiler = env["SPACK_CXX"]
+ f_compiler = None
+
+ # see if we should enable fortran support
+ if "SPACK_FC" in env.keys():
+ # even if this is set, it may not exist
+ # do one more sanity check
+ if os.path.isfile(env["SPACK_FC"]):
+ f_compiler = env["SPACK_FC"]
+
+ # cmake
+ if "+cmake" in spec:
+ cmake_exe = pjoin(spec['cmake'].prefix.bin, "cmake")
else:
- entries.append(cmake_cache_option("ENABLE_FORTRAN", False))
-
- if ((self.compiler.fc is not None)
- and ("gfortran" in self.compiler.fc)
- and ("clang" in self.compiler.cxx)):
+ cmake_exe = which("cmake")
+ if cmake_exe is None:
+ # error could not find cmake!
+ crash()
+ cmake_exe = cmake_exe.command
+ cmake_exe = os.path.realpath(cmake_exe)
+
+ host_config_path = self._get_host_config_path(spec)
+ cfg = open(host_config_path, "w")
+ cfg.write("#------------------{0}\n".format("-" * 60))
+ cfg.write("# !!!! This is a generated file, edit at own risk !!!!\n")
+ cfg.write("#------------------{0}\n".format("-" * 60))
+ cfg.write("# SYS_TYPE: {0}\n".format(self._get_sys_type(spec)))
+ cfg.write("# Compiler Spec: {0}\n".format(spec.compiler))
+ cfg.write("#------------------{0}\n".format("-" * 60))
+ # show path to cmake for reference and to be used by config-build.py
+ cfg.write("# CMake executable path: {0}\n".format(cmake_exe))
+ cfg.write("#------------------{0}\n\n".format("-" * 60))
+
+ # compiler settings
+ cfg.write("#------------------{0}\n".format("-" * 60))
+ cfg.write("# Compilers\n")
+ cfg.write("#------------------{0}\n\n".format("-" * 60))
+
+ cfg.write(cmake_cache_entry("CMAKE_C_COMPILER", c_compiler))
+ cfg.write(cmake_cache_entry("CMAKE_CXX_COMPILER", cpp_compiler))
+
+ if "+fortran" in spec or f_compiler is not None:
+ cfg.write(cmake_cache_option("ENABLE_FORTRAN", True))
+ cfg.write(cmake_cache_entry("CMAKE_Fortran_COMPILER", f_compiler))
+ else:
+ cfg.write(cmake_cache_option("ENABLE_FORTRAN", False))
+
+ # use global spack compiler flags
+ cppflags = ' '.join(spec.compiler_flags['cppflags'])
+ if cppflags:
+ # avoid always ending up with ' ' with no flags defined
+ cppflags += ' '
+ cflags = cppflags + ' '.join(spec.compiler_flags['cflags'])
+ if cflags:
+ cfg.write(cmake_cache_entry("CMAKE_C_FLAGS", cflags))
+ cxxflags = cppflags + ' '.join(spec.compiler_flags['cxxflags'])
+ if cxxflags:
+ cfg.write(cmake_cache_entry("CMAKE_CXX_FLAGS", cxxflags))
+ fflags = ' '.join(spec.compiler_flags['fflags'])
+ if fflags:
+ cfg.write(cmake_cache_entry("CMAKE_Fortran_FLAGS", fflags))
+
+ if ((f_compiler is not None)
+ and ("gfortran" in f_compiler)
+ and ("clang" in cpp_compiler)):
libdir = pjoin(os.path.dirname(
- os.path.dirname(self.compiler.cxx)), "lib")
+ os.path.dirname(cpp_compiler)), "lib")
flags = ""
for _libpath in [libdir, libdir + "64"]:
if os.path.exists(_libpath):
flags += " -Wl,-rpath,{0}".format(_libpath)
description = ("Adds a missing libstdc++ rpath")
if flags:
- entries.append(cmake_cache_string("BLT_EXE_LINKER_FLAGS", flags,
- description))
+ cfg.write(cmake_cache_entry("BLT_EXE_LINKER_FLAGS", flags,
+ description))
if "+cpp14" in spec:
- entries.append(cmake_cache_string("BLT_CXX_STD", "c++14", ""))
-
- return entries
-
- def initconfig_hardware_entries(self):
- spec = self.spec
- entries = super(Axom, self).initconfig_hardware_entries()
-
- if spec.satisfies('target=ppc64le:'):
- if "+cuda" in spec:
- entries.append(cmake_cache_option("ENABLE_CUDA", True))
- entries.append(cmake_cache_option("CUDA_SEPARABLE_COMPILATION",
- True))
-
- entries.append(
- cmake_cache_option("AXOM_ENABLE_ANNOTATIONS", True))
-
- # CUDA_FLAGS
- cudaflags = "-restrict --expt-extended-lambda "
-
- if not spec.satisfies('cuda_arch=none'):
- cuda_arch = spec.variants['cuda_arch'].value[0]
- entries.append(cmake_cache_string(
- "CMAKE_CUDA_ARCHITECTURES",
- cuda_arch))
- cudaflags += '-arch sm_${CMAKE_CUDA_ARCHITECTURES} '
- else:
- entries.append(
- "# cuda_arch could not be determined\n\n")
-
- if "+cpp14" in spec:
- cudaflags += " -std=c++14"
- else:
- cudaflags += " -std=c++11"
- entries.append(
- cmake_cache_string("CMAKE_CUDA_FLAGS", cudaflags))
-
- entries.append(
- "# nvcc does not like gtest's 'pthreads' flag\n")
- entries.append(
- cmake_cache_option("gtest_disable_pthreads", True))
-
- entries.append("#------------------{0}".format("-" * 30))
- entries.append("# Hardware Specifics")
- entries.append("#------------------{0}\n".format("-" * 30))
-
- # OpenMP
- entries.append(cmake_cache_option("ENABLE_OPENMP",
- spec.satisfies('+openmp')))
-
- # Enable death tests
- entries.append(cmake_cache_option(
- "ENABLE_GTEST_DEATH_TESTS",
- not spec.satisfies('+cuda target=ppc64le:')
- ))
-
- if spec.satisfies('target=ppc64le:'):
- if (self.compiler.fc is not None) and ("xlf" in self.compiler.fc):
- description = ("Converts C-style comments to Fortran style "
- "in preprocessed files")
- entries.append(cmake_cache_string(
- "BLT_FORTRAN_FLAGS",
- "-WF,-C! -qxlf2003=polymorphic",
- description))
- # Grab lib directory for the current fortran compiler
- libdir = pjoin(os.path.dirname(
- os.path.dirname(self.compiler.fc)),
- "lib")
- description = ("Adds a missing rpath for libraries "
- "associated with the fortran compiler")
- linker_flags = "${BLT_EXE_LINKER_FLAGS} -Wl,-rpath," + libdir
- entries.append(cmake_cache_string("BLT_EXE_LINKER_FLAGS",
- linker_flags, description))
- if "+shared" in spec:
- linker_flags = "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-rpath," \
- + libdir
- entries.append(cmake_cache_string(
- "CMAKE_SHARED_LINKER_FLAGS",
- linker_flags, description))
-
- # Fix for working around CMake adding implicit link directories
- # returned by the BlueOS compilers to link executables with
- # non-system default stdlib
- _gcc_prefix = "/usr/tce/packages/gcc/gcc-4.9.3/lib64"
- if os.path.exists(_gcc_prefix):
- _gcc_prefix2 = pjoin(
- _gcc_prefix,
- "gcc/powerpc64le-unknown-linux-gnu/4.9.3")
- _link_dirs = "{0};{1}".format(_gcc_prefix, _gcc_prefix2)
- entries.append(cmake_cache_string(
- "BLT_CMAKE_IMPLICIT_LINK_DIRECTORIES_EXCLUDE", _link_dirs))
-
- return entries
-
- def initconfig_mpi_entries(self):
- spec = self.spec
- entries = super(Axom, self).initconfig_mpi_entries()
-
- if "+mpi" in spec:
- entries.append(cmake_cache_option("ENABLE_MPI", True))
- if spec['mpi'].name == 'spectrum-mpi':
- entries.append(cmake_cache_string("BLT_MPI_COMMAND_APPEND",
- "mpibind"))
- else:
- entries.append(cmake_cache_option("ENABLE_MPI", False))
-
- return entries
-
- def initconfig_package_entries(self):
- spec = self.spec
- entries = []
+ cfg.write(cmake_cache_entry("BLT_CXX_STD", "c++14", ""))
# TPL locations
- entries.append("#------------------{0}".format("-" * 60))
- entries.append("# TPLs")
- entries.append("#------------------{0}\n".format("-" * 60))
+ cfg.write("#------------------{0}\n".format("-" * 60))
+ cfg.write("# TPLs\n")
+ cfg.write("#------------------{0}\n\n".format("-" * 60))
# Try to find the common prefix of the TPL directory, including the
# compiler. If found, we will use this in the TPL paths
@@ -294,28 +264,113 @@ class Axom(CachedCMakePackage, CudaPackage):
if len(prefix_paths) == 2:
tpl_root = os.path.realpath(pjoin(prefix_paths[0], compiler_str))
path_replacements[tpl_root] = "${TPL_ROOT}"
- entries.append("# Root directory for generated TPLs\n")
- entries.append(cmake_cache_path("TPL_ROOT", tpl_root))
+ cfg.write("# Root directory for generated TPLs\n")
+ cfg.write(cmake_cache_entry("TPL_ROOT", tpl_root))
conduit_dir = get_spec_path(spec, "conduit", path_replacements)
- entries.append(cmake_cache_path("CONDUIT_DIR", conduit_dir))
+ cfg.write(cmake_cache_entry("CONDUIT_DIR", conduit_dir))
# optional tpls
- for dep in ('mfem', 'hdf5', 'lua', 'scr', 'raja', 'umpire'):
- if '+%s' % dep in spec:
- dep_dir = get_spec_path(spec, dep, path_replacements)
- entries.append(cmake_cache_path('%s_DIR' % dep.upper(),
- dep_dir))
+
+ if "+mfem" in spec:
+ mfem_dir = get_spec_path(spec, "mfem", path_replacements)
+ cfg.write(cmake_cache_entry("MFEM_DIR", mfem_dir))
+ else:
+ cfg.write("# MFEM not built\n\n")
+
+ if "+hdf5" in spec:
+ hdf5_dir = get_spec_path(spec, "hdf5", path_replacements)
+ cfg.write(cmake_cache_entry("HDF5_DIR", hdf5_dir))
+ else:
+ cfg.write("# HDF5 not built\n\n")
+
+ if "+lua" in spec:
+ lua_dir = get_spec_path(spec, "lua", path_replacements)
+ cfg.write(cmake_cache_entry("LUA_DIR", lua_dir))
+ else:
+ cfg.write("# Lua not built\n\n")
+
+ if "+scr" in spec:
+ scr_dir = get_spec_path(spec, "scr", path_replacements)
+ cfg.write(cmake_cache_entry("SCR_DIR", scr_dir))
+ else:
+ cfg.write("# SCR not built\n\n")
+
+ if "+raja" in spec:
+ raja_dir = get_spec_path(spec, "raja", path_replacements)
+ cfg.write(cmake_cache_entry("RAJA_DIR", raja_dir))
+ else:
+ cfg.write("# RAJA not built\n\n")
+
+ if "+umpire" in spec:
+ umpire_dir = get_spec_path(spec, "umpire", path_replacements)
+ cfg.write(cmake_cache_entry("UMPIRE_DIR", umpire_dir))
+ else:
+ cfg.write("# Umpire not built\n\n")
+
+ cfg.write("#------------------{0}\n".format("-" * 60))
+ cfg.write("# MPI\n")
+ cfg.write("#------------------{0}\n\n".format("-" * 60))
+
+ if "+mpi" in spec:
+ cfg.write(cmake_cache_option("ENABLE_MPI", True))
+ cfg.write(cmake_cache_entry("MPI_C_COMPILER", spec['mpi'].mpicc))
+ cfg.write(cmake_cache_entry("MPI_CXX_COMPILER",
+ spec['mpi'].mpicxx))
+ if "+fortran" in spec or f_compiler is not None:
+ cfg.write(cmake_cache_entry("MPI_Fortran_COMPILER",
+ spec['mpi'].mpifc))
+
+ # Check for slurm
+ using_slurm = False
+ slurm_checks = ['+slurm',
+ 'schedulers=slurm',
+ 'process_managers=slurm']
+ if any(spec['mpi'].satisfies(variant) for variant in slurm_checks):
+ using_slurm = True
+
+ # Determine MPIEXEC
+ if using_slurm:
+ if spec['mpi'].external:
+ mpiexec = '/usr/bin/srun'
+ else:
+ mpiexec = os.path.join(spec['slurm'].prefix.bin, 'srun')
+ else:
+ mpiexec = os.path.join(spec['mpi'].prefix.bin, 'mpirun')
+ if not os.path.exists(mpiexec):
+ mpiexec = os.path.join(spec['mpi'].prefix.bin, 'mpiexec')
+
+ if not os.path.exists(mpiexec):
+ msg = "Unable to determine MPIEXEC, Axom tests may fail"
+ cfg.write("# {0}\n\n".format(msg))
+ tty.msg(msg)
+ else:
+ # starting with cmake 3.10, FindMPI expects MPIEXEC_EXECUTABLE
+ # vs the older versions which expect MPIEXEC
+ if self.spec["cmake"].satisfies('@3.10:'):
+ cfg.write(cmake_cache_entry("MPIEXEC_EXECUTABLE", mpiexec))
+ else:
+ cfg.write(cmake_cache_entry("MPIEXEC", mpiexec))
+
+ # Determine MPIEXEC_NUMPROC_FLAG
+ if using_slurm:
+ cfg.write(cmake_cache_entry("MPIEXEC_NUMPROC_FLAG", "-n"))
else:
- entries.append('# %s not build\n' % dep.upper())
+ cfg.write(cmake_cache_entry("MPIEXEC_NUMPROC_FLAG", "-np"))
+
+ if spec['mpi'].name == 'spectrum-mpi':
+ cfg.write(cmake_cache_entry("BLT_MPI_COMMAND_APPEND",
+ "mpibind"))
+ else:
+ cfg.write(cmake_cache_option("ENABLE_MPI", False))
##################################
# Devtools
##################################
- entries.append("#------------------{0}".format("-" * 60))
- entries.append("# Devtools")
- entries.append("#------------------{0}\n".format("-" * 60))
+ cfg.write("#------------------{0}\n".format("-" * 60))
+ cfg.write("# Devtools\n")
+ cfg.write("#------------------{0}\n\n".format("-" * 60))
# Add common prefix to path replacement list
if "+devtools" in spec:
@@ -324,59 +379,176 @@ class Axom(CachedCMakePackage, CudaPackage):
path2 = os.path.realpath(spec["doxygen"].prefix)
devtools_root = os.path.commonprefix([path1, path2])[:-1]
path_replacements[devtools_root] = "${DEVTOOLS_ROOT}"
- entries.append(
- "# Root directory for generated developer tools\n")
- entries.append(cmake_cache_path("DEVTOOLS_ROOT", devtools_root))
-
- # Only turn on clangformat support if devtools is on
- clang_fmt_path = spec['llvm'].prefix.bin.join('clang-format')
- entries.append(cmake_cache_path(
- "CLANGFORMAT_EXECUTABLE", clang_fmt_path))
- else:
- entries.append("# ClangFormat disabled due to disabled devtools\n")
- entries.append(cmake_cache_option("ENABLE_CLANGFORMAT", False))
+ cfg.write("# Root directory for generated developer tools\n")
+ cfg.write(cmake_cache_entry("DEVTOOLS_ROOT", devtools_root))
if "+python" in spec or "+devtools" in spec:
python_path = os.path.realpath(spec['python'].command.path)
for key in path_replacements:
python_path = python_path.replace(key, path_replacements[key])
- entries.append(cmake_cache_path("PYTHON_EXECUTABLE", python_path))
-
- enable_docs = "doxygen" in spec or "py-sphinx" in spec
- entries.append(cmake_cache_option("ENABLE_DOCS", enable_docs))
-
- if "py-sphinx" in spec:
- python_bin_dir = get_spec_path(spec, "python",
- path_replacements,
- use_bin=True)
- entries.append(cmake_cache_path("SPHINX_EXECUTABLE",
+ cfg.write(cmake_cache_entry("PYTHON_EXECUTABLE", python_path))
+
+ if "doxygen" in spec or "py-sphinx" in spec:
+ cfg.write(cmake_cache_option("ENABLE_DOCS", True))
+
+ if "doxygen" in spec:
+ doxygen_bin_dir = get_spec_path(spec, "doxygen",
+ path_replacements,
+ use_bin=True)
+ cfg.write(cmake_cache_entry("DOXYGEN_EXECUTABLE",
+ pjoin(doxygen_bin_dir,
+ "doxygen")))
+
+ if "py-sphinx" in spec:
+ python_bin_dir = get_spec_path(spec, "python",
+ path_replacements,
+ use_bin=True)
+ cfg.write(cmake_cache_entry("SPHINX_EXECUTABLE",
pjoin(python_bin_dir,
"sphinx-build")))
+ else:
+ cfg.write(cmake_cache_option("ENABLE_DOCS", False))
if "py-shroud" in spec:
shroud_bin_dir = get_spec_path(spec, "py-shroud",
path_replacements, use_bin=True)
- entries.append(cmake_cache_path("SHROUD_EXECUTABLE",
- pjoin(shroud_bin_dir, "shroud")))
+ cfg.write(cmake_cache_entry("SHROUD_EXECUTABLE",
+ pjoin(shroud_bin_dir, "shroud")))
+
+ if "cppcheck" in spec:
+ cppcheck_bin_dir = get_spec_path(spec, "cppcheck",
+ path_replacements, use_bin=True)
+ cfg.write(cmake_cache_entry("CPPCHECK_EXECUTABLE",
+ pjoin(cppcheck_bin_dir, "cppcheck")))
+
+ # Only turn on clangformat support if devtools is on
+ if "+devtools" in spec:
+ clang_fmt_path = spec['llvm'].prefix.bin.join('clang-format')
+ cfg.write(cmake_cache_entry("CLANGFORMAT_EXECUTABLE",
+ clang_fmt_path))
+ else:
+ cfg.write("# ClangFormat disabled due to disabled devtools\n")
+ cfg.write(cmake_cache_option("ENABLE_CLANGFORMAT", False))
- for dep in ('uncrustify', 'cppcheck', 'doxygen'):
- if dep in spec:
- dep_bin_dir = get_spec_path(spec, dep, path_replacements,
- use_bin=True)
- entries.append(cmake_cache_path('%s_EXECUTABLE' % dep.upper(),
- pjoin(dep_bin_dir, dep)))
+ ##################################
+ # Other machine specifics
+ ##################################
- return entries
+ cfg.write("#------------------{0}\n".format("-" * 60))
+ cfg.write("# Other machine specifics\n")
+ cfg.write("#------------------{0}\n\n".format("-" * 60))
+
+ # OpenMP
+ if "+openmp" in spec:
+ cfg.write(cmake_cache_option("ENABLE_OPENMP", True))
+ else:
+ cfg.write(cmake_cache_option("ENABLE_OPENMP", False))
+
+ # Enable death tests
+ if spec.satisfies('target=ppc64le:') and "+cuda" in spec:
+ cfg.write(cmake_cache_option("ENABLE_GTEST_DEATH_TESTS", False))
+ else:
+ cfg.write(cmake_cache_option("ENABLE_GTEST_DEATH_TESTS", True))
+
+ # Override XL compiler family
+ familymsg = ("Override to proper compiler family for XL")
+ if (f_compiler is not None) and ("xlf" in f_compiler):
+ cfg.write(cmake_cache_entry("CMAKE_Fortran_COMPILER_ID", "XL",
+ familymsg))
+ if "xlc" in c_compiler:
+ cfg.write(cmake_cache_entry("CMAKE_C_COMPILER_ID", "XL",
+ familymsg))
+ if "xlC" in cpp_compiler:
+ cfg.write(cmake_cache_entry("CMAKE_CXX_COMPILER_ID", "XL",
+ familymsg))
+
+ if spec.satisfies('target=ppc64le:'):
+ if (f_compiler is not None) and ("xlf" in f_compiler):
+ description = ("Converts C-style comments to Fortran style "
+ "in preprocessed files")
+ cfg.write(cmake_cache_entry("BLT_FORTRAN_FLAGS",
+ "-WF,-C! -qxlf2003=polymorphic",
+ description))
+ # Grab lib directory for the current fortran compiler
+ libdir = os.path.join(os.path.dirname(
+ os.path.dirname(f_compiler)), "lib")
+ description = ("Adds a missing rpath for libraries "
+ "associated with the fortran compiler")
+ linker_flags = "${BLT_EXE_LINKER_FLAGS} -Wl,-rpath," + libdir
+ cfg.write(cmake_cache_entry("BLT_EXE_LINKER_FLAGS",
+ linker_flags, description))
+ if "+shared" in spec:
+ linker_flags = "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-rpath," \
+ + libdir
+ cfg.write(cmake_cache_entry("CMAKE_SHARED_LINKER_FLAGS",
+ linker_flags, description))
+
+ if "+cuda" in spec:
+ cfg.write("#------------------{0}\n".format("-" * 60))
+ cfg.write("# Cuda\n")
+ cfg.write("#------------------{0}\n\n".format("-" * 60))
+
+ cfg.write(cmake_cache_option("ENABLE_CUDA", True))
+
+ cudatoolkitdir = spec['cuda'].prefix
+ cfg.write(cmake_cache_entry("CUDA_TOOLKIT_ROOT_DIR",
+ cudatoolkitdir))
+ cudacompiler = "${CUDA_TOOLKIT_ROOT_DIR}/bin/nvcc"
+ cfg.write(cmake_cache_entry("CMAKE_CUDA_COMPILER",
+ cudacompiler))
+
+ cfg.write(cmake_cache_option("CUDA_SEPARABLE_COMPILATION",
+ True))
+
+ cfg.write(cmake_cache_option("AXOM_ENABLE_ANNOTATIONS", True))
+
+ # CUDA_FLAGS
+ cudaflags = "-restrict "
+
+ if not spec.satisfies('cuda_arch=none'):
+ cuda_arch = spec.variants['cuda_arch'].value
+ axom_arch = 'sm_{0}'.format(cuda_arch[0])
+ cfg.write(cmake_cache_entry("AXOM_CUDA_ARCH", axom_arch))
+ cudaflags += "-arch ${AXOM_CUDA_ARCH} "
+ else:
+ cfg.write("# cuda_arch could not be determined\n\n")
+
+ cudaflags += "-std=c++11 --expt-extended-lambda -G "
+ cfg.write(cmake_cache_entry("CMAKE_CUDA_FLAGS", cudaflags))
+
+ if "+mpi" in spec:
+ cfg.write(cmake_cache_entry("CMAKE_CUDA_HOST_COMPILER",
+ "${MPI_CXX_COMPILER}"))
+ else:
+ cfg.write(cmake_cache_entry("CMAKE_CUDA_HOST_COMPILER",
+ "${CMAKE_CXX_COMPILER}"))
+
+ cfg.write("# nvcc does not like gtest's 'pthreads' flag\n")
+ cfg.write(cmake_cache_option("gtest_disable_pthreads", True))
+
+ cfg.write("\n")
+ cfg.close()
+ tty.info("Spack generated Axom host-config file: " + host_config_path)
def cmake_args(self):
+ spec = self.spec
+ host_config_path = self._get_host_config_path(spec)
+
options = []
+ options.extend(['-C', host_config_path])
if self.run_tests is False:
options.append('-DENABLE_TESTS=OFF')
else:
options.append('-DENABLE_TESTS=ON')
- options.append(self.define_from_variant(
- 'BUILD_SHARED_LIBS', 'shared'))
+ if "+shared" in spec:
+ options.append('-DBUILD_SHARED_LIBS=ON')
+ else:
+ options.append('-DBUILD_SHARED_LIBS=OFF')
return options
+
+ @run_after('install')
+ def install_cmake_cache(self):
+ install(self._get_host_config_path(self.spec), prefix)
diff --git a/var/spack/repos/builtin/packages/hdf5/package.py b/var/spack/repos/builtin/packages/hdf5/package.py
index 01c1428766..8425242b53 100644
--- a/var/spack/repos/builtin/packages/hdf5/package.py
+++ b/var/spack/repos/builtin/packages/hdf5/package.py
@@ -245,7 +245,7 @@ class Hdf5(AutotoolsPackage):
# sanity check in configure, so this doesn't merit a variant.
extra_args = ['--enable-unsupported',
'--enable-symbols=yes',
- '--with-zlib=%s' % self.spec['zlib'].prefix]
+ '--with-zlib']
extra_args += self.enable_or_disable('threadsafe')
extra_args += self.enable_or_disable('cxx')
extra_args += self.enable_or_disable('hl')