Update entrypoint.bash

Signed-off-by: Terry Cojean <terry.cojean@kit.edu>

CHANGELOG.md

@@ -1,290 +1,3 @@
-# v0.21.0 (2023-11-11)
-
-`v0.21.0` is a major feature release.
-
-## Features in this release
-
-1. **Better error messages with condition chaining**
-
-   In v0.18, we added better error messages that could tell you what problem happened,
-   but they couldn't tell you *why* it happened. `0.21` adds *condition chaining* to the
-   solver, and Spack can now trace back through the conditions that led to an error and
-   build a tree of causes potential causes and where they came from. For example:
-
-   ```console
-   $ spack solve hdf5 ^cmake@3.0.1
-   ==> Error: concretization failed for the following reasons:
-
-      1. Cannot satisfy 'cmake@3.0.1'
-      2. Cannot satisfy 'cmake@3.0.1'
-           required because hdf5 ^cmake@3.0.1 requested from CLI
-      3. Cannot satisfy 'cmake@3.18:' and 'cmake@3.0.1
-           required because hdf5 ^cmake@3.0.1 requested from CLI
-           required because hdf5 depends on cmake@3.18: when @1.13:
-             required because hdf5 ^cmake@3.0.1 requested from CLI
-      4. Cannot satisfy 'cmake@3.12:' and 'cmake@3.0.1
-           required because hdf5 depends on cmake@3.12:
-             required because hdf5 ^cmake@3.0.1 requested from CLI
-           required because hdf5 ^cmake@3.0.1 requested from CLI
-   ```
-
-   More details in #40173.
-
-2. **OCI build caches**
-
-   You can now use an arbitrary [OCI](https://opencontainers.org) registry as a build
-   cache:
-
-   ```console
-   $ spack mirror add my_registry oci://user/image # Dockerhub
-   $ spack mirror add my_registry oci://ghcr.io/haampie/spack-test # GHCR
-   $ spack mirror set --push --oci-username ... --oci-password ... my_registry  # set login creds
-   $ spack buildcache push my_registry [specs...]
-   ```
-
-   And you can optionally add a base image to get *runnable* images:
-
-   ```console
-   $ spack buildcache push --base-image ubuntu:23.04 my_registry python
-   Pushed ... as [image]:python-3.11.2-65txfcpqbmpawclvtasuog4yzmxwaoia.spack
-
-   $ docker run --rm -it [image]:python-3.11.2-65txfcpqbmpawclvtasuog4yzmxwaoia.spack
-   ```
-
-   This creates a container image from the Spack installations on the host system,
-   without the need to run `spack install` from a `Dockerfile` or `sif` file. It also
-   addresses the inconvenience of losing binaries of dependencies when `RUN spack
-   install` fails inside `docker build`.
-
-   Further, the container image layers and build cache tarballs are the same files. This
-   means that `spack install` and `docker pull` use the exact same underlying binaries.
-   If you previously used `spack install` inside of `docker build`, this feature helps
-   you save storage by a factor two.
-
-   More details in #38358.
-
-3. **Multiple versions of build dependencies**
-
-   Increasingly, complex package builds require multiple versions of some build
-   dependencies. For example, Python packages frequently require very specific versions
-   of `setuptools`, `cython`, and sometimes different physics packages require different
-   versions of Python to build. The concretizer enforced that every solve was *unified*,
-   i.e., that there only be one version of every package. The concretizer now supports
-   "duplicate" nodes for *build dependencies*, but enforces unification through
-   transitive link and run dependencies. This will allow it to better resolve complex
-   dependency graphs in ecosystems like Python, and it also gets us very close to
-   modeling compilers as proper dependencies.
-
-   This change required a major overhaul of the concretizer, as well as a number of
-   performance optimizations. See #38447, #39621.
-
-4. **Cherry-picking virtual dependencies**
-
-   You can now select only a subset of virtual dependencies from a spec that may provide
-   more. For example, if you want `mpich` to be your `mpi` provider, you can be explicit
-   by writing:
-
-   ```
-   hdf5 ^[virtuals=mpi] mpich
-   ```
-
-   Or, if you want to use, e.g., `intel-parallel-studio` for `blas` along with an external
-   `lapack` like `openblas`, you could write:
-
-   ```
-   strumpack ^[virtuals=mpi] intel-parallel-studio+mkl ^[virtuals=lapack] openblas
-   ```
-
-   The `virtuals=mpi` is an edge attribute, and dependency edges in Spack graphs now
-   track which virtuals they satisfied. More details in #17229 and #35322.
-
-   Note for packaging: in Spack 0.21 `spec.satisfies("^virtual")` is true if and only if
-   the package specifies `depends_on("virtual")`. This is different from Spack 0.20,
-   where depending on a provider implied depending on the virtual provided. See #41002
-   for an example where `^mkl` was being used to test for several `mkl` providers in a
-   package that did not depend on `mkl`.
-
-5. **License directive**
-
-   Spack packages can now have license metadata, with the new `license()` directive:
-
-   ```python
-       license("Apache-2.0")
-   ```
-
-   Licenses use [SPDX identifiers](https://spdx.org/licenses), and you can use SPDX
-   expressions to combine them:
-
-   ```python
-       license("Apache-2.0 OR MIT")
-   ```
-
-   Like other directives in Spack, it's conditional, so you can handle complex cases like
-   Spack itself:
-
-   ```python
-      license("LGPL-2.1", when="@:0.11")
-      license("Apache-2.0 OR MIT", when="@0.12:")
-   ```
-
-   More details in #39346, #40598.
-
-6. **`spack deconcretize` command**
-
-   We are getting close to having a `spack update` command for environments, but we're
-   not quite there yet. This is the next best thing. `spack deconcretize` gives you
-   control over what you want to update in an already concrete environment. If you have
-   an environment built with, say, `meson`, and you want to update your `meson` version,
-   you can run:
-
-   ```console
-   spack deconcretize meson
-   ```
-
-   and have everything that depends on `meson` rebuilt the next time you run `spack
-   concretize`. In a future Spack version, we'll handle all of this in a single command,
-   but for now you can use this to drop bits of your lockfile and resolve your
-   dependencies again. More in #38803.
-
-7. **UI Improvements**
-
-   The venerable `spack info` command was looking shabby compared to the rest of Spack's
-   UI, so we reworked it to have a bit more flair. `spack info` now makes much better
-   use of terminal space and shows variants, their values, and their descriptions much
-   more clearly. Conditional variants are grouped separately so you can more easily
-   understand how packages are structured. More in #40998.
-
-   `spack checksum` now allows you to filter versions from your editor, or by version
-   range. It also notifies you about potential download URL changes. See #40403.
-
-8. **Environments can include definitions**
-
-   Spack did not previously support using `include:` with The
-   [definitions](https://spack.readthedocs.io/en/latest/environments.html#spec-list-references)
-   section of an environment, but now it does. You can use this to curate lists of specs
-   and more easily reuse them across environments. See #33960.
-
-9. **Aliases**
-
-   You can now add aliases to Spack commands in `config.yaml`, e.g. this might enshrine
-   your favorite args to `spack find` as `spack f`:
-
-   ```yaml
-   config:
-     aliases:
-       f: find -lv
-   ```
-
-   See #17229.
-
-10. **Improved autoloading of modules**
-
-    Spack 0.20 was the first release to enable autoloading of direct dependencies in
-    module files.
-
-    The downside of this was that `module avail` and `module load` tab completion would
-    show users too many modules to choose from, and many users disabled generating
-    modules for dependencies through `exclude_implicits: true`. Further, it was
-    necessary to keep hashes in module names to avoid file name clashes.
-
-    In this release, you can start using `hide_implicits: true` instead, which exposes
-    only explicitly installed packages to the user, while still autoloading
-    dependencies. On top of that, you can safely use `hash_length: 0`, as this config
-    now only applies to the modules exposed to the user -- you don't have to worry about
-    file name clashes for hidden dependencies.
-
-   Note: for `tcl` this feature requires Modules 4.7 or higher
-
-11. **Updated container labeling**
-
-    Nightly Docker images from the `develop` branch will now be tagged as `:develop` and
-    `:nightly`. The `:latest` tag is no longer associated with `:develop`, but with the
-    latest stable release. Releases will be tagged with `:{major}`, `:{major}.{minor}`
-    and `:{major}.{minor}.{patch}`. `ubuntu:18.04` has also been removed from the list of
-    generated Docker images, as it is no longer supported. See #40593.
-
-## Other new commands and directives
-
-* `spack env activate` without arguments now loads a `default` environment that you do
-  not have to create (#40756).
-* `spack find -H` / `--hashes`: a new shortcut for piping `spack find` output to
-  other commands (#38663)
-* Add `spack checksum --verify`, fix `--add` (#38458)
-* New `default_args` context manager factors out common args for directives (#39964)
-* `spack compiler find --[no]-mixed-toolchain` lets you easily mix `clang` and
-  `gfortran` on Linux (#40902)
-
-## Performance improvements
-
-* `spack external find` execution is now much faster (#39843)
-* `spack location -i` now much faster on success (#40898)
-* Drop redundant rpaths post install (#38976)
-* ASP-based solver: avoid cycles in clingo using hidden directive (#40720)
-* Fix multiple quadratic complexity issues in environments (#38771)
-
-## Other new features of note
-
-* archspec: update to v0.2.2, support for Sapphire Rapids, Power10, Neoverse V2 (#40917)
-* Propagate variants across nodes that don't have that variant (#38512)
-* Implement fish completion (#29549)
-* Can now distinguish between source/binary mirror; don't ping mirror.spack.io as much (#34523)
-* Improve status reporting on install (add [n/total] display) (#37903)
-
-## Windows
-
-This release has the best Windows support of any Spack release yet, with numerous
-improvements and much larger swaths of tests passing:
-
-* MSVC and SDK improvements (#37711, #37930, #38500, #39823, #39180)
-* Windows external finding: update default paths; treat .bat as executable on Windows (#39850)
-* Windows decompression: fix removal of intermediate file (#38958)
-* Windows: executable/path handling (#37762)
-* Windows build systems: use ninja and enable tests (#33589)
-* Windows testing (#36970, #36972, #36973, #36840, #36977, #36792, #36834, #34696, #36971)
-* Windows PowerShell support (#39118, #37951)
-* Windows symlinking and libraries (#39933, #38599, #34701, #38578, #34701)
-
-## Notable refactors
-* User-specified flags take precedence over others in Spack compiler wrappers (#37376)
-* Improve setup of build, run, and test environments (#35737, #40916)
-* `make` is no longer a required system dependency of Spack (#40380)
-* Support Python 3.12 (#40404, #40155, #40153)
-* docs: Replace package list with packages.spack.io (#40251)
-* Drop Python 2 constructs in Spack (#38720, #38718, #38703)
-
-## Binary cache and stack updates
-* e4s arm stack: duplicate and target neoverse v1 (#40369)
-* Add macOS ML CI stacks (#36586)
-* E4S Cray CI Stack (#37837)
-* e4s cray: expand spec list (#38947)
-* e4s cray sles ci: expand spec list (#39081)
-
-## Removals, deprecations, and syntax changes
-* ASP: targets, compilers and providers soft-preferences are only global (#31261)
-* Parser: fix ambiguity with whitespace in version ranges (#40344)
-* Module file generation is disabled by default; you'll need to enable it to use it (#37258)
-* Remove deprecated "extra_instructions" option for containers (#40365)
-* Stand-alone test feature deprecation postponed to v0.22 (#40600)
-* buildcache push: make `--allow-root` the default and deprecate the option (#38878)
-
-## Notable Bugfixes
-* Bugfix: propagation of multivalued variants (#39833)
-* Allow `/` in git versions (#39398)
-* Fetch & patch: actually acquire stage lock, and many more issues (#38903)
-* Environment/depfile: better escaping of targets with Git versions (#37560)
-* Prevent "spack external find" to error out on wrong permissions (#38755)
-* lmod: allow core compiler to be specified with a version range (#37789)
-
-## Spack community stats
-
-* 7,469 total packages, 303 new since `v0.20.0`
-    * 150 new Python packages
-    * 34 new R packages
-* 353 people contributed to this release
-    * 336 committers to packages
-    * 65 committers to core
-
-
 # v0.20.3 (2023-10-31)
 
 ## Bugfixes

lib/spack/docs/configuration.rst

@@ -243,9 +243,11 @@ lower-precedence settings. Completely ignoring higher-level configuration
 options is supported with the ``::`` notation for keys (see
 :ref:`config-overrides` below).
 
-There are also special notations for string concatenation and precendense override.
-Using the ``+:`` notation  can be used to force *prepending* strings or lists. For lists, this is identical
-to the default behavior. Using the ``-:`` works similarly, but for *appending* values.
+There are also special notations for string concatenation and precendense override:
+
+* ``+:`` will force *prepending* strings or lists. For lists, this is the default behavior.
+* ``-:`` works similarly, but for *appending* values.
+
 :ref:`config-prepend-append`
 
 ^^^^^^^^^^^

lib/spack/spack/__init__.py

@@ -4,7 +4,7 @@
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 #: PEP440 canonical <major>.<minor>.<micro>.<devN> string
-__version__ = "0.21.0"
+__version__ = "0.22.0.dev0"
 spack_version = __version__
 
 

lib/spack/spack/build_systems/cached_cmake.py

@@ -34,6 +34,11 @@ def cmake_cache_option(name, boolean_value, comment="", force=False):
     return 'set({0} {1} CACHE BOOL "{2}"{3})\n'.format(name, value, comment, force_str)
 
 
+def cmake_cache_filepath(name, value, comment=""):
+    """Generate a string for a cmake cache variable of type FILEPATH"""
+    return 'set({0} "{1}" CACHE FILEPATH "{2}")\n'.format(name, value, comment)
+
+
 class CachedCMakeBuilder(CMakeBuilder):
     #: Phases of a Cached CMake package
     #: Note: the initconfig phase is used for developer builds as a final phase to stop on
@@ -257,6 +262,15 @@ def initconfig_hardware_entries(self):
             entries.append(
                 cmake_cache_path("HIP_CXX_COMPILER", "{0}".format(self.spec["hip"].hipcc))
             )
+            llvm_bin = spec["llvm-amdgpu"].prefix.bin
+            llvm_prefix = spec["llvm-amdgpu"].prefix
+            # Some ROCm systems seem to point to /<path>/rocm-<ver>/ and
+            # others point to /<path>/rocm-<ver>/llvm
+            if os.path.basename(os.path.normpath(llvm_prefix)) != "llvm":
+                llvm_bin = os.path.join(llvm_prefix, "llvm/bin/")
+            entries.append(
+                cmake_cache_filepath("CMAKE_HIP_COMPILER", os.path.join(llvm_bin, "clang++"))
+            )
             archs = self.spec.variants["amdgpu_target"].value
             if archs[0] != "none":
                 arch_str = ";".join(archs)
@@ -277,7 +291,7 @@ def std_initconfig_entries(self):
             "#------------------{0}".format("-" * 60),
             "# CMake executable path: {0}".format(self.pkg.spec["cmake"].command.path),
             "#------------------{0}\n".format("-" * 60),
-            cmake_cache_path("CMAKE_PREFIX_PATH", cmake_prefix_path),
+            cmake_cache_string("CMAKE_PREFIX_PATH", cmake_prefix_path),
             self.define_cmake_cache_from_variant("CMAKE_BUILD_TYPE", "build_type"),
         ]
 

lib/spack/spack/ci.py

@@ -46,7 +46,22 @@
 from spack.reporters import CDash, CDashConfiguration
 from spack.reporters.cdash import build_stamp as cdash_build_stamp
 
-JOB_RETRY_CONDITIONS = ["always"]
+# See https://docs.gitlab.com/ee/ci/yaml/#retry for descriptions of conditions
+JOB_RETRY_CONDITIONS = [
+    # "always",
+    "unknown_failure",
+    "script_failure",
+    "api_failure",
+    "stuck_or_timeout_failure",
+    "runner_system_failure",
+    "runner_unsupported",
+    "stale_schedule",
+    # "job_execution_timeout",
+    "archived_failure",
+    "unmet_prerequisites",
+    "scheduler_failure",
+    "data_integrity_failure",
+]
 
 TEMP_STORAGE_MIRROR_NAME = "ci_temporary_mirror"
 SPACK_RESERVED_TAGS = ["public", "protected", "notary"]

lib/spack/spack/package.py

@@ -32,6 +32,7 @@
 from spack.build_systems.bundle import BundlePackage
 from spack.build_systems.cached_cmake import (
     CachedCMakePackage,
+    cmake_cache_filepath,
     cmake_cache_option,
     cmake_cache_path,
     cmake_cache_string,

share/spack/docker/entrypoint.bash

@@ -51,8 +51,12 @@ case "$mode" in
         #   COPY spack.yaml .
         #   RUN spack install  # <- Spack is loaded and ready to use.
         #                      # No manual initialization necessary.
+        #   RUN <<EOT          # Supports multi-line scripts.
+        #   spack install      # Will fail on first error (set -e).
+        #   spack buildcache push
+        #   EOT
         . $SPACK_ROOT/share/spack/setup-env.sh
-        exec bash -c "$*"
+        exec bash -e -c "$*"
         ;;
 
     "interactiveshell")

share/spack/gitlab/cloud_pipelines/.gitlab-ci.yml

@@ -894,16 +894,16 @@ e4s-cray-rhel-build:
   variables:
     SPACK_CI_STACK_NAME: e4s-cray-sles
 
-# e4s-cray-sles-generate:
-#   extends: [ ".generate-cray-sles", ".e4s-cray-sles" ]
+e4s-cray-sles-generate:
+  extends: [ ".generate-cray-sles", ".e4s-cray-sles" ]
 
-# e4s-cray-sles-build:
-#   extends: [ ".build", ".e4s-cray-sles" ]
-#   trigger:
-#     include:
-#       - artifact: jobs_scratch_dir/cloud-ci-pipeline.yml
-#         job: e4s-cray-sles-generate
-#     strategy: depend
-#   needs:
-#     - artifacts: True
-#       job: e4s-cray-sles-generate
+e4s-cray-sles-build:
+  extends: [ ".build", ".e4s-cray-sles" ]
+  trigger:
+    include:
+      - artifact: jobs_scratch_dir/cloud-ci-pipeline.yml
+        job: e4s-cray-sles-generate
+    strategy: depend
+  needs:
+    - artifacts: True
+      job: e4s-cray-sles-generate

var/spack/repos/builtin/packages/abinit/package.py

@@ -27,6 +27,8 @@ class Abinit(AutotoolsPackage):
     homepage = "https://www.abinit.org/"
     url = "https://www.abinit.org/sites/default/files/packages/abinit-8.6.3.tar.gz"
 
+    maintainers("downloadico")
+    version("9.10.3", sha256="3f2a9aebbf1fee9855a09dd687f88d2317b8b8e04f97b2628ab96fb898dce49b")
     version("9.8.4", sha256="a086d5045f0093b432e6a044d5f71f7edf5a41a62d67b3677cb0751d330c564a")
     version("9.8.3", sha256="de823878aea2c20098f177524fbb4b60de9b1b5971b2e835ec244dfa3724589b")
     version("9.6.1", sha256="b6a12760fd728eb4aacca431ae12150609565bedbaa89763f219fcd869f79ac6")
@@ -143,19 +145,27 @@ def configure_args(self):
             oapp(f"--with-optim-flavor={self.spec.variants['optimization-flavor'].value}")
 
         if "+wannier90" in spec:
-            if "@:8" in spec:
+            if spec.satisfies("@:8"):
                 oapp(f"--with-wannier90-libs=-L{spec['wannier90'].prefix.lib} -lwannier -lm")
                 oapp(f"--with-wannier90-incs=-I{spec['wannier90'].prefix.modules}")
                 oapp(f"--with-wannier90-bins={spec['wannier90'].prefix.bin}")
                 oapp("--enable-connectors")
                 oapp("--with-dft-flavor=atompaw+libxc+wannier90")
-            else:
+            elif spec.satisfies("@:9.8"):
                 options.extend(
                     [
                         f"WANNIER90_CPPFLAGS=-I{spec['wannier90'].prefix.modules}",
                         f"WANNIER90_LIBS=-L{spec['wannier90'].prefix.lib} -lwannier",
                     ]
                 )
+            else:
+                options.extend(
+                    [
+                        f"WANNIER90_CPPFLAGS=-I{spec['wannier90'].prefix.modules}",
+                        f"WANNIER90_LIBS=-L{spec['wannier90'].prefix.lib}"
+                        "WANNIER90_LDFLAGS=-lwannier",
+                    ]
+                )
         else:
             if "@:9.8" in spec:
                 oapp(f"--with-fftw={spec['fftw-api'].prefix}")
@@ -169,7 +179,10 @@ def configure_args(self):
         if "+mpi" in spec:
             oapp(f"CC={spec['mpi'].mpicc}")
             oapp(f"CXX={spec['mpi'].mpicxx}")
-            oapp(f"FC={spec['mpi'].mpifc}")
+            if spec.satisfies("@9.8:"):
+                oapp(f"F90={spec['mpi'].mpifc}")
+            else:
+                oapp(f"FC={spec['mpi'].mpifc}")
 
             # MPI version:
             # let the configure script auto-detect MPI support from mpi_prefix

var/spack/repos/builtin/packages/adiak/package.py

@@ -20,8 +20,9 @@ class Adiak(CMakePackage):
     variant("shared", default=True, description="Build dynamic libraries")
 
     version(
-        "0.2.2", commit="3aedd494c81c01df1183af28bc09bade2fabfcd3", submodules=True, preferred=True
+        "0.4.0", commit="7e8b7233f8a148b402128ed46b2f0c643e3b397e", submodules=True, preferred=True
     )
+    version("0.2.2", commit="3aedd494c81c01df1183af28bc09bade2fabfcd3", submodules=True)
     version(
         "0.3.0-alpha",
         commit="054d2693a977ed0e1f16c665b4966bb90924779e",

var/spack/repos/builtin/packages/alquimia/package.py

@@ -34,7 +34,7 @@ class Alquimia(CMakePackage):
     depends_on("pflotran@develop", when="@develop")
     depends_on("petsc@3.10:", when="@develop")
 
-    @when("@1.0.10")
+    @when("@1.0.10:1.1.0")
     def patch(self):
         filter_file(
             "use iso_[cC]_binding",

var/spack/repos/builtin/packages/aluminum/package.py

@@ -9,7 +9,7 @@
 from spack.package import *
 
 
-class Aluminum(CMakePackage, CudaPackage, ROCmPackage):
+class Aluminum(CachedCMakePackage, CudaPackage, ROCmPackage):
     """Aluminum provides a generic interface to high-performance
     communication libraries, with a focus on allreduce
     algorithms. Blocking and non-blocking algorithms and GPU-aware
@@ -22,208 +22,207 @@ class Aluminum(CMakePackage, CudaPackage, ROCmPackage):
     git = "https://github.com/LLNL/Aluminum.git"
     tags = ["ecp", "radiuss"]
 
-    maintainers("bvanessen")
+    maintainers("benson31", "bvanessen")
 
     version("master", branch="master")
+    version("1.4.1", sha256="d130a67fef1cb7a9cb3bbec1d0de426f020fe68c9df6e172c83ba42281cd90e3")
+    version("1.4.0", sha256="ac54de058f38cead895ec8163f7b1fa7674e4dc5aacba683a660a61babbfe0c6")
     version("1.3.1", sha256="28ce0af6c6f29f97b7f19c5e45184bd2f8a0b1428f1e898b027d96d47cb74b0b")
     version("1.3.0", sha256="d0442efbebfdfb89eec793ae65eceb8f1ba65afa9f2e48df009f81985a4c27e3")
     version("1.2.3", sha256="9b214bdf30f9b7e8e017f83e6615db6be2631f5be3dd186205dbe3aa62f4018a")
-    version(
-        "1.2.2",
-        sha256="c01d9dd98be4cab9b944bae99b403abe76d65e9e1750e7f23bf0105636ad5485",
-        deprecated=True,
-    )
-    version(
-        "1.2.1",
-        sha256="869402708c8a102a67667b83527b4057644a32b8cdf4990bcd1a5c4e5f0e30af",
-        deprecated=True,
-    )
-    version(
-        "1.2.0",
-        sha256="2f3725147f4dbc045b945af68d3d747f5dffbe2b8e928deed64136785210bc9a",
-        deprecated=True,
-    )
-    version(
-        "1.1.0",
-        sha256="78b03e36e5422e8651f400feb4d8a527f87302db025d77aa37e223be6b9bdfc9",
-        deprecated=True,
-    )
-    version("1.0.0-lbann", tag="v1.0.0-lbann", commit="40a062b1f63e84e074489c0f926f36b806c6b8f3")
-    version("1.0.0", sha256="028d12e271817214db5c07c77b0528f88862139c3e442e1b12f58717290f414a")
-    version(
-        "0.7.0",
-        sha256="bbb73d2847c56efbe6f99e46b41d837763938483f2e2d1982ccf8350d1148caa",
-        deprecated=True,
-    )
-    version(
-        "0.6.0",
-        sha256="6ca329951f4c7ea52670e46e5020e7e7879d9b56fed5ff8c5df6e624b313e925",
-        deprecated=True,
-    )
-    version(
-        "0.5.0",
-        sha256="dc365a5849eaba925355a8efb27005c5f22bcd1dca94aaed8d0d29c265c064c1",
-        deprecated=True,
-    )
-    version(
-        "0.4.0",
-        sha256="4d6fab5481cc7c994b32fb23a37e9ee44041a9f91acf78f981a97cb8ef57bb7d",
-        deprecated=True,
-    )
-    version(
-        "0.3.3",
-        sha256="26e7f263f53c6c6ee0fe216e981a558dfdd7ec997d0dd2a24285a609a6c68f3b",
-        deprecated=True,
-    )
-    version(
-        "0.3.2",
-        sha256="09b6d1bcc02ac54ba269b1123eee7be20f0104b93596956c014b794ba96b037f",
-        deprecated=True,
-    )
-    version(
-        "0.2.1-1",
-        sha256="066b750e9d1134871709a3e2414b96b166e0e24773efc7d512df2f1d96ee8eef",
-        deprecated=True,
-    )
-    version(
-        "0.2.1",
-        sha256="3d5d15853cccc718f60df68205e56a2831de65be4d96e7f7e8497097e7905f89",
-        deprecated=True,
-    )
-    version(
-        "0.2",
-        sha256="fc8f06c6d8faab17a2aedd408d3fe924043bf857da1094d5553f35c4d2af893b",
-        deprecated=True,
-    )
-    version(
-        "0.1",
-        sha256="3880b736866e439dd94e6a61eeeb5bb2abccebbac82b82d52033bc6c94950bdb",
-        deprecated=True,
-    )
 
-    variant("nccl", default=False, description="Builds with support for NCCL communication lib")
+    # Library capabilities
+    variant(
+        "cuda_rma",
+        default=False,
+        when="+cuda",
+        description="Builds with support for CUDA intra-node "
+        " Put/Get and IPC RMA functionality",
+    )
     variant(
         "ht",
         default=False,
         description="Builds with support for host-enabled MPI"
         " communication of accelerator data",
     )
+    variant("nccl", default=False, description="Builds with support for NCCL communication lib")
+    variant("shared", default=True, description="Build Aluminum as a shared library")
+
+    # Debugging features
+    variant("hang_check", default=False, description="Enable hang checking")
+    variant("trace", default=False, description="Enable runtime tracing")
+
+    # Profiler support
+    variant("nvtx", default=False, when="+cuda", description="Enable profiling via nvprof/NVTX")
     variant(
-        "cuda_rma",
+        "roctracer", default=False, when="+rocm", description="Enable profiling via rocprof/roctx"
+    )
+
+    # Advanced options
+    variant("mpi_serialize", default=False, description="Serialize MPI operations")
+    variant("stream_mem_ops", default=False, description="Enable stream memory operations")
+    variant(
+        "thread_multiple",
         default=False,
-        description="Builds with support for CUDA intra-node "
-        " Put/Get and IPC RMA functionality",
-    )
-    variant("rccl", default=False, description="Builds with support for RCCL communication lib")
-    variant(
-        "ofi_libfabric_plugin",
-        default=spack.platforms.cray.slingshot_network(),
-        when="+rccl",
-        sticky=True,
-        description="Builds with support for OFI libfabric enhanced RCCL/NCCL communication lib",
-    )
-    variant(
-        "ofi_libfabric_plugin",
-        default=spack.platforms.cray.slingshot_network(),
-        when="+nccl",
-        sticky=True,
-        description="Builds with support for OFI libfabric enhanced RCCL/NCCL communication lib",
+        description="Allow multiple threads to call Aluminum concurrently",
     )
 
-    depends_on("cmake@3.21.0:", type="build", when="@1.0.1:")
-    depends_on("cmake@3.17.0:", type="build", when="@:1.0.0")
-    depends_on("mpi")
-    depends_on("nccl@2.7.0-0:", when="+nccl")
-    depends_on("hwloc@1.11:")
-    depends_on("hwloc +cuda +nvml", when="+cuda")
-    depends_on("hwloc@2.3.0:", when="+rocm")
-    depends_on("cub", when="@:0.1,0.6.0: +cuda ^cuda@:10")
-    depends_on("hipcub", when="@:0.1,0.6.0: +rocm")
+    # Benchmark/testing support
+    variant(
+        "benchmarks",
+        default=False,
+        description="Build the Aluminum benchmarking drivers "
+        "(warning: may significantly increase build time!)",
+    )
+    variant(
+        "tests",
+        default=False,
+        description="Build the Aluminum test drivers "
+        "(warning: may moderately increase build time!)",
+    )
 
-    depends_on("rccl", when="+rccl")
-    depends_on("aws-ofi-rccl", when="+rccl +ofi_libfabric_plugin")
-    depends_on("aws-ofi-nccl", when="+nccl +ofi_libfabric_plugin")
+    # FIXME: Do we want to expose tuning parameters to the Spack
+    # recipe? Some are numeric values, some are on/off switches.
 
     conflicts("~cuda", when="+cuda_rma", msg="CUDA RMA support requires CUDA")
     conflicts("+cuda", when="+rocm", msg="CUDA and ROCm support are mutually exclusive")
-    conflicts("+nccl", when="+rccl", msg="NCCL and RCCL support are mutually exclusive")
 
-    generator("ninja")
+    depends_on("mpi")
+
+    depends_on("cmake@3.21.0:", type="build", when="@1.0.1:")
+    depends_on("hwloc@1.11:")
+
+    with when("+cuda"):
+        depends_on("cub", when="^cuda@:10")
+        depends_on("hwloc +cuda +nvml")
+        with when("+nccl"):
+            depends_on("nccl@2.7.0-0:")
+            for arch in CudaPackage.cuda_arch_values:
+                depends_on(
+                    "nccl +cuda cuda_arch={0}".format(arch),
+                    when="+cuda cuda_arch={0}".format(arch),
+                )
+            if spack.platforms.cray.slingshot_network():
+                depends_on("aws-ofi-nccl")  # Note: NOT a CudaPackage
+
+    with when("+rocm"):
+        for val in ROCmPackage.amdgpu_targets:
+            depends_on(
+                "hipcub +rocm amdgpu_target={0}".format(val), when="amdgpu_target={0}".format(val)
+            )
+            depends_on(
+                "hwloc@2.3.0: +rocm amdgpu_target={0}".format(val),
+                when="amdgpu_target={0}".format(val),
+            )
+            # RCCL is *NOT* implented as a ROCmPackage
+            depends_on(
+                "rccl amdgpu_target={0}".format(val), when="+nccl amdgpu_target={0}".format(val)
+            )
+            depends_on(
+                "roctracer-dev +rocm amdgpu_target={0}".format(val),
+                when="+roctracer amdgpu_target={0}".format(val),
+            )
+        if spack.platforms.cray.slingshot_network():
+            depends_on("aws-ofi-rccl", when="+nccl")
 
     def cmake_args(self):
-        spec = self.spec
-        args = [
-            "-DCMAKE_CXX_STANDARD:STRING=17",
-            "-DALUMINUM_ENABLE_CUDA:BOOL=%s" % ("+cuda" in spec),
-            "-DALUMINUM_ENABLE_NCCL:BOOL=%s" % ("+nccl" in spec or "+rccl" in spec),
-            "-DALUMINUM_ENABLE_ROCM:BOOL=%s" % ("+rocm" in spec),
-        ]
-
-        if not spec.satisfies("^cmake@3.23.0"):
-            # There is a bug with using Ninja generator in this version
-            # of CMake
-            args.append("-DCMAKE_EXPORT_COMPILE_COMMANDS=ON")
-
-        if "+cuda" in spec:
-            if self.spec.satisfies("%clang"):
-                for flag in self.spec.compiler_flags["cxxflags"]:
-                    if "gcc-toolchain" in flag:
-                        args.append("-DCMAKE_CUDA_FLAGS=-Xcompiler={0}".format(flag))
-            if spec.satisfies("^cuda@11.0:"):
-                args.append("-DCMAKE_CUDA_STANDARD=17")
-            else:
-                args.append("-DCMAKE_CUDA_STANDARD=14")
-            archs = spec.variants["cuda_arch"].value
-            if archs != "none":
-                arch_str = ";".join(archs)
-                args.append("-DCMAKE_CUDA_ARCHITECTURES=%s" % arch_str)
-
-            if spec.satisfies("%cce") and spec.satisfies("^cuda+allow-unsupported-compilers"):
-                args.append("-DCMAKE_CUDA_FLAGS=-allow-unsupported-compiler")
-
-        if spec.satisfies("@0.5:"):
-            args.extend(
-                [
-                    "-DALUMINUM_ENABLE_HOST_TRANSFER:BOOL=%s" % ("+ht" in spec),
-                    "-DALUMINUM_ENABLE_MPI_CUDA:BOOL=%s" % ("+cuda_rma" in spec),
-                    "-DALUMINUM_ENABLE_MPI_CUDA_RMA:BOOL=%s" % ("+cuda_rma" in spec),
-                ]
-            )
-        else:
-            args.append("-DALUMINUM_ENABLE_MPI_CUDA:BOOL=%s" % ("+ht" in spec))
-
-        if spec.satisfies("@:0.1,0.6.0: +cuda ^cuda@:10"):
-            args.append("-DCUB_DIR:FILEPATH=%s" % spec["cub"].prefix)
-
-        # Add support for OS X to find OpenMP (LLVM installed via brew)
-        if self.spec.satisfies("%clang platform=darwin"):
-            clang = self.compiler.cc
-            clang_bin = os.path.dirname(clang)
-            clang_root = os.path.dirname(clang_bin)
-            args.extend(["-DOpenMP_DIR={0}".format(clang_root)])
-
-        if "+rocm" in spec:
-            args.extend(
-                [
-                    "-DHIP_ROOT_DIR={0}".format(spec["hip"].prefix),
-                    "-DHIP_CXX_COMPILER={0}".format(self.spec["hip"].hipcc),
-                    "-DCMAKE_CXX_FLAGS=-std=c++17",
-                ]
-            )
-            archs = self.spec.variants["amdgpu_target"].value
-            if archs != "none":
-                arch_str = ",".join(archs)
-                if spec.satisfies("%rocmcc@:5"):
-                    args.append(
-                        "-DHIP_HIPCC_FLAGS=--amdgpu-target={0}"
-                        " -g -fsized-deallocation -fPIC -std=c++17".format(arch_str)
-                    )
-                args.extend(
-                    [
-                        "-DCMAKE_HIP_ARCHITECTURES=%s" % arch_str,
-                        "-DAMDGPU_TARGETS=%s" % arch_str,
-                        "-DGPU_TARGETS=%s" % arch_str,
-                    ]
-                )
-
+        args = []
         return args
+
+    def get_cuda_flags(self):
+        spec = self.spec
+        args = []
+        if spec.satisfies("^cuda+allow-unsupported-compilers"):
+            args.append("-allow-unsupported-compiler")
+
+        if spec.satisfies("%clang"):
+            for flag in spec.compiler_flags["cxxflags"]:
+                if "gcc-toolchain" in flag:
+                    args.append("-Xcompiler={0}".format(flag))
+        return args
+
+    def std_initconfig_entries(self):
+        entries = super(Aluminum, self).std_initconfig_entries()
+
+        # CMAKE_PREFIX_PATH, in CMake types, is a "STRING", not a "PATH". :/
+        entries = [x for x in entries if "CMAKE_PREFIX_PATH" not in x]
+        cmake_prefix_path = os.environ["CMAKE_PREFIX_PATH"].replace(":", ";")
+        entries.append(cmake_cache_string("CMAKE_PREFIX_PATH", cmake_prefix_path))
+        return entries
+
+    def initconfig_compiler_entries(self):
+        spec = self.spec
+        entries = super(Aluminum, self).initconfig_compiler_entries()
+
+        # FIXME: Enforce this better in the actual CMake.
+        entries.append(cmake_cache_string("CMAKE_CXX_STANDARD", "17"))
+        entries.append(cmake_cache_option("BUILD_SHARED_LIBS", "+shared" in spec))
+        entries.append(cmake_cache_option("CMAKE_EXPORT_COMPILE_COMMANDS", True))
+        entries.append(cmake_cache_option("MPI_ASSUME_NO_BUILTIN_MPI", True))
+
+        return entries
+
+    def initconfig_hardware_entries(self):
+        spec = self.spec
+        entries = super(Aluminum, self).initconfig_hardware_entries()
+
+        entries.append(cmake_cache_option("ALUMINUM_ENABLE_CUDA", "+cuda" in spec))
+        if spec.satisfies("+cuda"):
+            entries.append(cmake_cache_string("CMAKE_CUDA_STANDARD", "17"))
+            if not spec.satisfies("cuda_arch=none"):
+                archs = spec.variants["cuda_arch"].value
+                arch_str = ";".join(archs)
+                entries.append(cmake_cache_string("CMAKE_CUDA_ARCHITECTURES", arch_str))
+
+            # FIXME: Should this use the "cuda_flags" function of the
+            # CudaPackage class or something? There might be other
+            # flags in play, and we need to be sure to get them all.
+            cuda_flags = self.get_cuda_flags()
+            if len(cuda_flags) > 0:
+                entries.append(cmake_cache_string("CMAKE_CUDA_FLAGS", " ".join(cuda_flags)))
+
+        entries.append(cmake_cache_option("ALUMINUM_ENABLE_ROCM", "+rocm" in spec))
+        if spec.satisfies("+rocm"):
+            entries.append(cmake_cache_string("CMAKE_HIP_STANDARD", "17"))
+            if not spec.satisfies("amdgpu_target=none"):
+                archs = self.spec.variants["amdgpu_target"].value
+                arch_str = ";".join(archs)
+                entries.append(cmake_cache_string("CMAKE_HIP_ARCHITECTURES", arch_str))
+                entries.append(cmake_cache_string("AMDGPU_TARGETS", arch_str))
+                entries.append(cmake_cache_string("GPU_TARGETS", arch_str))
+            entries.append(cmake_cache_path("HIP_ROOT_DIR", spec["hip"].prefix))
+
+        return entries
+
+    def initconfig_package_entries(self):
+        spec = self.spec
+        entries = super(Aluminum, self).initconfig_package_entries()
+
+        # Library capabilities
+        entries.append(cmake_cache_option("ALUMINUM_ENABLE_MPI_CUDA", "+cuda_rma" in spec))
+        entries.append(cmake_cache_option("ALUMINUM_ENABLE_MPI_CUDA_RMA", "+cuda_rma" in spec))
+        entries.append(cmake_cache_option("ALUMINUM_ENABLE_HOST_TRANSFER", "+ht" in spec))
+        entries.append(cmake_cache_option("ALUMINUM_ENABLE_NCCL", "+nccl" in spec))
+
+        # Debugging features
+        entries.append(cmake_cache_option("ALUMINUM_DEBUG_HANG_CHECK", "+hang_check" in spec))
+        entries.append(cmake_cache_option("ALUMINUM_ENABLE_TRACE", "+trace" in spec))
+
+        # Profiler support
+        entries.append(cmake_cache_option("ALUMINUM_ENABLE_NVPROF", "+nvtx" in spec))
+        entries.append(cmake_cache_option("ALUMINUM_ENABLE_ROCTRACER", "+roctracer" in spec))
+
+        # Advanced options
+        entries.append(cmake_cache_option("ALUMINUM_MPI_SERIALIZE", "+mpi_serialize" in spec))
+        entries.append(
+            cmake_cache_option("ALUMINUM_ENABLE_STREAM_MEM_OPS", "+stream_mem_ops" in spec)
+        )
+        entries.append(
+            cmake_cache_option("ALUMINUM_ENABLE_THREAD_MULTIPLE", "+thread_multiple" in spec)
+        )
+
+        # Benchmark/testing support
+        entries.append(cmake_cache_option("ALUMINUM_ENABLE_BENCHMARKS", "+benchmarks" in spec))
+        entries.append(cmake_cache_option("ALUMINUM_ENABLE_TESTS", "+tests" in spec))
+
+        return entries

var/spack/repos/builtin/packages/ams/package.py

@@ -15,6 +15,12 @@ class Ams(CMakePackage, CudaPackage):
     maintainers("koparasy", "lpottier")
 
     version("develop", branch="develop", submodules=False)
+    version(
+        "11.08.23.alpha",
+        tag="11.08.23.alpha",
+        commit="1a42b29268bb916dae301654ca0b92fdfe288732",
+        submodules=False,
+    )
     version(
         "07.25.23-alpha",
         tag="07.25.23-alpha",

var/spack/repos/builtin/packages/cpp-logger/package.py

@@ -16,3 +16,4 @@ class CppLogger(CMakePackage):
     version("develop", branch="develop")
     version("master", branch="master")
     version("0.0.1", tag="v0.0.1", commit="d48b38ab14477bb7c53f8189b8b4be2ea214c28a")
+    version("0.0.2", tag="v0.0.2", commit="329a48401033d2d2a1f1196141763cab029220ae")

var/spack/repos/builtin/packages/cube/package.py

@@ -16,7 +16,10 @@ class Cube(AutotoolsPackage):
 
     homepage = "https://www.scalasca.org/software/cube-4.x/download.html"
     url = "https://apps.fz-juelich.de/scalasca/releases/cube/4.4/dist/cubegui-4.4.2.tar.gz"
+    maintainers("swat-jsc")
 
+    version("4.8.2", sha256="bf2e02002bb2e5c4f61832ce37b62a440675c6453463014b33b2474aac78f86d")
+    version("4.8.1", sha256="a8a2a62b4e587c012d3d32385bed7c500db14232419795e0f4272d1dcefc55bc")
     version("4.8", sha256="1df8fcaea95323e7eaf0cc010784a41243532c2123a27ce93cb7e3241557ff76")
     version("4.7.1", sha256="7c96bf9ffb8cc132945f706657756fe6f88b7f7a5243ecd3741f599c2006d428")
     version("4.7", sha256="103fe00fa9846685746ce56231f64d850764a87737dc0407c9d0a24037590f68")

var/spack/repos/builtin/packages/cubelib/package.py

@@ -14,6 +14,7 @@ class Cubelib(AutotoolsPackage):
     maintainers = ("swat-jsc", "wrwilliams")
 
     version("4.8.2", sha256="d6fdef57b1bc9594f1450ba46cf08f431dd0d4ae595c47e2f3454e17e4ae74f4")
+    version("4.8.1", sha256="e4d974248963edab48c5d0fc5831146d391b0ae4632cccafe840bf5f12cd80a9")
     version("4.8", sha256="171c93ac5afd6bc74c50a9a58efdaf8589ff5cc1e5bd773ebdfb2347b77e2f68")
     version("4.7.1", sha256="62cf33a51acd9a723fff9a4a5411cd74203e24e0c4ffc5b9e82e011778ed4f2f")
     version("4.7", sha256="e44352c80a25a49b0fa0748792ccc9f1be31300a96c32de982b92477a8740938")

var/spack/repos/builtin/packages/cubew/package.py

@@ -14,6 +14,7 @@ class Cubew(AutotoolsPackage):
     maintainers = ("swat-jsc", "wrwilliams")
 
     version("4.8.2", sha256="4f3bcf0622c2429b8972b5eb3f14d79ec89b8161e3c1cc5862ceda417d7975d2")
+    version("4.8.1", sha256="42cbd743d87c16e805c8e28e79292ab33de259f2cfba46f2682cb35c1bc032d6")
     version("4.8", sha256="73c7f9e9681ee45d71943b66c01cfe675b426e4816e751ed2e0b670563ca4cf3")
     version("4.7.1", sha256="0d364a4930ca876aa887ec40d12399d61a225dbab69e57379b293516d7b6db8d")
     version("4.7", sha256="a7c7fca13e6cb252f08d4380223d7c56a8e86a67de147bcc0279ebb849c884a5")

var/spack/repos/builtin/packages/darshan-runtime/package.py

@@ -115,9 +115,9 @@ def configure_args(self):
         if "+apmpi" in spec:
             extra_args.append("--enable-apmpi-mod")
         if "+apmpi_sync" in spec:
-            extra_args.append(["--enable-apmpi-mod", "--enable-apmpi-coll-sync"])
+            extra_args.extend(["--enable-apmpi-mod", "--enable-apmpi-coll-sync"])
         if "+apxc" in spec:
-            extra_args.append(["--enable-apxc-mod"])
+            extra_args.append("--enable-apxc-mod")
 
         extra_args.append("--with-mem-align=8")
         extra_args.append("--with-log-path-by-env=DARSHAN_LOG_DIR_PATH")

var/spack/repos/builtin/packages/dihydrogen/package.py

@@ -8,7 +8,39 @@
 from spack.package import *
 
 
-class Dihydrogen(CMakePackage, CudaPackage, ROCmPackage):
+# This is a hack to get around some deficiencies in Hydrogen.
+def get_blas_entries(inspec):
+    entries = []
+    spec = inspec["hydrogen"]
+    if "blas=openblas" in spec:
+        entries.append(cmake_cache_option("DiHydrogen_USE_OpenBLAS", True))
+    elif "blas=mkl" in spec or spec.satisfies("^intel-mkl"):
+        entries.append(cmake_cache_option("DiHydrogen_USE_MKL", True))
+    elif "blas=essl" in spec or spec.satisfies("^essl"):
+        entries.append(cmake_cache_string("BLA_VENDOR", "IBMESSL"))
+        # IF IBM ESSL is used it needs help finding the proper LAPACK libraries
+        entries.append(
+            cmake_cache_string(
+                "LAPACK_LIBRARIES",
+                "%s;-llapack;-lblas"
+                % ";".join("-l{0}".format(lib) for lib in self.spec["essl"].libs.names),
+            )
+        )
+        entries.append(
+            cmake_cache_string(
+                "BLAS_LIBRARIES",
+                "%s;-lblas"
+                % ";".join("-l{0}".format(lib) for lib in self.spec["essl"].libs.names),
+            )
+        )
+    elif "blas=accelerate" in spec:
+        entries.append(cmake_cache_option("DiHydrogen_USE_ACCELERATE", True))
+    elif spec.satisfies("^netlib-lapack"):
+        entries.append(cmake_cache_string("BLA_VENDOR", "Generic"))
+    return entries
+
+
+class Dihydrogen(CachedCMakePackage, CudaPackage, ROCmPackage):
     """DiHydrogen is the second version of the Hydrogen fork of the
     well-known distributed linear algebra library,
     Elemental. DiHydrogen aims to be a basic distributed
@@ -20,117 +52,179 @@ class Dihydrogen(CMakePackage, CudaPackage, ROCmPackage):
     git = "https://github.com/LLNL/DiHydrogen.git"
     tags = ["ecp", "radiuss"]
 
-    maintainers("bvanessen")
+    maintainers("benson31", "bvanessen")
 
     version("develop", branch="develop")
     version("master", branch="master")
 
-    version("0.2.1", sha256="11e2c0f8a94ffa22e816deff0357dde6f82cc8eac21b587c800a346afb5c49ac")
-    version("0.2.0", sha256="e1f597e80f93cf49a0cb2dbc079a1f348641178c49558b28438963bd4a0bdaa4")
-    version("0.1", sha256="171d4b8adda1e501c38177ec966e6f11f8980bf71345e5f6d87d0a988fef4c4e")
+    version("0.3.0", sha256="8dd143441a28e0c7662cd92694e9a4894b61fd48508ac1d77435f342bc226dcf")
+
+    # Primary features
+
+    variant("dace", default=False, sticky=True, description="Enable DaCe backend.")
+
+    variant(
+        "distconv",
+        default=False,
+        sticky=True,
+        description="Enable (legacy) Distributed Convolution support.",
+    )
+
+    variant(
+        "nvshmem",
+        default=False,
+        sticky=True,
+        description="Enable support for NVSHMEM-based halo exchanges.",
+        when="+distconv",
+    )
+
+    variant(
+        "shared", default=True, sticky=True, description="Enables the build of shared libraries"
+    )
+
+    # Some features of developer interest
 
-    variant("al", default=True, description="Builds with Aluminum communication library")
     variant(
         "developer",
         default=False,
         description="Enable extra warnings and force tests to be enabled.",
     )
-    variant("half", default=False, description="Enable FP16 support on the CPU.")
+
+    variant("ci", default=False, description="Use default options for CI builds")
+
     variant(
-        "distconv",
+        "coverage",
         default=False,
-        description="Support distributed convolutions: spatial, channel, " "filter.",
+        description="Decorate build with code coverage instrumentation options",
+        when="%gcc",
     )
-    variant("nvshmem", default=False, description="Builds with support for NVSHMEM")
-    variant("openmp", default=False, description="Enable CPU acceleration with OpenMP threads.")
-    variant("rocm", default=False, description="Enable ROCm/HIP language features.")
-    variant("shared", default=True, description="Enables the build of shared libraries")
-
-    # Variants related to BLAS
     variant(
-        "openmp_blas", default=False, description="Use OpenMP for threading in the BLAS library"
+        "coverage",
+        default=False,
+        description="Decorate build with code coverage instrumentation options",
+        when="%clang",
     )
-    variant("int64_blas", default=False, description="Use 64bit integers for BLAS.")
     variant(
-        "blas",
-        default="openblas",
-        values=("openblas", "mkl", "accelerate", "essl", "libsci"),
-        description="Enable the use of OpenBlas/MKL/Accelerate/ESSL/LibSci",
+        "coverage",
+        default=False,
+        description="Decorate build with code coverage instrumentation options",
+        when="%rocmcc",
     )
 
-    conflicts("~cuda", when="+nvshmem")
+    # Package conflicts and requirements
 
-    depends_on("mpi")
-    depends_on("catch2", type="test")
+    conflicts("+nvshmem", when="~cuda", msg="NVSHMEM requires CUDA support.")
 
-    # Specify the correct version of Aluminum
-    depends_on("aluminum@0.4.0:0.4", when="@0.1 +al")
-    depends_on("aluminum@0.5.0:0.5", when="@0.2.0 +al")
-    depends_on("aluminum@0.7.0:0.7", when="@0.2.1 +al")
-    depends_on("aluminum@0.7.0:", when="@:0.0,0.2.1: +al")
+    conflicts("+cuda", when="+rocm", msg="CUDA and ROCm are mutually exclusive.")
 
-    # Add Aluminum variants
-    depends_on("aluminum +cuda +nccl +cuda_rma", when="+al +cuda")
-    depends_on("aluminum +rocm +rccl", when="+al +rocm")
-    depends_on("aluminum +ht", when="+al +distconv")
+    requires(
+        "+cuda",
+        "+rocm",
+        when="+distconv",
+        policy="any_of",
+        msg="DistConv support requires CUDA or ROCm.",
+    )
 
-    for arch in CudaPackage.cuda_arch_values:
-        depends_on("aluminum cuda_arch=%s" % arch, when="+al +cuda cuda_arch=%s" % arch)
-        depends_on("nvshmem cuda_arch=%s" % arch, when="+nvshmem +cuda cuda_arch=%s" % arch)
+    # Dependencies
 
-    # variants +rocm and amdgpu_targets are not automatically passed to
-    # dependencies, so do it manually.
-    for val in ROCmPackage.amdgpu_targets:
-        depends_on("aluminum amdgpu_target=%s" % val, when="amdgpu_target=%s" % val)
+    depends_on("catch2@3.0.1:", type=("build", "test"), when="+developer")
+    depends_on("cmake@3.21.0:", type="build")
+    depends_on("cuda@11.0:", when="+cuda")
+    depends_on("spdlog@1.11.0", when="@:0.1,0.2:")
 
-    depends_on("roctracer-dev", when="+rocm +distconv")
+    with when("@0.3.0:"):
+        depends_on("hydrogen +al")
+        for arch in CudaPackage.cuda_arch_values:
+            depends_on(
+                "hydrogen +cuda cuda_arch={0}".format(arch),
+                when="+cuda cuda_arch={0}".format(arch),
+            )
 
-    depends_on("cudnn", when="+cuda")
-    depends_on("cub", when="^cuda@:10")
+        for val in ROCmPackage.amdgpu_targets:
+            depends_on(
+                "hydrogen amdgpu_target={0}".format(val),
+                when="+rocm amdgpu_target={0}".format(val),
+            )
 
-    # Note that #1712 forces us to enumerate the different blas variants
-    depends_on("openblas", when="blas=openblas")
-    depends_on("openblas +ilp64", when="blas=openblas +int64_blas")
-    depends_on("openblas threads=openmp", when="blas=openblas +openmp_blas")
+    with when("+distconv"):
+        depends_on("mpi")
 
-    depends_on("intel-mkl", when="blas=mkl")
-    depends_on("intel-mkl +ilp64", when="blas=mkl +int64_blas")
-    depends_on("intel-mkl threads=openmp", when="blas=mkl +openmp_blas")
+        # All this nonsense for one silly little package.
+        depends_on("aluminum@1.4.1:")
 
-    depends_on("veclibfort", when="blas=accelerate")
-    conflicts("blas=accelerate +openmp_blas")
+        # Add Aluminum variants
+        depends_on("aluminum +cuda +nccl", when="+distconv +cuda")
+        depends_on("aluminum +rocm +nccl", when="+distconv +rocm")
 
-    depends_on("essl", when="blas=essl")
-    depends_on("essl +ilp64", when="blas=essl +int64_blas")
-    depends_on("essl threads=openmp", when="blas=essl +openmp_blas")
-    depends_on("netlib-lapack +external-blas", when="blas=essl")
+        # TODO: Debug linker errors when NVSHMEM is built with UCX
+        depends_on("nvshmem +nccl~ucx", when="+nvshmem")
 
-    depends_on("cray-libsci", when="blas=libsci")
-    depends_on("cray-libsci +openmp", when="blas=libsci +openmp_blas")
+        # OMP support is only used in DistConv, and only Apple needs
+        # hand-holding with it.
+        depends_on("llvm-openmp", when="%apple-clang")
+        # FIXME: when="platform=darwin"??
 
-    # Distconv builds require cuda or rocm
-    conflicts("+distconv", when="~cuda ~rocm")
+        # CUDA/ROCm arch forwarding
 
-    conflicts("+distconv", when="+half")
-    conflicts("+rocm", when="+half")
+        for arch in CudaPackage.cuda_arch_values:
+            depends_on(
+                "aluminum +cuda cuda_arch={0}".format(arch),
+                when="+cuda cuda_arch={0}".format(arch),
+            )
 
-    depends_on("half", when="+half")
+            # This is a workaround for a bug in the Aluminum package,
+            # as it should be responsible for its own NCCL dependency.
+            # Rather than failing to concretize, we help it along.
+            depends_on(
+                "nccl cuda_arch={0}".format(arch),
+                when="+distconv +cuda cuda_arch={0}".format(arch),
+            )
 
-    generator("ninja")
-    depends_on("cmake@3.17.0:", type="build")
+            # NVSHMEM also needs arch forwarding
+            depends_on(
+                "nvshmem +cuda cuda_arch={0}".format(arch),
+                when="+nvshmem +cuda cuda_arch={0}".format(arch),
+            )
 
-    depends_on("spdlog", when="@:0.1,0.2:")
+        # Idenfity versions of cuda_arch that are too old from
+        # lib/spack/spack/build_systems/cuda.py. We require >=60.
+        illegal_cuda_arch_values = [
+            "10",
+            "11",
+            "12",
+            "13",
+            "20",
+            "21",
+            "30",
+            "32",
+            "35",
+            "37",
+            "50",
+            "52",
+            "53",
+        ]
+        for value in illegal_cuda_arch_values:
+            conflicts("cuda_arch=" + value)
 
-    depends_on("llvm-openmp", when="%apple-clang +openmp")
+        for val in ROCmPackage.amdgpu_targets:
+            depends_on(
+                "aluminum amdgpu_target={0}".format(val),
+                when="+rocm amdgpu_target={0}".format(val),
+            )
 
-    # TODO: Debug linker errors when NVSHMEM is built with UCX
-    depends_on("nvshmem +nccl~ucx", when="+nvshmem")
+        # CUDA-specific distconv dependencies
+        depends_on("cudnn", when="+cuda")
 
-    # Idenfity versions of cuda_arch that are too old
-    # from lib/spack/spack/build_systems/cuda.py
-    illegal_cuda_arch_values = ["10", "11", "12", "13", "20", "21"]
-    for value in illegal_cuda_arch_values:
-        conflicts("cuda_arch=" + value)
+        # ROCm-specific distconv dependencies
+        depends_on("hipcub", when="+rocm")
+        depends_on("miopen-hip", when="+rocm")
+        depends_on("roctracer-dev", when="+rocm")
+
+    with when("+ci+coverage"):
+        depends_on("lcov", type=("build", "run"))
+        depends_on("py-gcovr", type=("build", "run"))
+        # Technically it's not used in the build, but CMake sets up a
+        # target, so it needs to be found.
 
     @property
     def libs(self):
@@ -138,104 +232,127 @@ def libs(self):
         return find_libraries("libH2Core", root=self.prefix, shared=shared, recursive=True)
 
     def cmake_args(self):
+        args = []
+        return args
+
+    def get_cuda_flags(self):
         spec = self.spec
+        args = []
+        if spec.satisfies("^cuda+allow-unsupported-compilers"):
+            args.append("-allow-unsupported-compiler")
 
-        args = [
-            "-DCMAKE_CXX_STANDARD=17",
-            "-DCMAKE_INSTALL_MESSAGE:STRING=LAZY",
-            "-DBUILD_SHARED_LIBS:BOOL=%s" % ("+shared" in spec),
-            "-DH2_ENABLE_ALUMINUM=%s" % ("+al" in spec),
-            "-DH2_ENABLE_CUDA=%s" % ("+cuda" in spec),
-            "-DH2_ENABLE_DISTCONV_LEGACY=%s" % ("+distconv" in spec),
-            "-DH2_ENABLE_OPENMP=%s" % ("+openmp" in spec),
-            "-DH2_ENABLE_FP16=%s" % ("+half" in spec),
-            "-DH2_DEVELOPER_BUILD=%s" % ("+developer" in spec),
-        ]
+        if spec.satisfies("%clang"):
+            for flag in spec.compiler_flags["cxxflags"]:
+                if "gcc-toolchain" in flag:
+                    args.append("-Xcompiler={0}".format(flag))
+        return args
 
-        if spec.version < Version("0.3"):
-            args.append("-DH2_ENABLE_HIP_ROCM=%s" % ("+rocm" in spec))
-        else:
-            args.append("-DH2_ENABLE_ROCM=%s" % ("+rocm" in spec))
+    def initconfig_compiler_entries(self):
+        spec = self.spec
+        entries = super(Dihydrogen, self).initconfig_compiler_entries()
 
-        if not spec.satisfies("^cmake@3.23.0"):
-            # There is a bug with using Ninja generator in this version
-            # of CMake
-            args.append("-DCMAKE_EXPORT_COMPILE_COMMANDS=ON")
+        # FIXME: Enforce this better in the actual CMake.
+        entries.append(cmake_cache_string("CMAKE_CXX_STANDARD", "17"))
+        entries.append(cmake_cache_option("BUILD_SHARED_LIBS", "+shared" in spec))
+        entries.append(cmake_cache_option("CMAKE_EXPORT_COMPILE_COMMANDS", True))
 
-        if "+cuda" in spec:
-            if self.spec.satisfies("%clang"):
-                for flag in self.spec.compiler_flags["cxxflags"]:
-                    if "gcc-toolchain" in flag:
-                        args.append("-DCMAKE_CUDA_FLAGS=-Xcompiler={0}".format(flag))
-            if spec.satisfies("^cuda@11.0:"):
-                args.append("-DCMAKE_CUDA_STANDARD=17")
-            else:
-                args.append("-DCMAKE_CUDA_STANDARD=14")
-            archs = spec.variants["cuda_arch"].value
-            if archs != "none":
-                arch_str = ";".join(archs)
-                args.append("-DCMAKE_CUDA_ARCHITECTURES=%s" % arch_str)
+        # It's possible this should have a `if "platform=cray" in
+        # spec:` in front of it, but it's not clear to me when this is
+        # set. In particular, I don't actually see this blurb showing
+        # up on Tioga builds. Which is causing the obvious problem
+        # (namely, the one this was added to supposedly solve in the
+        # first place.
+        entries.append(cmake_cache_option("MPI_ASSUME_NO_BUILTIN_MPI", True))
 
-            if spec.satisfies("%cce") and spec.satisfies("^cuda+allow-unsupported-compilers"):
-                args.append("-DCMAKE_CUDA_FLAGS=-allow-unsupported-compiler")
-
-        if "+cuda" in spec:
-            args.append("-DcuDNN_DIR={0}".format(spec["cudnn"].prefix))
-
-        if spec.satisfies("^cuda@:10"):
-            if "+cuda" in spec or "+distconv" in spec:
-                args.append("-DCUB_DIR={0}".format(spec["cub"].prefix))
-
-        # Add support for OpenMP with external (Brew) clang
-        if spec.satisfies("%clang +openmp platform=darwin"):
+        if spec.satisfies("%clang +distconv platform=darwin"):
             clang = self.compiler.cc
             clang_bin = os.path.dirname(clang)
             clang_root = os.path.dirname(clang_bin)
-            args.extend(
-                [
-                    "-DOpenMP_CXX_FLAGS=-fopenmp=libomp",
-                    "-DOpenMP_CXX_LIB_NAMES=libomp",
-                    "-DOpenMP_libomp_LIBRARY={0}/lib/libomp.dylib".format(clang_root),
-                ]
-            )
-
-        if "+rocm" in spec:
-            args.extend(
-                [
-                    "-DCMAKE_CXX_FLAGS=-std=c++17",
-                    "-DHIP_ROOT_DIR={0}".format(spec["hip"].prefix),
-                    "-DHIP_CXX_COMPILER={0}".format(self.spec["hip"].hipcc),
-                ]
-            )
-            if "platform=cray" in spec:
-                args.extend(["-DMPI_ASSUME_NO_BUILTIN_MPI=ON"])
-            archs = self.spec.variants["amdgpu_target"].value
-            if archs != "none":
-                arch_str = ",".join(archs)
-                args.append(
-                    "-DHIP_HIPCC_FLAGS=--amdgpu-target={0}"
-                    " -g -fsized-deallocation -fPIC -std=c++17".format(arch_str)
+            entries.append(cmake_cache_string("OpenMP_CXX_FLAGS", "-fopenmp=libomp"))
+            entries.append(cmake_cache_string("OpenMP_CXX_LIB_NAMES", "libomp"))
+            entries.append(
+                cmake_cache_string(
+                    "OpenMP_libomp_LIBRARY", "{0}/lib/libomp.dylib".format(clang_root)
                 )
-                args.extend(
-                    [
-                        "-DCMAKE_HIP_ARCHITECTURES=%s" % arch_str,
-                        "-DAMDGPU_TARGETS=%s" % arch_str,
-                        "-DGPU_TARGETS=%s" % arch_str,
-                    ]
-                )
-
-        if self.spec.satisfies("^essl"):
-            # IF IBM ESSL is used it needs help finding the proper LAPACK libraries
-            args.extend(
-                [
-                    "-DLAPACK_LIBRARIES=%s;-llapack;-lblas"
-                    % ";".join("-l{0}".format(lib) for lib in self.spec["essl"].libs.names),
-                    "-DBLAS_LIBRARIES=%s;-lblas"
-                    % ";".join("-l{0}".format(lib) for lib in self.spec["essl"].libs.names),
-                ]
             )
 
-        return args
+        return entries
+
+    def initconfig_hardware_entries(self):
+        spec = self.spec
+        entries = super(Dihydrogen, self).initconfig_hardware_entries()
+
+        entries.append(cmake_cache_option("H2_ENABLE_CUDA", "+cuda" in spec))
+        if spec.satisfies("+cuda"):
+            entries.append(cmake_cache_string("CMAKE_CUDA_STANDARD", "17"))
+            if not spec.satisfies("cuda_arch=none"):
+                archs = spec.variants["cuda_arch"].value
+                arch_str = ";".join(archs)
+                entries.append(cmake_cache_string("CMAKE_CUDA_ARCHITECTURES", arch_str))
+
+            # FIXME: Should this use the "cuda_flags" function of the
+            # CudaPackage class or something? There might be other
+            # flags in play, and we need to be sure to get them all.
+            cuda_flags = self.get_cuda_flags()
+            if len(cuda_flags) > 0:
+                entries.append(cmake_cache_string("CMAKE_CUDA_FLAGS", " ".join(cuda_flags)))
+
+        enable_rocm_var = (
+            "H2_ENABLE_ROCM" if spec.version < Version("0.3") else "H2_ENABLE_HIP_ROCM"
+        )
+        entries.append(cmake_cache_option(enable_rocm_var, "+rocm" in spec))
+        if spec.satisfies("+rocm"):
+            entries.append(cmake_cache_string("CMAKE_HIP_STANDARD", "17"))
+            if not spec.satisfies("amdgpu_target=none"):
+                archs = self.spec.variants["amdgpu_target"].value
+                arch_str = ";".join(archs)
+                entries.append(cmake_cache_string("CMAKE_HIP_ARCHITECTURES", arch_str))
+                entries.append(cmake_cache_string("AMDGPU_TARGETS", arch_str))
+                entries.append(cmake_cache_string("GPU_TARGETS", arch_str))
+            entries.append(cmake_cache_path("HIP_ROOT_DIR", spec["hip"].prefix))
+
+        return entries
+
+    def initconfig_package_entries(self):
+        spec = self.spec
+        entries = super(Dihydrogen, self).initconfig_package_entries()
+
+        # Basic H2 options
+        entries.append(cmake_cache_option("H2_DEVELOPER_BUILD", "+developer" in spec))
+        entries.append(cmake_cache_option("H2_ENABLE_TESTS", "+developer" in spec))
+
+        entries.append(cmake_cache_option("H2_ENABLE_CODE_COVERAGE", "+coverage" in spec))
+        entries.append(cmake_cache_option("H2_CI_BUILD", "+ci" in spec))
+
+        entries.append(cmake_cache_option("H2_ENABLE_DACE", "+dace" in spec))
+
+        # DistConv options
+        entries.append(cmake_cache_option("H2_ENABLE_ALUMINUM", "+distconv" in spec))
+        entries.append(cmake_cache_option("H2_ENABLE_DISTCONV_LEGACY", "+distconv" in spec))
+        entries.append(cmake_cache_option("H2_ENABLE_OPENMP", "+distconv" in spec))
+
+        # Paths to stuff, just in case. CMAKE_PREFIX_PATH should catch
+        # all this, but this shouldn't hurt to have.
+        entries.append(cmake_cache_path("spdlog_ROOT", spec["spdlog"].prefix))
+
+        if "+developer" in spec:
+            entries.append(cmake_cache_path("Catch2_ROOT", spec["catch2"].prefix))
+
+        if "+coverage" in spec:
+            entries.append(cmake_cache_path("lcov_ROOT", spec["lcov"].prefix))
+            entries.append(cmake_cache_path("genhtml_ROOT", spec["lcov"].prefix))
+            if "+ci" in spec:
+                entries.append(cmake_cache_path("gcovr_ROOT", spec["py-gcovr"].prefix))
+
+        if "+distconv" in spec:
+            entries.append(cmake_cache_path("Aluminum_ROOT", spec["aluminum"].prefix))
+            if "+cuda" in spec:
+                entries.append(cmake_cache_path("cuDNN_ROOT", spec["cudnn"].prefix))
+
+        # Currently this is a hack for all Hydrogen versions. WIP to
+        # fix this at develop.
+        entries.extend(get_blas_entries(spec))
+        return entries
 
     def setup_build_environment(self, env):
         if self.spec.satisfies("%apple-clang +openmp"):

var/spack/repos/builtin/packages/discotec/package.py

@@ -18,6 +18,7 @@ class Discotec(CMakePackage):
 
     version("main", branch="main")
 
+    variant("compression", default=False, description="Write sparse grid files compressed")
     variant("ft", default=False, description="DisCoTec with algorithm-based fault tolerance")
     variant("gene", default=False, description="Build for GENE (as task library)")
     variant("hdf5", default=True, description="Interpolation output with HDF5")
@@ -31,6 +32,7 @@ class Discotec(CMakePackage):
     depends_on("cmake@3.24.2:", type="build")
     depends_on("glpk")
     depends_on("highfive+mpi+boost+ipo", when="+hdf5")
+    depends_on("lz4", when="+compression")
     depends_on("mpi")
     depends_on("selalib", when="+selalib")
     depends_on("vtk", when="+vtk")
@@ -38,6 +40,7 @@ class Discotec(CMakePackage):
     def cmake_args(self):
         args = [
             self.define("DISCOTEC_BUILD_MISSING_DEPS", False),
+            self.define_from_variant("DISCOTEC_WITH_COMPRESSION", "compression"),
             self.define_from_variant("DISCOTEC_ENABLEFT", "ft"),
             self.define_from_variant("DISCOTEC_GENE", "gene"),
             self.define_from_variant("DISCOTEC_OPENMP", "openmp"),

var/spack/repos/builtin/packages/fdb/package.py

@@ -16,7 +16,6 @@ class Fdb(CMakePackage):
 
     maintainers("skosukhin")
 
-    # master version of fdb is subject to frequent changes and is to be used experimentally.
     version("master", branch="master")
     version("5.11.23", sha256="09b1d93f2b71d70c7b69472dfbd45a7da0257211f5505b5fcaf55bfc28ca6c65")
     version("5.11.17", sha256="375c6893c7c60f6fdd666d2abaccb2558667bd450100817c0e1072708ad5591e")
@@ -44,6 +43,7 @@ class Fdb(CMakePackage):
     depends_on("ecbuild@3.7:", type="build", when="@5.11.6:")
 
     depends_on("eckit@1.16:")
+    depends_on("eckit@1.24.4:", when="@5.11.22:")
     depends_on("eckit+admin", when="+tools")
 
     depends_on("eccodes@2.10:")

var/spack/repos/builtin/packages/ginkgo/package.py

@@ -24,7 +24,8 @@ class Ginkgo(CMakePackage, CudaPackage, ROCmPackage):
 
     version("develop", branch="develop")
     version("master", branch="master")
-    version("1.6.0", commit="1f1ed46e724334626f016f105213c047e16bc1ae", preferred=True)  # v1.6.0
+    version("1.7.0", commit="49242ff89af1e695d7794f6d50ed9933024b66fe")  # v1.7.0
+    version("1.6.0", commit="1f1ed46e724334626f016f105213c047e16bc1ae")  # v1.6.0
     version("1.5.0", commit="234594c92b58e2384dfb43c2d08e7f43e2b58e7a")  # v1.5.0
     version("1.5.0.glu_experimental", branch="glu_experimental")
     version("1.4.0", commit="f811917c1def4d0fcd8db3fe5c948ce13409e28e")  # v1.4.0
@@ -37,13 +38,18 @@ class Ginkgo(CMakePackage, CudaPackage, ROCmPackage):
     variant("shared", default=True, description="Build shared libraries")
     variant("full_optimizations", default=False, description="Compile with all optimizations")
     variant("openmp", default=sys.platform != "darwin", description="Build with OpenMP")
-    variant("oneapi", default=False, description="Build with oneAPI support")
+    variant("sycl", default=False, description="Enable SYCL backend")
     variant("develtools", default=False, description="Compile with develtools enabled")
     variant("hwloc", default=False, description="Enable HWLOC support")
     variant("mpi", default=False, description="Enable MPI support")
 
-    depends_on("cmake@3.9:", type="build")
-    depends_on("cuda@9:", when="+cuda")
+    depends_on("cmake@3.9:", type="build", when="@:1.3.0")
+    depends_on("cmake@3.13:", type="build", when="@1.4.0:1.6.0")
+    depends_on("cmake@3.16:", type="build", when="@1.7.0:")
+    depends_on("cmake@3.18:", type="build", when="+cuda@1.7.0:")
+    depends_on("cuda@9:", when="+cuda @:1.4.0")
+    depends_on("cuda@9.2:", when="+cuda @1.5.0:")
+    depends_on("cuda@10.1:", when="+cuda @1.7.0:")
     depends_on("mpi", when="+mpi")
 
     depends_on("rocthrust", when="+rocm")
@@ -60,14 +66,13 @@ class Ginkgo(CMakePackage, CudaPackage, ROCmPackage):
     depends_on("googletest", type="test")
     depends_on("numactl", type="test", when="+hwloc")
 
-    depends_on("intel-oneapi-mkl", when="+oneapi")
-    depends_on("intel-oneapi-dpl", when="+oneapi")
+    depends_on("intel-oneapi-mkl", when="+sycl")
+    depends_on("intel-oneapi-dpl", when="+sycl")
+    depends_on("intel-oneapi-tbb", when="+sycl")
 
     conflicts("%gcc@:5.2.9")
     conflicts("+rocm", when="@:1.1.1")
     conflicts("+mpi", when="@:1.4.0")
-    conflicts("+cuda", when="+rocm")
-    conflicts("+openmp", when="+oneapi")
 
     # ROCm 4.1.0 breaks platform settings which breaks Ginkgo's HIP support.
     conflicts("^hip@4.1.0:", when="@:1.3.0")
@@ -76,22 +81,35 @@ class Ginkgo(CMakePackage, CudaPackage, ROCmPackage):
     conflicts("^rocthrust@4.1.0:", when="@:1.3.0")
     conflicts("^rocprim@4.1.0:", when="@:1.3.0")
 
+    # Ginkgo 1.6.0 start relying on ROCm 4.5.0
+    conflicts("^hip@:4.3.1", when="@1.6.0:")
+    conflicts("^hipblas@:4.3.1", when="@1.6.0:")
+    conflicts("^hipsparse@:4.3.1", when="@1.6.0:")
+    conflicts("^rocthrust@:4.3.1", when="@1.6.0:")
+    conflicts("^rocprim@:4.3.1", when="@1.6.0:")
+
+    conflicts(
+        "+sycl", when="@:1.4.0", msg="For SYCL support, please use Ginkgo version 1.4.0 and newer."
+    )
+
     # Skip smoke tests if compatible hardware isn't found
     patch("1.4.0_skip_invalid_smoke_tests.patch", when="@1.4.0")
 
-    # Newer DPC++ compilers use the updated SYCL 2020 standard which change
-    # kernel attribute propagation rules. This doesn't work well with the
-    # initial Ginkgo oneAPI support.
-    patch("1.4.0_dpcpp_use_old_standard.patch", when="+oneapi @1.4.0")
-
     # Add missing include statement
     patch("thrust-count-header.patch", when="+rocm @1.5.0")
 
     def setup_build_environment(self, env):
         spec = self.spec
-        if "+oneapi" in spec:
+        if "+sycl" in spec:
             env.set("MKLROOT", join_path(spec["intel-oneapi-mkl"].prefix, "mkl", "latest"))
             env.set("DPL_ROOT", join_path(spec["intel-oneapi-dpl"].prefix, "dpl", "latest"))
+            # The `IntelSYCLConfig.cmake` is broken with spack. By default, it
+            # relies on the CMAKE_CXX_COMPILER being the real ipcx/dpcpp
+            # compiler. If not, the variable SYCL_COMPILER of that script is
+            # broken, and all the SYCL detection mechanism is wrong. We fix it
+            # by giving hint environment variables.
+            env.set("SYCL_LIBRARY_DIR_HINT", os.path.dirname(os.path.dirname(self.compiler.cxx)))
+            env.set("SYCL_INCLUDE_DIR_HINT", os.path.dirname(os.path.dirname(self.compiler.cxx)))
 
     def cmake_args(self):
         # Check that the have the correct C++ standard is available
@@ -106,18 +124,19 @@ def cmake_args(self):
             except UnsupportedCompilerFlag:
                 raise InstallError("Ginkgo requires a C++14-compliant C++ compiler")
 
-        cxx_is_dpcpp = os.path.basename(self.compiler.cxx) == "dpcpp"
-        if self.spec.satisfies("+oneapi") and not cxx_is_dpcpp:
-            raise InstallError(
-                "Ginkgo's oneAPI backend requires the" + "DPC++ compiler as main CXX compiler."
-            )
+        if self.spec.satisfies("@1.4.0:1.6.0 +sycl") and not self.spec.satisfies(
+            "%oneapi@2021.3.0:"
+        ):
+            raise InstallError("ginkgo +sycl requires %oneapi@2021.3.0:")
+        elif self.spec.satisfies("@1.7.0: +sycl") and not self.spec.satisfies("%oneapi@2022.1.0:"):
+            raise InstallError("ginkgo +sycl requires %oneapi@2022.1.0:")
 
         spec = self.spec
         from_variant = self.define_from_variant
         args = [
             from_variant("GINKGO_BUILD_CUDA", "cuda"),
             from_variant("GINKGO_BUILD_HIP", "rocm"),
-            from_variant("GINKGO_BUILD_DPCPP", "oneapi"),
+            from_variant("GINKGO_BUILD_SYCL", "sycl"),
             from_variant("GINKGO_BUILD_OMP", "openmp"),
             from_variant("GINKGO_BUILD_MPI", "mpi"),
             from_variant("BUILD_SHARED_LIBS", "shared"),
@@ -161,6 +180,11 @@ def cmake_args(self):
                 args.append(
                     self.define("CMAKE_MODULE_PATH", self.spec["hip"].prefix.lib.cmake.hip)
                 )
+
+        if "+sycl" in self.spec:
+            sycl_compatible_compilers = ["dpcpp", "icpx"]
+            if not (os.path.basename(self.compiler.cxx) in sycl_compatible_compilers):
+                raise InstallError("ginkgo +sycl requires DPC++ (dpcpp) or icpx compiler.")
         return args
 
     @property

var/spack/repos/builtin/packages/gotcha/package.py

@@ -17,6 +17,7 @@ class Gotcha(CMakePackage):
 
     version("develop", branch="develop")
     version("master", branch="master")
+    version("1.0.5", tag="1.0.5", commit="e28f10c45a0cda0e1ec225eaea6abfe72c8353aa")
     version("1.0.4", tag="1.0.4", commit="46f2aaedc885f140a3f31a17b9b9a9d171f3d6f0")
     version("1.0.3", tag="1.0.3", commit="1aafd1e30d46ce4e6555c8a4ea5f5edf6a5eade5")
     version("1.0.2", tag="1.0.2", commit="bed1b7c716ebb0604b3e063121649b5611640f25")

var/spack/repos/builtin/packages/hdf5/package.py

@@ -711,6 +711,17 @@ def fix_package_config(self):
                     if not os.path.exists(tgt_filename):
                         symlink(src_filename, tgt_filename)
 
+    @run_after("install")
+    def link_debug_libs(self):
+        # When build_type is Debug, the hdf5 build appends _debug to all library names.
+        # Dependents of hdf5 (netcdf-c etc.) can't handle those, thus make symlinks.
+        if "build_type=Debug" in self.spec:
+            libs = find(self.prefix.lib, "libhdf5*_debug.*", recursive=False)
+            with working_dir(self.prefix.lib):
+                for lib in libs:
+                    libname = os.path.split(lib)[1]
+                    os.symlink(libname, libname.replace("_debug", ""))
+
     @property
     @llnl.util.lang.memoized
     def _output_version(self):

var/spack/repos/builtin/packages/hydrogen/package.py

@@ -7,254 +7,268 @@
 
 from spack.package import *
 
+# This limits the versions of lots of things pretty severely.
+#
+#   - Only v1.5.2 and newer are buildable.
+#   - CMake must be v3.22 or newer.
+#   - CUDA must be v11.0.0 or newer.
 
-class Hydrogen(CMakePackage, CudaPackage, ROCmPackage):
+
+class Hydrogen(CachedCMakePackage, CudaPackage, ROCmPackage):
     """Hydrogen: Distributed-memory dense and sparse-direct linear algebra
     and optimization library. Based on the Elemental library."""
 
     homepage = "https://libelemental.org"
-    url = "https://github.com/LLNL/Elemental/archive/v1.0.1.tar.gz"
+    url = "https://github.com/LLNL/Elemental/archive/v1.5.1.tar.gz"
     git = "https://github.com/LLNL/Elemental.git"
     tags = ["ecp", "radiuss"]
 
     maintainers("bvanessen")
 
     version("develop", branch="hydrogen")
+    version("1.5.3", sha256="faefbe738bd364d0e26ce9ad079a11c93a18c6f075719a365fd4fa5f1f7a989a")
+    version("1.5.2", sha256="a902cad3962471216cfa278ba0561c18751d415cd4d6b2417c02a43b0ab2ea33")
     version("1.5.1", sha256="447da564278f98366906d561d9c8bc4d31678c56d761679c2ff3e59ee7a2895c")
-    version("1.5.0", sha256="03dd487fb23b9fdbc715554a8ea48c3196a1021502e61b0172ef3fdfbee75180")
-    version("1.4.0", sha256="c13374ff4a6c4d1076e47ba8c8d91a7082588b9958d1ed89cffb12f1d2e1452e")
-    version("1.3.4", sha256="7979f6656f698f0bbad6798b39d4b569835b3013ff548d98089fce7c283c6741")
-    version("1.3.3", sha256="a51a1cfd40ac74d10923dfce35c2c04a3082477683f6b35e7b558ea9f4bb6d51")
-    version("1.3.2", sha256="50bc5e87955f8130003d04dfd9dcad63107e92b82704f8107baf95b0ccf98ed6")
-    version("1.3.1", sha256="a8b8521458e9e747f2b24af87c4c2749a06e500019c383e0cefb33e5df6aaa1d")
-    version("1.3.0", sha256="0f3006aa1d8235ecdd621e7344c99f56651c6836c2e1bc0cf006331b70126b36")
-    version("1.2.0", sha256="8545975139582ee7bfe5d00f8d83a8697afc285bf7026b0761e9943355974806")
-    version("1.1.0-1", sha256="73ce05e4166853a186469269cb00a454de71e126b2019f95bbae703b65606808")
-    version("1.1.0", sha256="b4c12913acd01c72d31f4522266bfeb8df1d4d3b4aef02e07ccbc9a477894e71")
-    version("1.0.1", sha256="27cf76e1ef1d58bd8f9b1e34081a14a682b7ff082fb5d1da56713e5e0040e528")
-    version("1.0", sha256="d8a97de3133f2c6b6bb4b80d32b4a4cc25eb25e0df4f0cec0f8cb19bf34ece98")
+    # Older versions are no longer supported.
 
-    variant("shared", default=True, description="Enables the build of shared libraries")
-    variant("openmp", default=True, description="Make use of OpenMP within CPU-kernels")
-    variant(
-        "openmp_blas", default=False, description="Use OpenMP for threading in the BLAS library"
-    )
-    variant("quad", default=False, description="Enable quad precision")
-    variant("int64", default=False, description="Use 64bit integers")
-    variant("int64_blas", default=False, description="Use 64bit integers for BLAS.")
-    variant("scalapack", default=False, description="Build with ScaLAPACK library")
+    variant("shared", default=True, description="Enables the build of shared libraries.")
     variant(
         "build_type",
         default="Release",
         description="The build type to build",
         values=("Debug", "Release"),
     )
+    variant("int64", default=False, description="Use 64-bit integers")
+    variant("al", default=False, description="Use Aluminum communication library")
+    variant(
+        "cub", default=True, when="+cuda", description="Use CUB/hipCUB for GPU memory management"
+    )
+    variant(
+        "cub", default=True, when="+rocm", description="Use CUB/hipCUB for GPU memory management"
+    )
+    variant("half", default=False, description="Support for FP16 precision data types")
+
+    # TODO: Add netlib-lapack. For GPU-enabled builds, typical
+    # workflows don't touch host BLAS/LAPACK all that often, and even
+    # less frequently in performance-critical regions.
     variant(
         "blas",
-        default="openblas",
-        values=("openblas", "mkl", "accelerate", "essl", "libsci"),
-        description="Enable the use of OpenBlas/MKL/Accelerate/ESSL/LibSci",
+        default="any",
+        values=("any", "openblas", "mkl", "accelerate", "essl", "libsci"),
+        description="Specify a host BLAS library preference",
     )
-    variant(
-        "mpfr",
-        default=False,
-        description="Support GNU MPFR's" "arbitrary-precision floating-point arithmetic",
-    )
-    variant("test", default=False, description="Builds test suite")
-    variant("al", default=False, description="Builds with Aluminum communication library")
+    variant("int64_blas", default=False, description="Use 64-bit integers for (host) BLAS.")
+
+    variant("openmp", default=True, description="Make use of OpenMP within CPU kernels")
     variant(
         "omp_taskloops",
+        when="+openmp",
         default=False,
-        description="Use OpenMP taskloops instead of parallel for loops.",
+        description="Use OpenMP taskloops instead of parallel for loops",
     )
-    variant("half", default=False, description="Builds with support for FP16 precision data types")
 
-    conflicts("~openmp", when="+omp_taskloops")
+    # Users should spec this on their own on the command line, no?
+    # This doesn't affect Hydrogen itself at all. Not one bit.
+    # variant(
+    #     "openmp_blas",
+    #     default=False,
+    #     description="Use OpenMP for threading in the BLAS library")
+
+    variant("test", default=False, description="Builds test suite")
+
     conflicts("+cuda", when="+rocm", msg="CUDA and ROCm support are mutually exclusive")
+    conflicts("+half", when="+rocm", msg="FP16 support not implemented for ROCm.")
 
-    depends_on("cmake@3.21.0:", type="build", when="@1.5.2:")
-    depends_on("cmake@3.17.0:", type="build", when="@:1.5.1")
-    depends_on("cmake@3.22.0:", type="build", when="%cce")
+    depends_on("cmake@3.22.0:", type="build", when="@1.5.2:")
+    depends_on("cmake@3.17.0:", type="build", when="@1.5.1")
 
     depends_on("mpi")
-    depends_on("hwloc@1.11:")
-    depends_on("hwloc +cuda +nvml", when="+cuda")
-    depends_on("hwloc@2.3.0:", when="+rocm")
+    depends_on("blas")
+    depends_on("lapack")
 
     # Note that #1712 forces us to enumerate the different blas variants
+    # Note that this forces us to use OpenBLAS until #1712 is fixed
     depends_on("openblas", when="blas=openblas")
     depends_on("openblas +ilp64", when="blas=openblas +int64_blas")
-    depends_on("openblas threads=openmp", when="blas=openblas +openmp_blas")
 
     depends_on("intel-mkl", when="blas=mkl")
     depends_on("intel-mkl +ilp64", when="blas=mkl +int64_blas")
-    depends_on("intel-mkl threads=openmp", when="blas=mkl +openmp_blas")
 
+    # I don't think this is true...
     depends_on("veclibfort", when="blas=accelerate")
-    conflicts("blas=accelerate +openmp_blas")
 
     depends_on("essl", when="blas=essl")
     depends_on("essl +ilp64", when="blas=essl +int64_blas")
-    depends_on("essl threads=openmp", when="blas=essl +openmp_blas")
+
     depends_on("netlib-lapack +external-blas", when="blas=essl")
 
     depends_on("cray-libsci", when="blas=libsci")
-    depends_on("cray-libsci +openmp", when="blas=libsci +openmp_blas")
 
     # Specify the correct version of Aluminum
-    depends_on("aluminum@:0.3", when="@:1.3 +al")
-    depends_on("aluminum@0.4.0:0.4", when="@1.4.0:1.4 +al")
-    depends_on("aluminum@0.6.0:0.6", when="@1.5.0:1.5.1 +al")
-    depends_on("aluminum@0.7.0:", when="@:1.0,1.5.2: +al")
+    depends_on("aluminum@0.7.0:", when="@1.5.2: +al")
 
     # Add Aluminum variants
-    depends_on("aluminum +cuda +nccl +cuda_rma", when="+al +cuda")
-    depends_on("aluminum +rocm +rccl", when="+al +rocm")
+    depends_on("aluminum +cuda +ht", when="+al +cuda")
+    depends_on("aluminum +rocm +ht", when="+al +rocm")
 
     for arch in CudaPackage.cuda_arch_values:
-        depends_on("aluminum cuda_arch=%s" % arch, when="+al +cuda cuda_arch=%s" % arch)
+        depends_on("aluminum +cuda cuda_arch=%s" % arch, when="+al +cuda cuda_arch=%s" % arch)
 
     # variants +rocm and amdgpu_targets are not automatically passed to
     # dependencies, so do it manually.
     for val in ROCmPackage.amdgpu_targets:
-        depends_on("aluminum amdgpu_target=%s" % val, when="+al +rocm amdgpu_target=%s" % val)
+        depends_on(
+            "aluminum +rocm amdgpu_target=%s" % val, when="+al +rocm amdgpu_target=%s" % val
+        )
 
-    # Note that this forces us to use OpenBLAS until #1712 is fixed
-    depends_on("lapack", when="blas=openblas ~openmp_blas")
-
-    depends_on("scalapack", when="+scalapack")
-    depends_on("gmp", when="+mpfr")
-    depends_on("mpc", when="+mpfr")
-    depends_on("mpfr", when="+mpfr")
-
-    depends_on("cuda", when="+cuda")
-    depends_on("cub", when="^cuda@:10")
-    depends_on("hipcub", when="+rocm")
+    depends_on("cuda@11.0.0:", when="+cuda")
+    depends_on("hipcub +rocm", when="+rocm +cub")
     depends_on("half", when="+half")
 
     depends_on("llvm-openmp", when="%apple-clang +openmp")
 
-    conflicts(
-        "@0:0.98",
-        msg="Hydrogen did not exist before v0.99. " + "Did you mean to use Elemental instead?",
-    )
-
-    generator("ninja")
-
     @property
     def libs(self):
         shared = True if "+shared" in self.spec else False
-        return find_libraries("libEl", root=self.prefix, shared=shared, recursive=True)
+        return find_libraries("libHydrogen", root=self.prefix, shared=shared, recursive=True)
 
     def cmake_args(self):
+        args = []
+        return args
+
+    def get_cuda_flags(self):
         spec = self.spec
+        args = []
+        if spec.satisfies("^cuda+allow-unsupported-compilers"):
+            args.append("-allow-unsupported-compiler")
 
-        enable_gpu_fp16 = "+cuda" in spec and "+half" in spec
+        if spec.satisfies("%clang"):
+            for flag in spec.compiler_flags["cxxflags"]:
+                if "gcc-toolchain" in flag:
+                    args.append("-Xcompiler={0}".format(flag))
+        return args
 
-        args = [
-            "-DCMAKE_CXX_STANDARD=17",
-            "-DCMAKE_INSTALL_MESSAGE:STRING=LAZY",
-            "-DBUILD_SHARED_LIBS:BOOL=%s" % ("+shared" in spec),
-            "-DHydrogen_ENABLE_OPENMP:BOOL=%s" % ("+openmp" in spec),
-            "-DHydrogen_ENABLE_QUADMATH:BOOL=%s" % ("+quad" in spec),
-            "-DHydrogen_USE_64BIT_INTS:BOOL=%s" % ("+int64" in spec),
-            "-DHydrogen_USE_64BIT_BLAS_INTS:BOOL=%s" % ("+int64_blas" in spec),
-            "-DHydrogen_ENABLE_MPC:BOOL=%s" % ("+mpfr" in spec),
-            "-DHydrogen_GENERAL_LAPACK_FALLBACK=ON",
-            "-DHydrogen_ENABLE_ALUMINUM=%s" % ("+al" in spec),
-            "-DHydrogen_ENABLE_CUB=%s" % ("+cuda" in spec or "+rocm" in spec),
-            "-DHydrogen_ENABLE_CUDA=%s" % ("+cuda" in spec),
-            "-DHydrogen_ENABLE_ROCM=%s" % ("+rocm" in spec),
-            "-DHydrogen_ENABLE_TESTING=%s" % ("+test" in spec),
-            "-DHydrogen_ENABLE_HALF=%s" % ("+half" in spec),
-            "-DHydrogen_ENABLE_GPU_FP16=%s" % enable_gpu_fp16,
-        ]
+    def std_initconfig_entries(self):
+        entries = super(Hydrogen, self).std_initconfig_entries()
 
-        if not spec.satisfies("^cmake@3.23.0"):
-            # There is a bug with using Ninja generator in this version
-            # of CMake
-            args.append("-DCMAKE_EXPORT_COMPILE_COMMANDS=ON")
+        # CMAKE_PREFIX_PATH, in CMake types, is a "STRING", not a "PATH". :/
+        entries = [x for x in entries if "CMAKE_PREFIX_PATH" not in x]
+        cmake_prefix_path = os.environ["CMAKE_PREFIX_PATH"].replace(":", ";")
+        entries.append(cmake_cache_string("CMAKE_PREFIX_PATH", cmake_prefix_path))
+        # IDK why this is here, but it was in the original recipe. So, yeah.
+        entries.append(cmake_cache_string("CMAKE_INSTALL_MESSAGE", "LAZY"))
+        return entries
 
-        if "+cuda" in spec:
-            if self.spec.satisfies("%clang"):
-                for flag in self.spec.compiler_flags["cxxflags"]:
-                    if "gcc-toolchain" in flag:
-                        args.append("-DCMAKE_CUDA_FLAGS=-Xcompiler={0}".format(flag))
-            args.append("-DCMAKE_CUDA_STANDARD=14")
-            archs = spec.variants["cuda_arch"].value
-            if archs != "none":
-                arch_str = ";".join(archs)
-                args.append("-DCMAKE_CUDA_ARCHITECTURES=%s" % arch_str)
+    def initconfig_compiler_entries(self):
+        spec = self.spec
+        entries = super(Hydrogen, self).initconfig_compiler_entries()
 
-            if spec.satisfies("%cce") and spec.satisfies("^cuda+allow-unsupported-compilers"):
-                args.append("-DCMAKE_CUDA_FLAGS=-allow-unsupported-compiler")
+        # FIXME: Enforce this better in the actual CMake.
+        entries.append(cmake_cache_string("CMAKE_CXX_STANDARD", "17"))
+        entries.append(cmake_cache_option("BUILD_SHARED_LIBS", "+shared" in spec))
+        entries.append(cmake_cache_option("CMAKE_EXPORT_COMPILE_COMMANDS", True))
 
-        if "+rocm" in spec:
-            args.extend(
-                [
-                    "-DCMAKE_CXX_FLAGS=-std=c++17",
-                    "-DHIP_ROOT_DIR={0}".format(spec["hip"].prefix),
-                    "-DHIP_CXX_COMPILER={0}".format(self.spec["hip"].hipcc),
-                ]
-            )
-            archs = self.spec.variants["amdgpu_target"].value
-            if archs != "none":
-                arch_str = ",".join(archs)
-                cxxflags_str = " ".join(self.spec.compiler_flags["cxxflags"])
-                args.append(
-                    "-DHIP_HIPCC_FLAGS=--amdgpu-target={0}"
-                    " -g -fsized-deallocation -fPIC {1}"
-                    " -std=c++17".format(arch_str, cxxflags_str)
-                )
-                args.extend(
-                    [
-                        "-DCMAKE_HIP_ARCHITECTURES=%s" % arch_str,
-                        "-DAMDGPU_TARGETS=%s" % arch_str,
-                        "-DGPU_TARGETS=%s" % arch_str,
-                    ]
-                )
+        entries.append(cmake_cache_option("MPI_ASSUME_NO_BUILTIN_MPI", True))
 
-        # Add support for OS X to find OpenMP (LLVM installed via brew)
-        if self.spec.satisfies("%clang +openmp platform=darwin"):
+        if spec.satisfies("%clang +openmp platform=darwin") or spec.satisfies(
+            "%clang +omp_taskloops platform=darwin"
+        ):
             clang = self.compiler.cc
             clang_bin = os.path.dirname(clang)
             clang_root = os.path.dirname(clang_bin)
-            args.extend(["-DOpenMP_DIR={0}".format(clang_root)])
+            entries.append(cmake_cache_string("OpenMP_CXX_FLAGS", "-fopenmp=libomp"))
+            entries.append(cmake_cache_string("OpenMP_CXX_LIB_NAMES", "libomp"))
+            entries.append(
+                cmake_cache_string(
+                    "OpenMP_libomp_LIBRARY", "{0}/lib/libomp.dylib".format(clang_root)
+                )
+            )
+
+        return entries
+
+    def initconfig_hardware_entries(self):
+        spec = self.spec
+        entries = super(Hydrogen, self).initconfig_hardware_entries()
+
+        entries.append(cmake_cache_option("Hydrogen_ENABLE_CUDA", "+cuda" in spec))
+        if spec.satisfies("+cuda"):
+            entries.append(cmake_cache_string("CMAKE_CUDA_STANDARD", "17"))
+            if not spec.satisfies("cuda_arch=none"):
+                archs = spec.variants["cuda_arch"].value
+                arch_str = ";".join(archs)
+                entries.append(cmake_cache_string("CMAKE_CUDA_ARCHITECTURES", arch_str))
+
+            # FIXME: Should this use the "cuda_flags" function of the
+            # CudaPackage class or something? There might be other
+            # flags in play, and we need to be sure to get them all.
+            cuda_flags = self.get_cuda_flags()
+            if len(cuda_flags) > 0:
+                entries.append(cmake_cache_string("CMAKE_CUDA_FLAGS", " ".join(cuda_flags)))
+
+        entries.append(cmake_cache_option("Hydrogen_ENABLE_ROCM", "+rocm" in spec))
+        if spec.satisfies("+rocm"):
+            entries.append(cmake_cache_string("CMAKE_HIP_STANDARD", "17"))
+            if not spec.satisfies("amdgpu_target=none"):
+                archs = self.spec.variants["amdgpu_target"].value
+                arch_str = ";".join(archs)
+                entries.append(cmake_cache_string("CMAKE_HIP_ARCHITECTURES", arch_str))
+                entries.append(cmake_cache_string("AMDGPU_TARGETS", arch_str))
+                entries.append(cmake_cache_string("GPU_TARGETS", arch_str))
+            entries.append(cmake_cache_path("HIP_ROOT_DIR", spec["hip"].prefix))
+
+        return entries
+
+    def initconfig_package_entries(self):
+        spec = self.spec
+        entries = super(Hydrogen, self).initconfig_package_entries()
+
+        # Basic Hydrogen options
+        entries.append(cmake_cache_option("Hydrogen_ENABLE_TESTING", "+test" in spec))
+        entries.append(cmake_cache_option("Hydrogen_GENERAL_LAPACK_FALLBACK", True))
+        entries.append(cmake_cache_option("Hydrogen_USE_64BIT_INTS", "+int64" in spec))
+        entries.append(cmake_cache_option("Hydrogen_USE_64BIT_BLAS_INTS", "+int64_blas" in spec))
+
+        # Advanced dependency options
+        entries.append(cmake_cache_option("Hydrogen_ENABLE_ALUMINUM", "+al" in spec))
+        entries.append(cmake_cache_option("Hydrogen_ENABLE_CUB", "+cub" in spec))
+        entries.append(cmake_cache_option("Hydrogen_ENABLE_GPU_FP16", "+cuda +half" in spec))
+        entries.append(cmake_cache_option("Hydrogen_ENABLE_HALF", "+half" in spec))
+        entries.append(cmake_cache_option("Hydrogen_ENABLE_OPENMP", "+openmp" in spec))
+        entries.append(
+            cmake_cache_option("Hydrogen_ENABLE_OMP_TASKLOOP", "+omp_taskloops" in spec)
+        )
+
+        # Note that CUDA/ROCm are handled above.
 
         if "blas=openblas" in spec:
-            args.extend(
-                [
-                    "-DHydrogen_USE_OpenBLAS:BOOL=%s" % ("blas=openblas" in spec),
-                    "-DOpenBLAS_DIR:STRING={0}".format(spec["openblas"].prefix),
-                ]
-            )
-        elif "blas=mkl" in spec:
-            args.extend(["-DHydrogen_USE_MKL:BOOL=%s" % ("blas=mkl" in spec)])
-        elif "blas=accelerate" in spec:
-            args.extend(["-DHydrogen_USE_ACCELERATE:BOOL=TRUE"])
-        elif "blas=essl" in spec:
+            entries.append(cmake_cache_option("Hydrogen_USE_OpenBLAS", "blas=openblas" in spec))
+            # CMAKE_PREFIX_PATH should handle this
+            entries.append(cmake_cache_string("OpenBLAS_DIR", spec["openblas"].prefix))
+        elif "blas=mkl" in spec or spec.satisfies("^intel-mkl"):
+            entries.append(cmake_cache_option("Hydrogen_USE_MKL", True))
+        elif "blas=essl" in spec or spec.satisfies("^essl"):
+            entries.append(cmake_cache_string("BLA_VENDOR", "IBMESSL"))
             # IF IBM ESSL is used it needs help finding the proper LAPACK libraries
-            args.extend(
-                [
-                    "-DLAPACK_LIBRARIES=%s;-llapack;-lblas"
+            entries.append(
+                cmake_cache_string(
+                    "LAPACK_LIBRARIES",
+                    "%s;-llapack;-lblas"
                     % ";".join("-l{0}".format(lib) for lib in self.spec["essl"].libs.names),
-                    "-DBLAS_LIBRARIES=%s;-lblas"
+                )
+            )
+            entries.append(
+                cmake_cache_string(
+                    "BLAS_LIBRARIES",
+                    "%s;-lblas"
                     % ";".join("-l{0}".format(lib) for lib in self.spec["essl"].libs.names),
-                ]
+                )
             )
+        elif "blas=accelerate" in spec:
+            entries.append(cmake_cache_option("Hydrogen_USE_ACCELERATE", True))
+        elif spec.satisfies("^netlib-lapack"):
+            entries.append(cmake_cache_string("BLA_VENDOR", "Generic"))
 
-        if "+omp_taskloops" in spec:
-            args.extend(["-DHydrogen_ENABLE_OMP_TASKLOOP:BOOL=%s" % ("+omp_taskloops" in spec)])
-
-        if "+al" in spec:
-            args.extend(
-                [
-                    "-DHydrogen_ENABLE_ALUMINUM:BOOL=%s" % ("+al" in spec),
-                    "-DALUMINUM_DIR={0}".format(spec["aluminum"].prefix),
-                ]
-            )
-
-        return args
+        return entries
 
     def setup_build_environment(self, env):
         if self.spec.satisfies("%apple-clang +openmp"):

var/spack/repos/builtin/packages/hypre/package.py

@@ -24,6 +24,7 @@ class Hypre(AutotoolsPackage, CudaPackage, ROCmPackage):
     test_requires_compiler = True
 
     version("develop", branch="master")
+    version("2.30.0", sha256="8e2af97d9a25bf44801c6427779f823ebc6f306438066bba7fcbc2a5f9b78421")
     version("2.29.0", sha256="98b72115407a0e24dbaac70eccae0da3465f8f999318b2c9241631133f42d511")
     version("2.28.0", sha256="2eea68740cdbc0b49a5e428f06ad7af861d1e169ce6a12d2cf0aa2fc28c4a2ae")
     version("2.27.0", sha256="507a3d036bb1ac21a55685ae417d769dd02009bde7e09785d0ae7446b4ae1f98")
@@ -107,6 +108,7 @@ def patch(self):  # fix sequential compilation in 'src/seq_mv'
     depends_on("rocthrust", when="+rocm")
     depends_on("rocrand", when="+rocm")
     depends_on("rocprim", when="+rocm")
+    depends_on("hipblas", when="+rocm +superlu-dist")
     depends_on("umpire", when="+umpire")
     depends_on("caliper", when="+caliper")
 
@@ -258,6 +260,8 @@ def configure_args(self):
 
         if "+rocm" in spec:
             rocm_pkgs = ["rocsparse", "rocthrust", "rocprim", "rocrand"]
+            if "+superlu-dist" in spec:
+                rocm_pkgs.append("hipblas")
             rocm_inc = ""
             for pkg in rocm_pkgs:
                 if "^" + pkg in spec:

var/spack/repos/builtin/packages/intel-xed/package.py

@@ -21,6 +21,8 @@ class IntelXed(Package):
 
     # Current versions now have actual releases and tags.
     version("main", branch="main")
+    version("2023.10.11", tag="v2023.10.11", commit="d7d46c73fb04a1742e99c9382a4acb4ed07ae272")
+    version("2023.08.21", tag="v2023.08.21", commit="01a6da8090af84cd52f6c1070377ae6e885b078f")
     version("2023.07.09", tag="v2023.07.09", commit="539a6a349cf7538a182ed3ee1f48bb9317eb185f")
     version("2023.06.07", tag="v2023.06.07", commit="4dc77137f651def2ece4ac0416607b215c18e6e4")
     version("2023.04.16", tag="v2023.04.16", commit="a3055cd0209f5c63c88e280bbff9579b1e2942e2")
@@ -40,7 +42,12 @@ class IntelXed(Package):
 
     # Match xed more closely with the version of mbuild at the time.
     resource(
-        name="mbuild", placement=mdir, git=mbuild_git, tag="v2022.07.28", when="@2022.07:9999"
+        name="mbuild",
+        placement=mdir,
+        git=mbuild_git,
+        tag="v2022.07.28",
+        commit="75cb46e6536758f1a3cdb3d6bd83a4a9fd0338bb",
+        when="@2022.07:9999",
     )
 
     resource(
@@ -48,7 +55,7 @@ class IntelXed(Package):
         placement=mdir,
         git=mbuild_git,
         tag="v2022.04.17",
-        commit="ef19f00de14a9c2c253c1c9b1119e1617280e3f2",
+        commit="b41485956bf65d51b8c2379768de7eaaa7a4245b",
         when="@:2022.06",
     )
 

var/spack/repos/builtin/packages/julia/package.py

@@ -26,6 +26,7 @@ class Julia(MakefilePackage):
     maintainers("vchuravy", "haampie", "giordano")
 
     version("master", branch="master")
+    version("1.9.3", sha256="8d7dbd8c90e71179e53838cdbe24ff40779a90d7360e29766609ed90d982081d")
     version("1.9.2", sha256="015438875d591372b80b09d01ba899657a6517b7c72ed41222298fef9d4ad86b")
     version("1.9.0", sha256="48f4c8a7d5f33d0bc6ce24226df20ab49e385c2d0c3767ec8dfdb449602095b2")
     version("1.8.5", sha256="d31026cc6b275d14abce26fd9fd5b4552ac9d2ce8bde4291e494468af5743031")
@@ -163,7 +164,8 @@ class Julia(MakefilePackage):
     )
 
     # patchelf 0.13 is required because the rpath patch uses --add-rpath
-    depends_on("patchelf@0.13:", type="build")
+    # patchelf 0.18 breaks (at least) libjulia-internal.so
+    depends_on("patchelf@0.13:0.17", type="build")
     depends_on("perl", type="build")
     depends_on("libwhich", type="build")
     depends_on("python", type="build")

var/spack/repos/builtin/packages/lbann/lbann_v0.104_build_cleanup.patch

@@ -0,0 +1,39 @@
+diff --git a/src/callbacks/memory_profiler.cpp b/src/callbacks/memory_profiler.cpp
+index 0d5cec5d2..6f40705af 100644
+--- a/src/callbacks/memory_profiler.cpp
++++ b/src/callbacks/memory_profiler.cpp
+@@ -158,7 +158,10 @@ struct MemUsage
+   size_t total_mem;
+ 
+   MemUsage(const std::string& r, size_t m) : report(r), total_mem(m) {}
+-  bool operator<(const MemUsage& other) { return total_mem < other.total_mem; }
++  bool operator<(const MemUsage& other) const
++  {
++    return total_mem < other.total_mem;
++  }
+ };
+ } // namespace
+ 
+diff --git a/src/optimizers/adam.cpp b/src/optimizers/adam.cpp
+index d00dfbe7c..1d9ad3949 100644
+--- a/src/optimizers/adam.cpp
++++ b/src/optimizers/adam.cpp
+@@ -34,14 +34,12 @@
+ 
+ namespace lbann {
+ 
+-#if defined (LBANN_HAS_ROCM) && defined (LBANN_HAS_GPU_FP16)
++#if defined(LBANN_HAS_ROCM) && defined(LBANN_HAS_GPU_FP16)
+ namespace {
+-bool isfinite(fp16 const& x)
+-{
+-  return std::isfinite(float(x));
+-}
+-}
++bool isfinite(fp16 const& x) { return std::isfinite(float(x)); }
++} // namespace
+ #endif
++using std::isfinite;
+ 
+ template <typename TensorDataType>
+ adam<TensorDataType>::adam(TensorDataType learning_rate,

var/spack/repos/builtin/packages/lbann/package.py

@@ -5,7 +5,6 @@
 
 import os
 import socket
-import sys
 
 from spack.package import *
 
@@ -24,109 +23,42 @@ class Lbann(CachedCMakePackage, CudaPackage, ROCmPackage):
     maintainers("bvanessen")
 
     version("develop", branch="develop")
-    version("0.102", sha256="3734a76794991207e2dd2221f05f0e63a86ddafa777515d93d99d48629140f1a")
+    version("benchmarking", branch="benchmarking")
+    version("0.104", sha256="a847c7789082ab623ed5922ab1248dd95f5f89d93eed44ac3d6a474703bbc0bf")
+    version("0.103", sha256="9da1bf308f38323e30cb07f8ecf8efa05c7f50560e8683b9cd961102b1b3e25a")
     version(
-        "0.101",
-        sha256="69d3fe000a88a448dc4f7e263bcb342c34a177bd9744153654528cd86335a1f7",
-        deprecated=True,
-    )
-    version(
-        "0.100",
-        sha256="d1bab4fb6f1b80ae83a7286cc536a32830890f6e5b0c3107a17c2600d0796912",
-        deprecated=True,
-    )
-    version(
-        "0.99",
-        sha256="3358d44f1bc894321ce07d733afdf6cb7de39c33e3852d73c9f31f530175b7cd",
-        deprecated=True,
-    )
-    version(
-        "0.98.1",
-        sha256="9a2da8f41cd8bf17d1845edf9de6d60f781204ebd37bffba96d8872036c10c66",
-        deprecated=True,
-    )
-    version(
-        "0.98",
-        sha256="8d64b9ac0f1d60db553efa4e657f5ea87e790afe65336117267e9c7ae6f68239",
-        deprecated=True,
-    )
-    version(
-        "0.97.1",
-        sha256="2f2756126ac8bb993202cf532d72c4d4044e877f4d52de9fdf70d0babd500ce4",
-        deprecated=True,
-    )
-    version(
-        "0.97",
-        sha256="9794a706fc7ac151926231efdf74564c39fbaa99edca4acb745ee7d20c32dae7",
-        deprecated=True,
-    )
-    version(
-        "0.96",
-        sha256="97af78e9d3c405e963361d0db96ee5425ee0766fa52b43c75b8a5670d48e4b4a",
-        deprecated=True,
-    )
-    version(
-        "0.95",
-        sha256="d310b986948b5ee2bedec36383a7fe79403721c8dc2663a280676b4e431f83c2",
-        deprecated=True,
-    )
-    version(
-        "0.94",
-        sha256="567e99b488ebe6294933c98a212281bffd5220fc13a0a5cd8441f9a3761ceccf",
-        deprecated=True,
-    )
-    version(
-        "0.93",
-        sha256="77bfd7fe52ee7495050f49bcdd0e353ba1730e3ad15042c678faa5eeed55fb8c",
-        deprecated=True,
-    )
-    version(
-        "0.92",
-        sha256="9187c5bcbc562c2828fe619d53884ab80afb1bcd627a817edb935b80affe7b84",
-        deprecated=True,
-    )
-    version(
-        "0.91",
-        sha256="b69f470829f434f266119a33695592f74802cff4b76b37022db00ab32de322f5",
+        "0.102",
+        sha256="3734a76794991207e2dd2221f05f0e63a86ddafa777515d93d99d48629140f1a",
         deprecated=True,
     )
 
-    variant("al", default=True, description="Builds with support for Aluminum Library")
     variant(
         "build_type",
         default="Release",
         description="The build type to build",
         values=("Debug", "Release"),
     )
-    variant(
-        "conduit",
-        default=True,
-        description="Builds with support for Conduit Library "
-        "(note that for v0.99 conduit is required)",
-    )
     variant(
         "deterministic",
         default=False,
         description="Builds with support for deterministic execution",
     )
-    variant(
-        "dihydrogen", default=True, description="Builds with support for DiHydrogen Tensor Library"
-    )
     variant(
         "distconv",
         default=False,
+        sticky=True,
         description="Builds with support for spatial, filter, or channel "
         "distributed convolutions",
     )
     variant(
         "dtype",
         default="float",
+        sticky=True,
         description="Type for floating point representation of weights",
         values=("float", "double"),
     )
     variant("fft", default=False, description="Support for FFT operations")
     variant("half", default=False, description="Builds with support for FP16 precision data types")
-    variant("hwloc", default=True, description="Add support for topology aware algorithms")
     variant("nvprof", default=False, description="Build with region annotations for NVPROF")
     variant(
         "numpy", default=False, description="Builds with support for processing NumPy data files"
@@ -139,7 +71,7 @@ class Lbann(CachedCMakePackage, CudaPackage, ROCmPackage):
     variant("vtune", default=False, description="Builds with support for Intel VTune")
     variant("onednn", default=False, description="Support for OneDNN")
     variant("onnx", default=False, description="Support for exporting models into ONNX format")
-    variant("nvshmem", default=False, description="Support for NVSHMEM")
+    variant("nvshmem", default=False, description="Support for NVSHMEM", when="+distconv")
     variant(
         "python",
         default=True,
@@ -168,20 +100,13 @@ class Lbann(CachedCMakePackage, CudaPackage, ROCmPackage):
     # Don't expose this a dependency until Spack can find the external properly
     # depends_on('binutils+gold', type='build', when='+gold')
 
+    patch("lbann_v0.104_build_cleanup.patch", when="@0.104:")
+
     # Variant Conflicts
-    conflicts("@:0.90,0.99:", when="~conduit")
-    conflicts("@0.90:0.101", when="+fft")
-    conflicts("@:0.90,0.102:", when="~dihydrogen")
     conflicts("~cuda", when="+nvprof")
-    conflicts("~hwloc", when="+al")
     conflicts("~cuda", when="+nvshmem")
     conflicts("+cuda", when="+rocm", msg="CUDA and ROCm support are mutually exclusive")
 
-    conflicts("~vision", when="@0.91:0.101")
-    conflicts("~numpy", when="@0.91:0.101")
-    conflicts("~python", when="@0.91:0.101")
-    conflicts("~pfe", when="@0.91:0.101")
-
     requires("%clang", when="+lld")
 
     conflicts("+lld", when="+gold")
@@ -191,84 +116,56 @@ class Lbann(CachedCMakePackage, CudaPackage, ROCmPackage):
     depends_on("cmake@3.17.0:", type="build")
     depends_on("cmake@3.21.0:", type="build", when="@0.103:")
 
-    # Specify the correct versions of Hydrogen
-    depends_on("hydrogen@:1.3.4", when="@0.95:0.100")
-    depends_on("hydrogen@1.4.0:1.4", when="@0.101:0.101.99")
-    depends_on("hydrogen@1.5.0:", when="@:0.90,0.102:")
+    # Specify the core libraries: Hydrogen, DiHydrogen, Aluminum
+    depends_on("hydrogen@1.5.3:")
+    depends_on("aluminum@1.4.1:")
+    depends_on("dihydrogen@0.2.0:")
+
+    # Align the following variants across Hydrogen and DiHydrogen
+    forwarded_variants = ["cuda", "rocm", "half", "nvshmem"]
+    for v in forwarded_variants:
+        if v != "nvshmem":
+            depends_on("hydrogen +{0}".format(v), when="+{0}".format(v))
+            depends_on("hydrogen ~{0}".format(v), when="~{0}".format(v))
+        if v != "al" and v != "half":
+            depends_on("dihydrogen +{0}".format(v), when="+{0}".format(v))
+            depends_on("dihydrogen ~{0}".format(v), when="~{0}".format(v))
+        if v == "cuda" or v == "rocm":
+            depends_on("aluminum +{0} +nccl".format(v), when="+{0}".format(v))
 
     # Add Hydrogen variants
     depends_on("hydrogen +openmp +shared +int64")
-    depends_on("hydrogen +openmp_blas", when=sys.platform != "darwin")
-    depends_on("hydrogen ~al", when="~al")
-    depends_on("hydrogen +al", when="+al")
-    depends_on("hydrogen ~cuda", when="~cuda")
-    depends_on("hydrogen +cuda", when="+cuda")
-    depends_on("hydrogen ~half", when="~half")
-    depends_on("hydrogen +half", when="+half")
-    depends_on("hydrogen ~rocm", when="~rocm")
-    depends_on("hydrogen +rocm", when="+rocm")
     depends_on("hydrogen build_type=Debug", when="build_type=Debug")
 
-    # Older versions depended on Elemental not Hydrogen
-    depends_on("elemental +openmp_blas +shared +int64", when="@0.91:0.94")
-    depends_on(
-        "elemental +openmp_blas +shared +int64 build_type=Debug",
-        when="build_type=Debug @0.91:0.94",
-    )
-
-    # Specify the correct version of Aluminum
-    depends_on("aluminum@:0.3", when="@0.95:0.100 +al")
-    depends_on("aluminum@0.4.0:0.4", when="@0.101:0.101.99 +al")
-    depends_on("aluminum@0.5.0:", when="@:0.90,0.102: +al")
+    # Add DiHydrogen variants
+    depends_on("dihydrogen +distconv", when="+distconv")
+    depends_on("dihydrogen@develop", when="@develop")
 
     # Add Aluminum variants
-    depends_on("aluminum +cuda +nccl", when="+al +cuda")
-    depends_on("aluminum +rocm +rccl", when="+al +rocm")
-
-    depends_on("dihydrogen@0.2.0:", when="@:0.90,0.102:")
-    depends_on("dihydrogen +openmp", when="+dihydrogen")
-    depends_on("dihydrogen +openmp_blas", when=sys.platform != "darwin")
-    depends_on("dihydrogen ~cuda", when="+dihydrogen ~cuda")
-    depends_on("dihydrogen +cuda", when="+dihydrogen +cuda")
-    depends_on("dihydrogen ~al", when="+dihydrogen ~al")
-    depends_on("dihydrogen +al", when="+dihydrogen +al")
-    depends_on("dihydrogen +distconv +cuda", when="+distconv +cuda")
-    depends_on("dihydrogen +distconv +rocm", when="+distconv +rocm")
-    depends_on("dihydrogen ~half", when="+dihydrogen ~half")
-    depends_on("dihydrogen +half", when="+dihydrogen +half")
-    depends_on("dihydrogen ~nvshmem", when="+dihydrogen ~nvshmem")
-    depends_on("dihydrogen +nvshmem", when="+dihydrogen +nvshmem")
-    depends_on("dihydrogen ~rocm", when="+dihydrogen ~rocm")
-    depends_on("dihydrogen +rocm", when="+dihydrogen +rocm")
-    depends_on("dihydrogen@0.1", when="@0.101:0.101.99 +dihydrogen")
-    depends_on("dihydrogen@:0.0,0.2:", when="@:0.90,0.102: +dihydrogen")
-    conflicts("~dihydrogen", when="+distconv")
+    depends_on("aluminum@master", when="@develop")
 
     depends_on("hdf5+mpi", when="+distconv")
 
     for arch in CudaPackage.cuda_arch_values:
         depends_on("hydrogen cuda_arch=%s" % arch, when="+cuda cuda_arch=%s" % arch)
-        depends_on("aluminum cuda_arch=%s" % arch, when="+al +cuda cuda_arch=%s" % arch)
-        depends_on("dihydrogen cuda_arch=%s" % arch, when="+dihydrogen +cuda cuda_arch=%s" % arch)
+        depends_on("aluminum cuda_arch=%s" % arch, when="+cuda cuda_arch=%s" % arch)
+        depends_on("dihydrogen cuda_arch=%s" % arch, when="+cuda cuda_arch=%s" % arch)
         depends_on("nccl cuda_arch=%s" % arch, when="+cuda cuda_arch=%s" % arch)
 
     # variants +rocm and amdgpu_targets are not automatically passed to
     # dependencies, so do it manually.
     for val in ROCmPackage.amdgpu_targets:
         depends_on("hydrogen amdgpu_target=%s" % val, when="amdgpu_target=%s" % val)
-        depends_on("aluminum amdgpu_target=%s" % val, when="+al amdgpu_target=%s" % val)
-        depends_on("dihydrogen amdgpu_target=%s" % val, when="+dihydrogen amdgpu_target=%s" % val)
+        depends_on("aluminum amdgpu_target=%s" % val, when="amdgpu_target=%s" % val)
+        depends_on("dihydrogen amdgpu_target=%s" % val, when="amdgpu_target=%s" % val)
 
     depends_on("roctracer-dev", when="+rocm +distconv")
 
-    depends_on("cudnn", when="@0.90:0.100 +cuda")
-    depends_on("cudnn@8.0.2:", when="@:0.90,0.101: +cuda")
-    depends_on("cub", when="@0.94:0.98.2 +cuda ^cuda@:10")
-    depends_on("cutensor", when="@:0.90,0.102: +cuda")
+    depends_on("cudnn@8.0.2:", when="+cuda")
+    depends_on("cutensor", when="+cuda")
     depends_on("hipcub", when="+rocm")
     depends_on("mpi")
-    depends_on("hwloc@1.11:", when="@:0.90,0.102: +hwloc")
-    depends_on("hwloc@1.11.0:1.11", when="@0.95:0.101 +hwloc")
+    depends_on("hwloc@1.11:")
     depends_on("hwloc +cuda +nvml", when="+cuda")
     depends_on("hwloc@2.3.0:", when="+rocm")
     depends_on("hiptt", when="+rocm")
@@ -296,9 +193,7 @@ class Lbann(CachedCMakePackage, CudaPackage, ROCmPackage):
     # Note that conduit defaults to +fortran +parmetis +python, none of which are
     # necessary by LBANN: you may want to disable those options in your
     # packages.yaml
-    depends_on("conduit@0.4.0: +hdf5", when="@0.94:0 +conduit")
-    depends_on("conduit@0.5.0:0.6 +hdf5", when="@0.100:0.101 +conduit")
-    depends_on("conduit@0.6.0: +hdf5", when="@:0.90,0.99:")
+    depends_on("conduit@0.6.0: +hdf5")
 
     # LBANN can use Python in two modes 1) as part of an extensible framework
     # and 2) to drive the front end model creation and launch
@@ -308,12 +203,12 @@ class Lbann(CachedCMakePackage, CudaPackage, ROCmPackage):
     extends("python", when="+python")
 
     # Python front end and possible extra packages
-    depends_on("python@3: +shared", type=("build", "run"), when="@:0.90,0.99: +pfe")
+    depends_on("python@3: +shared", type=("build", "run"), when="+pfe")
     extends("python", when="+pfe")
     depends_on("py-setuptools", type="build", when="+pfe")
-    depends_on("py-protobuf+cpp@3.10.0:", type=("build", "run"), when="@:0.90,0.99: +pfe")
+    depends_on("py-protobuf+cpp@3.10.0:4.21.12", type=("build", "run"), when="+pfe")
 
-    depends_on("protobuf+shared@3.10.0:", when="@:0.90,0.99:")
+    depends_on("protobuf+shared@3.10.0:3.21.12")
     depends_on("zlib-api", when="protobuf@3.11.0:")
 
     # using cereal@1.3.1 and above requires changing the
@@ -328,7 +223,7 @@ class Lbann(CachedCMakePackage, CudaPackage, ROCmPackage):
     depends_on("onnx", when="+onnx")
     depends_on("nvshmem", when="+nvshmem")
 
-    depends_on("spdlog", when="@:0.90,0.102:")
+    depends_on("spdlog@1.11.0")
     depends_on("zstr")
 
     depends_on("caliper+adiak+mpi", when="+caliper")
@@ -336,6 +231,7 @@ class Lbann(CachedCMakePackage, CudaPackage, ROCmPackage):
     generator("ninja")
 
     def setup_build_environment(self, env):
+        env.append_flags("CXXFLAGS", "-fno-omit-frame-pointer")
         if self.spec.satisfies("%apple-clang"):
             env.append_flags("CPPFLAGS", self.compiler.openmp_flag)
             env.append_flags("CFLAGS", self.spec["llvm-openmp"].headers.include_flags)
@@ -357,7 +253,7 @@ def libs(self):
     def cache_name(self):
         hostname = socket.gethostname()
         # Get a hostname that has no node identifier
-        hostname = hostname.rstrip("1234567890")
+        hostname = hostname.rstrip("1234567890-")
         return "LBANN_{0}_{1}-{2}-{3}@{4}.cmake".format(
             hostname,
             self.spec.version,
@@ -440,12 +336,9 @@ def initconfig_package_entries(self):
         cmake_variant_fields = [
             ("LBANN_WITH_CNPY", "numpy"),
             ("LBANN_DETERMINISTIC", "deterministic"),
-            ("LBANN_WITH_HWLOC", "hwloc"),
-            ("LBANN_WITH_ALUMINUM", "al"),
             ("LBANN_WITH_ADDRESS_SANITIZER", "asan"),
             ("LBANN_WITH_BOOST", "boost"),
             ("LBANN_WITH_CALIPER", "caliper"),
-            ("LBANN_WITH_CONDUIT", "conduit"),
             ("LBANN_WITH_NVSHMEM", "nvshmem"),
             ("LBANN_WITH_FFT", "fft"),
             ("LBANN_WITH_ONEDNN", "onednn"),
@@ -460,6 +353,9 @@ def initconfig_package_entries(self):
         for opt, val in cmake_variant_fields:
             entries.append(self.define_cmake_cache_from_variant(opt, val))
 
+        entries.append(cmake_cache_option("LBANN_WITH_ALUMINUM", True))
+        entries.append(cmake_cache_option("LBANN_WITH_CONDUIT", True))
+        entries.append(cmake_cache_option("LBANN_WITH_HWLOC", True))
         entries.append(cmake_cache_option("LBANN_WITH_ROCTRACER", "+rocm +distconv" in spec))
         entries.append(cmake_cache_option("LBANN_WITH_TBINF", False))
         entries.append(
@@ -492,7 +388,7 @@ def initconfig_package_entries(self):
                 )
             )
 
-        entries.append(self.define_cmake_cache_from_variant("LBANN_WITH_DIHYDROGEN", "dihydrogen"))
+        entries.append(cmake_cache_option("LBANN_WITH_DIHYDROGEN", True))
         entries.append(self.define_cmake_cache_from_variant("LBANN_WITH_DISTCONV", "distconv"))
 
         # IF IBM ESSL is used it needs help finding the proper LAPACK libraries

var/spack/repos/builtin/packages/lcov/package.py

@@ -13,14 +13,42 @@ class Lcov(MakefilePackage):
     supports statement, function and branch coverage measurement."""
 
     homepage = "http://ltp.sourceforge.net/coverage/lcov.php"
-    url = "https://github.com/linux-test-project/lcov/releases/download/v1.14/lcov-1.14.tar.gz"
+    url = "https://github.com/linux-test-project/lcov/releases/download/v2.0/lcov-2.0.tar.gz"
     maintainers("KineticTheory")
 
+    version("2.0", sha256="1857bb18e27abe8bcec701a907d5c47e01db4d4c512fc098d1a6acd29267bf46")
     version("1.16", sha256="987031ad5528c8a746d4b52b380bc1bffe412de1f2b9c2ba5224995668e3240b")
     version("1.15", sha256="c1cda2fa33bec9aa2c2c73c87226cfe97de0831887176b45ee523c5e30f8053a")
     version("1.14", sha256="14995699187440e0ae4da57fe3a64adc0a3c5cf14feab971f8db38fb7d8f071a")
 
-    depends_on("perl")
+    # dependencies from
+    # https://github.com/linux-test-project/lcov/blob/02ece21d54ccd16255d74f8b00f8875b6c15653a/README#L91-L111
+    depends_on("perl", type=("build", "run"))
+    depends_on("perl-b-hooks-endofscope", type=("run"))
+    depends_on("perl-capture-tiny", type=("run"))
+    depends_on("perl-class-inspector", type=("run"))
+    depends_on("perl-class-singleton", type=("run"))
+    depends_on("perl-datetime", type=("run"))
+    depends_on("perl-datetime-locale", type=("run"))
+    depends_on("perl-datetime-timezone", type=("run"))
+    depends_on("perl-devel-cover", type=("run"))
+    depends_on("perl-devel-stacktrace", type=("run"))
+    depends_on("perl-digest-md5", type=("run"))
+    depends_on("perl-eval-closure", type=("run"))
+    depends_on("perl-exception-class", type=("run"))
+    depends_on("perl-file-sharedir", type=("run"))
+    depends_on("perl-file-spec", type=("run"))
+    depends_on("perl-json", type=("run"))
+    depends_on("perl-memory-process", type=("run"))
+    depends_on("perl-module-implementation", type=("run"))
+    depends_on("perl-mro-compat", type=("run"))
+    depends_on("perl-namespace-clean", type=("run"))
+    depends_on("perl-package-stash", type=("run"))
+    depends_on("perl-params-validationcompiler", type=("run"))
+    depends_on("perl-role-tiny", type=("run"))
+    depends_on("perl-specio", type=("run"))
+    depends_on("perl-sub-identify", type=("run"))
+    depends_on("perl-time-hires", type=("run"))
 
     def install(self, spec, prefix):
         make(

var/spack/repos/builtin/packages/libgit2/package.py

@@ -83,6 +83,7 @@ class Libgit2(CMakePackage):
     depends_on("cmake@2.8:", type="build", when="@:0.28")
     depends_on("cmake@3.5:", type="build", when="@0.99:")
     depends_on("pkgconfig", type="build")
+    depends_on("python", type="test")
 
     # Runtime Dependencies
     depends_on("libssh2", when="+ssh")
@@ -123,5 +124,6 @@ def cmake_args(self):
 
         # Control tests
         args.append(self.define("BUILD_CLAR", self.run_tests))
+        args.append(self.define("BUILD_TESTS", self.run_tests))
 
         return args

var/spack/repos/builtin/packages/mapl/package.py

@@ -36,6 +36,11 @@ class Mapl(CMakePackage):
     version("develop", branch="develop")
     version("main", branch="main")
 
+    version("2.42.0", sha256="9b6c3434919c14ef79004db5f76cb3dd8ef375584227101c230a372bb0470fdd")
+    version("2.41.2", sha256="73e1f0961f1b70e8159c0a2ce3499eb5158f3ca6d081f4c7826af7854ebfb44d")
+    version("2.41.1", sha256="2b384bd4fbaac1bff4ef009922c436c4ab54832172a5cd4d312ea44e32c1ae7c")
+    version("2.41.0", sha256="1142f9395e161174e3ec1654fba8bda1d0bd93edc7438b1927d8f5d7b42a0a86")
+    version("2.40.4", sha256="fb843b118d6e56cd4fc4b114c4d6f91956d5c8b3d9389ada56da1dfdbc58904f")
     version("2.40.3", sha256="4b82a314c88a035fc2b91395750aa7950d6bee838786178ed16a3f39a1e45519")
     version("2.40.2", sha256="7327f6f5bce6e09e7f7b930013fba86ee7cbfe8ed4c7c087fc9ab5acbf6640fd")
     version("2.40.1", sha256="6f40f946fabea6ba73b0764092e495505d220455b191b4e454736a0a25ee058c")
@@ -116,6 +121,12 @@ class Mapl(CMakePackage):
 
     # Versions later than 3.14 remove FindESMF.cmake
     # from ESMA_CMake.
+    resource(
+        name="esma_cmake",
+        git="https://github.com/GEOS-ESM/ESMA_cmake.git",
+        tag="v3.36.0",
+        when="@2.42.0:",
+    )
     resource(
         name="esma_cmake",
         git="https://github.com/GEOS-ESM/ESMA_cmake.git",
@@ -159,6 +170,12 @@ class Mapl(CMakePackage):
     # Patch to add missing MPI Fortran target to top-level CMakeLists.txt
     patch("mapl-2.12.3-mpi-fortran.patch", when="@:2.12.3")
 
+    # MAPL only compiles with MPICH from version 2.42.0 and higher so we conflict
+    # with older versions. Also, it's only been tested with MPICH 4, so we don't
+    # allow older MPICH
+    conflicts("mpich@:3")
+    conflicts("mpich@4", when="@:2.41")
+
     variant("flap", default=False, description="Build with FLAP support", when="@:2.39")
     variant("pflogger", default=True, description="Build with pFlogger support")
     variant("fargparse", default=True, description="Build with fArgParse support")

var/spack/repos/builtin/packages/mfem/package.py

@@ -967,6 +967,9 @@ def find_optional_library(name, prefix):
             if "^rocthrust" in spec and not spec["hip"].external:
                 # petsc+rocm needs the rocthrust header path
                 hip_headers += spec["rocthrust"].headers
+            if "^hipblas" in spec and not spec["hip"].external:
+                # superlu-dist+rocm needs the hipblas header path
+                hip_headers += spec["hipblas"].headers
             if "%cce" in spec:
                 # We assume the proper Cray CCE module (cce) is loaded:
                 craylibs_path = env["CRAYLIBS_" + machine().upper()]

var/spack/repos/builtin/packages/patchelf/package.py

@@ -19,7 +19,14 @@ class Patchelf(AutotoolsPackage):
     maintainers("haampie")
 
     version("0.18.0", sha256="64de10e4c6b8b8379db7e87f58030f336ea747c0515f381132e810dbf84a86e7")
-    version("0.17.2", sha256="20427b718dd130e4b66d95072c2a2bd5e17232e20dad58c1bea9da81fae330e0")
+    # patchelf 0.18 breaks libraries:
+    # https://github.com/spack/spack/issues/39252
+    # https://github.com/spack/spack/pull/40938
+    version(
+        "0.17.2",
+        sha256="20427b718dd130e4b66d95072c2a2bd5e17232e20dad58c1bea9da81fae330e0",
+        preferred=True,
+    )
     version("0.16.1", sha256="1a562ed28b16f8a00456b5f9ee573bb1af7c39c1beea01d94fc0c7b3256b0406")
     version("0.15.0", sha256="53a8d58ed4e060412b8fdcb6489562b3c62be6f65cee5af30eba60f4423bfa0f")
     version("0.14.5", sha256="113ada3f1ace08f0a7224aa8500f1fa6b08320d8f7df05ff58585286ec5faa6f")

var/spack/repos/builtin/packages/perl-class-singleton/package.py

@@ -0,0 +1,15 @@
+# Copyright 2013-2023 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)
+
+from spack.package import *
+
+
+class PerlClassSingleton(PerlPackage):
+    """Class::Singleton - Implementation of a "Singleton" class"""
+
+    homepage = "https://metacpan.org/pod/Class::Singleton"
+    url = "https://cpan.metacpan.org/authors/id/S/SH/SHAY/Class-Singleton-1.6.tar.gz"
+
+    version("1.6", sha256="27ba13f0d9512929166bbd8c9ef95d90d630fc80f0c9a1b7458891055e9282a4")

var/spack/repos/builtin/packages/perl-datetime-locale/package.py

@@ -0,0 +1,17 @@
+# Copyright 2013-2023 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)
+
+from spack.package import *
+
+
+class PerlDatetimeLocale(PerlPackage):
+    """DateTime::Locale - Localization support for DateTime.pm"""
+
+    homepage = "https://metacpan.org/pod/DateTime::Locale"
+    url = "https://cpan.metacpan.org/authors/id/D/DR/DROLSKY/DateTime-Locale-1.40.tar.gz"
+
+    version("1.40", sha256="7490b4194b5d23a4e144976dedb3bdbcc6d3364b5d139cc922a86d41fdb87afb")
+
+    depends_on("perl-file-sharedir-install", type=("build", "run"))

var/spack/repos/builtin/packages/perl-datetime-timezone/package.py

@@ -0,0 +1,15 @@
+# Copyright 2013-2023 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)
+
+from spack.package import *
+
+
+class PerlDatetimeTimezone(PerlPackage):
+    """DateTime::TimeZone - Time zone object base class and factory"""
+
+    homepage = "https://metacpan.org/pod/DateTime::TimeZone"
+    url = "https://cpan.metacpan.org/authors/id/D/DR/DROLSKY/DateTime-TimeZone-2.60.tar.gz"
+
+    version("2.60", sha256="f0460d379323905b579bed44e141237a337dc25dd26b6ab0c60ac2b80629323d")

var/spack/repos/builtin/packages/perl-datetime/package.py

@@ -0,0 +1,17 @@
+# Copyright 2013-2023 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)
+
+from spack.package import *
+
+
+class PerlDatetime(PerlPackage):
+    """DateTime - A date and time object for Perl"""
+
+    homepage = "https://metacpan.org/pod/DateTime"
+    url = "https://cpan.metacpan.org/authors/id/D/DR/DROLSKY/DateTime-1.63.tar.gz"
+
+    version("1.63", sha256="1b11e49ec6e184ae2a10eccd05eda9534f32458fc644c12ab710c29a3a816f6f")
+
+    depends_on("perl-namespace-autoclean", type=("run"))

var/spack/repos/builtin/packages/perl-devel-cover/package.py

@@ -0,0 +1,15 @@
+# Copyright 2013-2023 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)
+
+from spack.package import *
+
+
+class PerlDevelCover(PerlPackage):
+    """Devel::Cover - Perl extension for code coverage metrics"""
+
+    homepage = "https://metacpan.org/pod/Devel::Cover"
+    url = "https://cpan.metacpan.org/authors/id/P/PJ/PJCJ/Devel-Cover-1.40.tar.gz"
+
+    version("1.40", sha256="26e2f431fbcf7bff3851f352f83b84067c09ff206f40ab975cad8d2bafe711a8")

var/spack/repos/builtin/packages/perl-file-sharedir/package.py

@@ -0,0 +1,17 @@
+# Copyright 2013-2023 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)
+
+from spack.package import *
+
+
+class PerlFileSharedir(PerlPackage):
+    """File::ShareDir - Locate per-dist and per-module shared files"""
+
+    homepage = "https://metacpan.org/pod/File::ShareDir"
+    url = "https://cpan.metacpan.org/authors/id/R/RE/REHSACK/File-ShareDir-1.118.tar.gz"
+
+    version("1.118", sha256="3bb2a20ba35df958dc0a4f2306fc05d903d8b8c4de3c8beefce17739d281c958")
+
+    # depends_on("perl-module-build", type="build")

var/spack/repos/builtin/packages/perl-file-spec/package.py

@@ -0,0 +1,15 @@
+# Copyright 2013-2023 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)
+
+from spack.package import *
+
+
+class PerlFileSpec(PerlPackage):
+    """File::Spec - Perl extension for portably performing operations on file names"""
+
+    homepage = "https://metacpan.org/pod/File::Spec"
+    url = "https://cpan.metacpan.org/authors/id/K/KW/KWILLIAMS/File-Spec-0.90.tar.gz"
+
+    version("0.90", sha256="695a34604e1b6a98327fe2b374504329735b07c2c45db9f55df1636e4c29bf79")

var/spack/repos/builtin/packages/perl-memory-process/package.py

@@ -0,0 +1,15 @@
+# Copyright 2013-2023 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)
+
+from spack.package import *
+
+
+class PerlMemoryProcess(PerlPackage):
+    """Memory::Process - Perl class to determine actual memory usage"""
+
+    homepage = "https://metacpan.org/pod/Memory::Process"
+    url = "https://cpan.metacpan.org/authors/id/S/SK/SKIM/Memory-Process-0.06.tar.gz"
+
+    version("0.06", sha256="35814488ffd29c97621625ea3b3d700afbfa60ed055bd759d4e58d9c8fd44e4e")

var/spack/repos/builtin/packages/perl-namespace-autoclean/package.py

@@ -0,0 +1,15 @@
+# Copyright 2013-2023 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)
+
+from spack.package import *
+
+
+class PerlNamespaceAutoclean(PerlPackage):
+    """Namespace::Autoclean - Keep imports out of your namespace"""
+
+    homepage = "https://metacpan.org/pod/namespace::autoclean"
+    url = "https://cpan.metacpan.org/authors/id/E/ET/ETHER/namespace-autoclean-0.29.tar.gz"
+
+    version("0.29", sha256="45ebd8e64a54a86f88d8e01ae55212967c8aa8fed57e814085def7608ac65804")

var/spack/repos/builtin/packages/perl-params-validationcompiler/package.py

@@ -0,0 +1,16 @@
+# Copyright 2013-2023 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)
+
+from spack.package import *
+
+
+class PerlParamsValidationcompiler(PerlPackage):
+    """Params::ValidationCompiler - Build an optimized subroutine parameter validator once,
+    use it forever"""
+
+    homepage = "https://metacpan.org/pod/Params::ValidationCompiler"
+    url = "https://cpan.metacpan.org/authors/id/D/DR/DROLSKY/Params-ValidationCompiler-0.31.tar.gz"
+
+    version("0.31", sha256="7b6497173f1b6adb29f5d51d8cf9ec36d2f1219412b4b2410e9d77a901e84a6d")

var/spack/repos/builtin/packages/perl-specio/package.py

@@ -0,0 +1,15 @@
+# Copyright 2013-2023 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)
+
+from spack.package import *
+
+
+class PerlSpecio(PerlPackage):
+    """Type constraints and coercions for Perl ."""
+
+    homepage = "https://metacpan.org/dist/Specio"
+    url = "http://search.cpan.org/CPAN/authors/id/D/DR/DROLSKY/Specio-0.48.tar.gz"
+
+    version("0.48", sha256="0c85793580f1274ef08173079131d101f77b22accea7afa8255202f0811682b2")

var/spack/repos/builtin/packages/pflotran/package.py

@@ -57,3 +57,9 @@ def flag_handler(self, name, flags):
         if "%gcc@10:" in self.spec and name == "fflags":
             flags.append("-fallow-argument-mismatch")
         return flags, None, None
+
+    @when("@5.0.0")
+    def patch(self):
+        filter_file(
+            "use iso_[cC]_binding", "use, intrinsic :: iso_c_binding", "src/pflotran/hdf5_aux.F90"
+        )

var/spack/repos/builtin/packages/podio/package.py

@@ -15,11 +15,12 @@ class Podio(CMakePackage):
     url = "https://github.com/AIDASoft/podio/archive/v00-09-02.tar.gz"
     git = "https://github.com/AIDASoft/podio.git"
 
-    maintainers("vvolkl", "drbenmorgan", "jmcarcell")
+    maintainers("vvolkl", "drbenmorgan", "jmcarcell", "tmadlener")
 
     tags = ["hep", "key4hep"]
 
     version("master", branch="master")
+    version("0.17.2", sha256="5b519335c4e1708f71ed85b3cac8ca81e544cc4572a5c37019ce9fc414c5e74d")
     version("0.17.1", sha256="97d6c5f81d50ee42bf7c01f041af2fd333c806f1bbf0a4828ca961a24cea6bb2")
     version("0.17", sha256="0c19f69970a891459cab227ab009514f1c1ce102b70e8c4b7d204eb6a0c643c1")
     version("0.16.7", sha256="8af7c947e2637f508b7af053412bacd9218d41a455d69addd7492f05b7a4338d")

var/spack/repos/builtin/packages/py-geomdl/package.py

@@ -0,0 +1,26 @@
+# Copyright 2013-2023 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)
+
+from spack.package import *
+
+
+class PyGeomdl(PythonPackage):
+    """Object-oriented pure Python B-Spline and NURBS library."""
+
+    homepage = "https://pypi.org/project/geomdl"
+    pypi = "geomdl/geomdl-5.3.1.tar.gz"
+
+    version("5.3.1", sha256="e81a31b4d5f111267b16045ba1d9539235a98b2cff5e4bad18f7ddcd4cb804c8")
+
+    depends_on("py-setuptools@40.6.3:", type="build")
+
+    # For compiling geomdl.core module
+    depends_on("py-cython@:2", type="build")
+
+    variant("viz", default=False, description="Add viz dependencies")
+
+    depends_on("py-numpy@1.15.4:", type="run", when="+viz")
+    depends_on("py-matplotlib@2.2.3:", type="run", when="+viz")
+    depends_on("py-plotly", type="run", when="+viz")

var/spack/repos/builtin/packages/py-libensemble/package.py

@@ -12,13 +12,14 @@ class PyLibensemble(PythonPackage):
     """Library for managing ensemble-like collections of computations."""
 
     homepage = "https://libensemble.readthedocs.io"
-    pypi = "libensemble/libensemble-1.0.0.tar.gz"
+    pypi = "libensemble/libensemble-1.1.0.tar.gz"
     git = "https://github.com/Libensemble/libensemble.git"
     maintainers("shuds13", "jlnav")
 
     tags = ["e4s"]
 
     version("develop", branch="develop")
+    version("1.1.0", sha256="3e3ddc4233272d3651e9d62c7bf420018930a4b9b135ef9ede01d5356235c1c6")
     version("1.0.0", sha256="b164e044f16f15b68fd565684ad8ce876c93aaeb84e5078f4ea2a29684b110ca")
     version("0.10.2", sha256="ef8dfe5d233dcae2636a3d6aa38f3c2ad0f42c65bd38f664e99b3e63b9f86622")
     version("0.10.1", sha256="56ae42ec9a28d3df8f46bdf7d016db9526200e9df2a28d849902e3c44fe5c1ba")

var/spack/repos/builtin/packages/py-lightning/package.py

@@ -15,6 +15,7 @@ class PyLightning(PythonPackage):
 
     maintainers("adamjstewart")
 
+    version("2.1.1", sha256="865491940d20a9754eac7494aa18cab893e0c2b31e83743349eeeaf31dfb52db")
     version("2.1.0", sha256="1f78f5995ae7dcffa1edf34320db136902b73a0d1b304404c48ec8be165b3a93")
     version("2.0.9", sha256="2395ece6e29e12064718ff16b8edec5685df7f7095d4fee78edb0a654f5cd7eb")
     version("2.0.8", sha256="db914e211b5c3b079a821be6e4344e72d0a729163676a65c4e00aae98390ae7b")

var/spack/repos/builtin/packages/py-macs3/package.py

@@ -24,3 +24,5 @@ class PyMacs3(PythonPackage):
     depends_on("py-numpy@1.19:", type=("build", "run"))
     depends_on("py-cykhash@2", type=("build", "run"))
     depends_on("py-hmmlearn@0.3:", type=("build", "run"))
+
+    depends_on("zlib-api")

var/spack/repos/builtin/packages/py-nanobind/package.py

@@ -23,6 +23,9 @@ class PyNanobind(PythonPackage):
     maintainers("chrisrichardson", "garth-wells", "ma595")
 
     version("master", branch="master", submodules=True)
+    version(
+        "1.8.0", tag="v1.8.0", commit="1a309ba444a47e081dc6213d72345a2fbbd20795", submodules=True
+    )
     version(
         "1.7.0", tag="v1.7.0", commit="555ec7595c89c60ce7cf53e803bc226dc4899abb", submodules=True
     )

var/spack/repos/builtin/packages/py-pynucleus/package.py

@@ -19,6 +19,9 @@ class PyPynucleus(PythonPackage):
     for ref in refs:
         version(ref, branch=ref)
 
+    variant("examples", default=True, description="Install examples")
+    variant("tests", default=True, description="Install tests")
+
     depends_on("python@3.10:", type=("build", "run"))
     depends_on("py-mpi4py@2.0.0:", type=("build", "link", "run"))
     depends_on("py-cython@0.29.32:", type=("build", "run"))
@@ -30,14 +33,14 @@ class PyPynucleus(PythonPackage):
     depends_on("py-h5py", type=("build", "run"))
     depends_on("py-tabulate", type=("build", "run"))
     depends_on("py-pyyaml", type=("build", "run"))
-    depends_on("py-matplotlib+latex", type=("build", "run"))
+    depends_on("py-matplotlib", type=("build", "run"))
     depends_on("py-scikit-sparse", type=("build", "run"))
     depends_on("py-modepy", type=("build", "run"))
     depends_on("py-meshpy", type=("build", "run"))
     depends_on("py-pytools", type=("build", "run"))
     depends_on("py-psutil", type="run")
-
-    variant("examples", default=True, description="Install examples")
+    depends_on("py-pytest", when="+tests", type="run")
+    depends_on("py-pytest-html", when="+tests", type="run")
 
     import_modules = [
         "PyNucleus",
@@ -64,5 +67,9 @@ def install_python(self):
     def install_additional_files(self):
         spec = self.spec
         prefix = self.prefix
-        if "+examples" in spec:
+        if "+examples" in spec or "+tests" in spec:
             install_tree("drivers", prefix.drivers)
+        if "+examples" in spec:
+            install_tree("examples", prefix.examples)
+        if "+tests" in spec:
+            install_tree("tests", prefix.tests)

var/spack/repos/builtin/packages/py-torch/package.py

@@ -491,9 +491,8 @@ def enable_or_disable(variant, keyword="USE", var=None, newer=False):
 
         enable_or_disable("cuda")
         if "+cuda" in self.spec:
-            # cmake/public/cuda.cmake
-            # cmake/Modules_CUDA_fix/upstream/FindCUDA.cmake
-            env.unset("CUDA_ROOT")
+            env.set("CUDA_HOME", self.spec["cuda"].prefix)  # Linux/macOS
+            env.set("CUDA_PATH", self.spec["cuda"].prefix)  # Windows
             torch_cuda_arch = ";".join(
                 "{0:.1f}".format(float(i) / 10.0) for i in self.spec.variants["cuda_arch"].value
             )

var/spack/repos/builtin/packages/py-torchgeo/package.py

@@ -16,6 +16,7 @@ class PyTorchgeo(PythonPackage):
     maintainers("adamjstewart", "calebrob6")
 
     version("main", branch="main")
+    version("0.5.1", sha256="5f86a34d18fe36eeb9146b057b21e5356252ef8ab6a9db33feebb120a01feff8")
     version("0.5.0", sha256="2bc2f9c4a19a569790cb3396499fdec17496632b0e52b86be390a2cc7a1a7033")
     version("0.4.1", sha256="a3692436bf63df8d2f9b76d16eea5ee309dd1bd74e0fde6e64456abfdb2a5b58")
     version("0.4.0", sha256="a0812487205aa2db7bc92119d896ae4bf4f1014e6fdc0ce0f75bcb24fada6613")

var/spack/repos/builtin/packages/raja/package.py

@@ -162,6 +162,11 @@ def _get_sys_type(self, spec):
             sys_type = env["SYS_TYPE"]
         return sys_type
 
+    @property
+    def libs(self):
+        shared = "+shared" in self.spec
+        return find_libraries("libRAJA", root=self.prefix, shared=shared, recursive=True)
+
     @property
     def cache_name(self):
         hostname = socket.gethostname()

var/spack/repos/builtin/packages/scafacos/package.py

@@ -0,0 +1,40 @@
+# Copyright 2013-2023 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)
+
+from spack.package import *
+
+
+class Scafacos(AutotoolsPackage):
+    """ScaFaCoS is a library of scalable fast coulomb solvers."""
+
+    homepage = "http://www.scafacos.de/"
+    url = "https://github.com/scafacos/scafacos/releases/download/v1.0.4/scafacos-1.0.4.tar.gz"
+
+    maintainers("hmenke")
+
+    license("GPL-3.0-or-later OR LGPL-3.0-or-later")
+
+    version("1.0.4", sha256="6634c4202e825e771d1dd75bbe9cac5cee41136c87653fde98fbd634681c1be6")
+    version("1.0.3", sha256="d3579f4cddb10a562722c190c2452ebc455592d44f6dbde8f155849ba6e2b3d0")
+    version("1.0.2", sha256="158078665e48e28fd12b7895063db056cee5d135423fc36802e39c9160102b97")
+    version("1.0.1", sha256="2b125f313795c81b0e87eb920082e91addf94c17444f9486d979e691aaded99b")
+    version("1.0.0", sha256="cc5762edbecfec0323126b6a6a535dcc3e134fcfef4b00f63eb05fae15244a96")
+
+    depends_on("fftw")
+    depends_on("file")
+    depends_on("gmp")
+    depends_on("gsl")
+    depends_on("mpi")
+    depends_on("pfft")
+    depends_on("pnfft")
+
+    def configure_args(self):
+        args = [
+            "--disable-doc",
+            "--enable-fcs-solvers=direct,ewald,fmm,p3m",
+            "FC={0}".format(self.spec["mpi"].mpifc),
+            "F77={0}".format(self.spec["mpi"].mpif77),
+        ]
+        return args

var/spack/repos/builtin/packages/sleef/package.py

@@ -53,10 +53,9 @@ class Sleef(CMakePackage):
     # conflicts("^mpfr@4.2:")
 
     def cmake_args(self):
-        # Taken from PyTorch's aten/src/ATen/CMakeLists.txt
+        # https://salsa.debian.org/science-team/sleef/-/blob/master/debian/rules
         return [
-            self.define("BUILD_SHARED_LIBS", False),
             self.define("BUILD_DFT", False),
-            self.define("BUILD_GNUABI_LIBS", False),
+            self.define("SLEEF_TEST_ALL_IUT", True),
             self.define("BUILD_TESTS", False),
         ]

var/spack/repos/builtin/packages/sundials/package.py

@@ -27,6 +27,7 @@ class Sundials(CMakePackage, CudaPackage, ROCmPackage):
     # Versions
     # ==========================================================================
     version("develop", branch="develop")
+    version("6.6.2", sha256="08f8223a5561327e44c072e46faa7f665c0c0bc8cd7e45d23f486c3d24c65009")
     version("6.6.1", sha256="21f71e4aef95b18f954c8bbdc90b62877443950533d595c68051ab768b76984b")
     version("6.6.0", sha256="f90029b8da846c8faff5530fd1fa4847079188d040554f55c1d5d1e04743d29d")
     version("6.5.1", sha256="4252303805171e4dbdd19a01e52c1dcfe0dafc599c3cfedb0a5c2ffb045a8a75")

var/spack/repos/builtin/packages/superlu-dist/package.py

@@ -53,14 +53,16 @@ class SuperluDist(CMakePackage, CudaPackage, ROCmPackage):
         ),
     )
     variant("shared", default=True, description="Build shared libraries")
+    variant("parmetis", default=True, description="Enable ParMETIS library")
 
     depends_on("mpi")
     depends_on("blas")
     depends_on("lapack")
-    depends_on("parmetis +int64", when="+int64")
-    depends_on("metis@5: +int64", when="+int64")
-    depends_on("parmetis ~int64", when="~int64")
-    depends_on("metis@5: ~int64", when="~int64")
+    with when("+parmetis"):
+        depends_on("metis@5: +int64", when="+int64")
+        depends_on("parmetis +int64", when="+int64")
+        depends_on("metis@5: ~int64", when="~int64")
+        depends_on("parmetis ~int64", when="~int64")
     depends_on("cmake@3.18.1:", type="build", when="@7.1.0:")
     depends_on("hipblas", when="+rocm")
     depends_on("rocsolver", when="+rocm")
@@ -93,13 +95,17 @@ def append_from_variant(*args):
         append_define("TPL_LAPACK_LIBRARIES", spec["lapack"].libs)
         append_define("TPL_ENABLE_LAPACKLIB", True)
         append_define("USE_XSDK_DEFAULTS", True)
-        append_define(
-            "TPL_PARMETIS_LIBRARIES", [spec["parmetis"].libs.ld_flags, spec["metis"].libs.ld_flags]
-        )
-        append_define(
-            "TPL_PARMETIS_INCLUDE_DIRS",
-            [spec["parmetis"].prefix.include, spec["metis"].prefix.include],
-        )
+
+        append_from_variant("TPL_ENABLE_PARMETISLIB", "parmetis")
+        if "+parmetis" in spec:
+            append_define(
+                "TPL_PARMETIS_LIBRARIES",
+                [spec["parmetis"].libs.ld_flags, spec["metis"].libs.ld_flags],
+            )
+            append_define(
+                "TPL_PARMETIS_INCLUDE_DIRS",
+                [spec["parmetis"].prefix.include, spec["metis"].prefix.include],
+            )
 
         append_define("XSDK_INDEX_SIZE", "64" if "+int64" in spec else "32")
 

var/spack/repos/tutorial/packages/libpspio/package.py

@@ -0,0 +1,37 @@
+# Copyright 2013-2023 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)
+
+from spack.package import *
+
+
+class Libpspio(AutotoolsPackage):
+    """Library to perform I/O operations on pseudopotential data files."""
+
+    homepage = "https://gitlab.com/ElectronicStructureLibrary/libpspio"
+    url = "https://gitlab.com/ElectronicStructureLibrary/libpspio/-/archive/0.3.0/libpspio-0.3.0.tar.gz"
+
+    maintainers("hmenke")
+
+    license("MPL-2.0")
+
+    version("0.3.0", sha256="4dc092457e481e5cd703eeecd87e6f17749941fe274043550c8a2557a649afc5")
+
+    variant("fortran", default=False, description="Enable Fortran bindings")
+
+    depends_on("autoconf", type="build")
+    depends_on("automake", type="build")
+    depends_on("libtool", type="build")
+    depends_on("m4", type="build")
+    depends_on("pkgconfig", type="build")
+
+    depends_on("check")
+    depends_on("gsl")
+
+    def autoreconf(self, spec, prefix):
+        Executable("./autogen.sh")()
+
+    def configure_args(self):
+        args = self.enable_or_disable("fortran")
+        return args