HPSF Conference 2025

Einstein’s theory of General Relativity revolutionised Physics over a century ago. Despite this, the number of known analytical solutions to the equations, particularly in the dynamical strong-field case is very small. Numerical relativity is often the only tool that can be used to investigate this regime.

Charliecloud is a lightweight, fully unprivileged, open source container implementation for HPC applications. It can handle the entire container workflow, including building images, pushing/pulling to registries, and dealing with accelerators like GPUs. We take a unique approach to containerization while remaining compatible with the broader container ecosystem where it matters.

Notable distinctions include: fully unprivileged end-to-end workflow, small code base with minimal dependencies, delegation of all security boundaries, layer-free build cache, zero-consistency root emulation based on seccomp, and a spirit of openness and public service.

This talk will motivate containers for HPC applications, then explain Charliecloud’s design philosophy and how we address these needs. We’ll discuss Charliecloud’s “weirdness” when compared to other implementations (i.e., its design philosophy and key distinctions), provide a brief overview of the code’s structure, and summarize recent and upcoming changes of interest.

LA-UR-25-22140

1. Welcome and overview, Damien Lebrun-Grandie, Oak Ridge National Laboratory (10 minutes)

2. Update on the Ecosystem and Community, Christian Trott, Sandia National Laboratories (20 minutes)

3. Kokkos Core update, Damien Lebrun-Grandie, Oak Ridge National Laboratory (30 minutes)

4. Kokkos-Kernels update, Luc Berger-Vergiat, Sandia National Laboratories (20 minutes)

I will describe Quokka, a new AMR code for astrophysics, aimed at problems in star formation and galaxy formation. Quokka is a Newtonian radiation hydrodynamics code with support for particles, chemistry, self-gravity, and (soon) magnetic fields based on a method-of-lines formulation. We use AMReX's unique capabilities to enable many of these physics features, from AMReX's OpenBC Poisson solver for self-gravity, to AMReX-Astro Microphysics for the cell-by-cell chemistry network integration with symbolic code generation. I will talk about our current code development focused on particles and a constrained-transport implementation of magnetohydrodynamics, and briefly mention applications in simulating galactic winds and the formation of the first stars.

GlideinWMS is a pilot and pressure-based workload manager for distributed scientific computing. Many experiments like CMS and Fermilab’s Neutrino experiments use it to provision elastic clusters for their analysis and simulations, split in close to a million concurrent jobs. The majority of the user jobs require containers and the pilots use Apptainer to setup the desired platform. For the pilots, that run as regular batch jobs, Apptainer is safer, lighter and easier to use than other containerization solutions. Many images used by the pilots are expanded SIF images distributed via the CernVMFS: this combination is very efficient.

This workshop will provide participants with background and hands-on experience to use basic Charliecloud containers for HPC applications. Participants will build toy containers and a real HPC application, and then run them in parallel on a supercomputer. This will be a highly interactive workshop with lots of Q&A.

This section will walk through the key workflow operation pull.

LA-UR-25-22140

In this talk I discuss the role of the SUNDIALS (SUite of Nonlinear and DIfferential/ALgebraic equation Solvers) package in three different AMReX-based applications. In this context, SUNDIALS provides support for the overall temporal integration scheme of the model equations. We are particularly interested in the multirate infinitesimal (MRI) schemes, where different physical processes can be advanced using different time steps. Our initial application is in the context of combustion, where we show that we are able to achieve increased accuracy over our traditional spectral deferred corrections approach with greater computational efficiency. Our second application is in micromagnetic memory and storage devices where we demonstrate efficiency by leveraging the non-stiff nature of the computationally-expensive demagnetization processes. Our final application is low-power ferroelectric transistors where we also effectively leverage the non-stiff nature of the computationally-expensive Poisson process. In each case we show significant computational savings over our baseline codes.

This workshop will provide participants with background and hands-on experience to use basic Charliecloud containers for HPC applications. Participants will build toy containers and a real HPC application, and then run them in parallel on a supercomputer. This will be a highly interactive workshop with lots of Q&A.

This section will explain that containers are not special by running an Alpine container via tarball.

LA-UR-25-22140

The adaptive mesh and particle capabilities of AMReX have been used to implement a wide range of numerical methods, targeting combustion, plasma physics, earth systems modeling, cosmology, and more. This talk will show how they can also be used to implement a quite different type of algorithm: an agent-based model (ABM) for the spread of respiratory diseases called ExaEpi. ABMs are valuable because they provide a fundamental and natural description of the system and are able to capture emergent phenomena. However, their use in forecasting and control is limited by the difficulty in calibrating and quantifying the uncertainty associated with a large number of parameters. By leveraging AMReX, ExaEpi can help address these limitations by enabling many large ensembles to run quickly on exascale compute facilities. 

Managing software on supercomputers is challenging due to diverse architectures, dependency complexities, and security constraints. Traditional tools like Spack help with software compilation, but they lack portability and require system-specific configurations. Apptainer (formerly Singularity) solves these issues by enabling secure, portable, and reproducible containerized environments tailored for HPC. Unlike Docker, Apptainer runs without root access, ensuring security and compliance in multi-user clusters. It supports MPI, GPUs, and Slurm, allowing high-performance workloads to run seamlessly across systems. By integrating Apptainer into NSM supercomputers, researchers benefit from faster deployments, reproducible results, and reduced administrative overhead. This session explores Apptainer’s role in transforming HPC workflows, its advantages over traditional software management, and best practices for adopting containers in large-scale computing environments.

This workshop will provide participants with background and hands-on experience to use basic Charliecloud containers for HPC applications. Participants will build toy containers and a real HPC application, and then run them in parallel on a supercomputer. This will be a highly interactive workshop with lots of Q&A.

This section will walk through the key workflow operation, building from a Dockerfile.

LA-UR-25-22140

Spack 1.0 will feature faster builds through multi-package parallelism. In this talk, I’ll describe how I accelerated Spack’s package installation process by parallelizing its main installer loop. By enabling Spack to spawn multiple package builds concurrently, this feature increases available parallelism and significantly reduces overall build times for multi-package installations. I'll talk about the design decisions, tradeoffs, and performance gains achieved, providing valuable lessons for optimizing package builds on platforms from laptops to large-scale HPC environments. I’ll also talk about how, even as a a relatively new Spack user, I was able to come up to speed quickly and contribute meaningful improvements to the project.

1. FleCSI Applications, Ben Bergen & Hyun Lim, Los Alamos National Laboratory (10 minutes)
The Flexible Computational Science Infrastructure (FleCSI) programming system provides a clutter-free environment that allows developers to focus on the arithmetic operations of their methods without the distraction of computer science details that are often visible in legacy simulation codes. To this end, FleSCI provides light-weight wrappers over the raw Kokkos interface that resemble native C++ keywords, e.g., forall. Using this design philosophy, we have been able to evolve our support to cover various Kokkos policies and execution spaces. HARD is a FleCSI-based application for radiation hydrodynamics that is performance portable across a variety of systems, e.g., El Capitan, Venado, and Crossroads, and inherits FleCSI’s support for multiple distributed-memory and tasking backends, e.g., Legion, HPX, and MPI. In this talk, we will demonstrate the basic data-parallel interface with implementation and usage examples. We will also present results for several test problems in inertial confinement fusion with comparisons between different backends and performance assessments in different heterogeneous computing environments.

2. DDC: A Performance Portable Library Abstracting Computation on Discrete Domains, Thomas Padioleau, CEA Paris-Saclay (10 minutes)
The Discrete Domain Computation (DDC) library is a modern C++ library that aims to offer to the C++ world an equivalent to the xarray.DataArray Python environment. The Xarray library introduces labeled multidimensional arrays, enabling more intuitive data manipulation by associating dimensions with user-provided names rather than relying on positional indexing. This approach simplifies indexing, slicing, and broadcasting while reducing common indexing errors. Inspired by these ideas, DDC extends the Kokkos library providing zero-overhead dimension labeling for multidimensional arrays along with performance-portable multidimensional algorithms. This labeling mechanism enables compile-time detection of indexing and slicing errors, ensuring safer and more expressive array operations in C++. In this presentation, we will introduce the core concepts of DDC and demonstrate its usage through a simple example that highlights its key features.

3. TChem-atm - A Performance Portable Chemistry Solver for Atmospheric Chemistry, Oscar Diaz-Ibarra, Sandia National Laboratories (20 minutes)
TChem-atm (https://github.com/PCLAeroParams/TChem-atm) is a performance-portable software library designed to support atmospheric chemistry applications, specifically computing source term Jacobian matrices. The software utilizes Kokkos as its portability layer, preparing it for next-generation computing architectures. The software interface employs a hierarchical parallelism design to leverage the massive parallelism available on modern computing platforms, including model parallelism, batch parallelism, and nested parallelism for each problem instance. Additionally, TChem-atm is designed to be coupled with third-party libraries that may be used to advance the state of gas and particle species over time, notably interfacing with the Tines, Kokkos-kernels, and Sundials libraries. We have tested TChem-atm in two scenarios: using a typical reaction mechanism in atmospheric science and an example involving multiple aerosol particles. This testing framework allows us to evaluate our code by varying the number of evaluations and the size of the source term (right-hand side). Finally, we report performance measurements using the CUDA, HIP, and OpenMP back ends.

4. GPU Porting of the TRUST CFD Platform with Kokkos, Rémi Bourgeois, French Atomic Energy Commission (CEA) (20 minutes)
TRUST is a High Performance Computing thermohydraulic platform for Computational Fluid Dynamics developed at the French Atomic Energy Commission (CEA). This software is designed for massively parallel (MPI) simulations of conduction, incompressible single-phase, and Low Mach Number (LMN) flows with a Weakly-Compressible multi-species solver and compressible multi-phase flows. It is used as the basis for many specialised applications in the nuclear and new energy fields across CEA. The code is being progressively ported to support GPU acceleration (Nvidia/AMD/Intel) thanks to the Kokkos library, as it is one of the demonstrators of the CExA project. In this talk we will go over our experience using Kokkos to progressively port our large code base. We will cover our enabled GPU features and performances. We will mention some of the difficulties we encountered as well as the strategies we had to adopt that sometimes differ from standard good practices due to the specificity of our application.

5. Omega: Towards a Performance-portable Ocean Model using Kokkos, Maciej Waruszewski, Sandia National Laboratories (20 minutes)
High-resolution simulations of the Earth system require resources available only on the world's largest supercomputers, which are increasingly based on GPUs. However, CPU-based systems are still frequently used to conduct simulations at coarse resolutions. To be able to take advantage of all compute platforms, we are developing Omega: the Ocean Model for E3SM Global Applications, a new ocean model written in C++ using Kokkos for performance portability. Omega will replace MPAS-Ocean to become the new ocean component of the DOE’s Energy Exascale Earth System Model (E3SM). Omega is an unstructured mesh ocean model based on the same finite-volume scheme as the current ocean component. Work on Omega began in 2023. Currently, Omega is a layered shallow water model with passive tracers. While still simple, this initial version can run on realistic size meshes and contains computational kernels representative of the full model horizontal numerics. After briefly describing Omega, this talk will go into our experiences with Kokkos and present initial performance results from a variety of compute platforms.)

The WarpX project is advancing the modeling and simulation of a wide range of physics applications, including particle accelerators and nuclear fusion, through high-performance scientific computing. This talk will provide a comprehensive update on WarpX, focusing on our experiences with the AMReX software framework. We will highlight key achievements, share valuable lessons learned, and discuss the future challenges we anticipate. The presentation will cover the critical role of AMReX in enabling high performance and portability, showcase significant milestones, and provide insights into the challenges faced and solutions developed.

This session delves into the advanced utilization of Apptainer (formerly Singularity) for distributed computing in high-performance computing (HPC) environments. It will cover containerized execution methodologies, security enhancements, and scalability optimizations critical for scientific computing. The discussion will emphasize MPI integration, multi-node orchestration, and performance considerations for HPC workloads within Apptainer containers. Researchers and scientists will gain a comprehensive understanding of deploying, managing, and optimizing containerized scientific applications across distributed HPC infrastructures.

This workshop will provide participants with background and hands-on experience to use basic Charliecloud containers for HPC applications. Participants will build toy containers and a real HPC application, and then run them in parallel on a supercomputer. This will be a highly interactive workshop with lots of Q&A.

This section will walk through the key workflow operation push.

LA-UR-25-22140

Binary package managers allow for the fast installation of binary artifacts, but limit configurability to ensure compatibility between binaries due to rigid ABI requirements. Source package managers allow for more flexibility in building software, since binaries are compiled on demand, but compilation can take a considerable amount of time. Spack has existing a mechanism for mixing source and precompiled packages; however, because Spack does not model ABI compatibility between packages, all transitive dependencies of a binary package must have been built at the same time as that package in order to maintain ABI compatiblity. We present an extension to Spack, which we call splicing, that models ABI compatibility in the package ecosystem and allows seamless mixing of source and binary distribution of packages. This extension augments both the packaging language and dependency resolution engine of Spack in order to maximize reused binaries while maintaining the flexibility of source based management. Through empirical evaluation, we show that our extension incurs minimal performance overhead to dependency resolution while greatly extending the modeling capability of Spack.

The lead developer of Apptainer will discuss recent changes to Apptainer.

This workshop will provide participants with background and hands-on experience to use basic Charliecloud containers for HPC applications. Participants will build toy containers and a real HPC application, and then run them in parallel on a supercomputer. This will be a highly interactive workshop with lots of Q&A.

This section will include a multi-node MPI hello world example.

LA-UR-25-22140

While primarily run, tested, and developed on Unix-like operating systems, in particular HPC systems, scientific software is often deployed on Windows. Spack's recent expansion to Windows marks a significant milestone, enabling its powerful package management capabilities on a new platform.This talk will provide technical insight into the process of adapting Spack to support a platform orthogonal in design to anything Spack has supported in the past. We cover the path to initial support, the current state of Spack on Windows, and look at the roadmap for future Windows development. We’ll explore unique challenges supporting Windows and their solutions. This talk will address design, new features introduced to support Windows development, and how Spack brings needed robust package management to the Windows ecosystem. We’ll cover best practices for porting new or existing packages to Windows, deploying and managing Spack environments in real-world scenarios, and standardizing your Windows development workflows with a focus on common pitfalls for Windows developers. This talk will provide a pathway for attendees interested in supporting Windows to go forth and Spack!

The phase field (PF) method is used to simulate a wide range of problems in mechanics, ranging from crack propagation to topology optimization. As a diffuse interface method, PF requires AMR to be computationally feasible, but few PF methods leverage block-structured AMR. Alamo is an AMReX-based code designed to solve phase field equations with implicit elastic solves. It features a variety of phase field methods, material models, and a strong-form nonlinear elastic solver based on AMReX's MLMG. In this talk, we give a high-level overview of some of the applications of Alamo, including deflagration of solid rocket propellant, topology optimization of mechanical structures, phase field fracture, microstructure evolution, and solid-fluid interaction.

This workshop will provide participants with background and hands-on experience to use basic Charliecloud containers for HPC applications. Participants will build toy containers and a real HPC application, and then run them in parallel on a supercomputer. This will be a highly interactive workshop with lots of Q&A.

This section will wrap-up the workshop with final Q&A.

LA-UR-25-22140

Spack's Continuous Integration (CI) system is essential for building and distributing reliable HPC software packages. It has dramatically scaled from building hundreds to hundreds of thousands of packages weekly. Leveraging GitLab, Spack CI has evolved from a Linux-only build system to orchestrating runners across diverse providers, architectures, and platforms, supporting multiple domain stacks like E4S, HEP, and Radiuss. Through enhanced monitoring and data-driven methodologies, including machine learning, Spack CI has gained insights to optimizing resource allocation and analyzing failure modes. Improvements to binary caching reduce storage and prevent race conditions. The core goal is to maintain a resilient and efficient CI ecosystem, ensuring the reliability of Spack's HPC software for its expanding community.

The past decade has seen a rapid increase in the development and use of Python-based open-source libraries for data-driven methods and machine learning. The widespread adoption of these libraries across scientific and engineering disciplines highlights their growing prominence in accelerating simulations. This talk presents an in-situ (in-memory/online) workflow, which requires minimal modifications, designed for mature AMReX codes to leverage the rich Python-ecosystem. The workflow enables language-interoperable data transfer through runtime coupling of AMReX and pyAMReX via Multiple Program Multiple Data (MPMD) mode of Message Passing Interface (MPI). This capability is demonstrated through multiscale modeling of granular flows, which involves coupling low-fidelity continuum and high-fidelity particle-based methods. The computational intractability of straightforward coupling between low- and high-fidelity methods is addressed using adaptively (on-the-fly) evolving neural network ensembles, implemented in PyTorch Distributed Data Parallel, as a surrogate for the expensive high-fidelity solver. The scalability of the current approach across multiple GPUs will also be discussed.

Container images are built by interpreting instructions in a machine-readable recipe, typically a Dockerfile, which is often faster with a build cache that stores instruction results for re-use. The standard approach (used e.g. by Docker and Podman) is a many-layered union filesystem, encoding differences between layers as tar archives.

This talk describes a new approach, as implemented in Charliecloud: store changing images in a Git repository. Our experiments show this performs similarly to layered caches on both build time and disk usage, with a considerable advantage for many-instruction recipes. Our approach also has structural advantages: better diff format, lower cache overhead, and better file de-duplication. These results show that a Git-based cache for layer-free container implementations is not only possible but may outperform the layered approach on important dimensions.

LA-UR-25-22140

This talk will describe how the Extreme-Scale Scientific Software Stack is developed and maintained. E4S is an Ecosystem for Science and is layered upon the Spack package manager. This talk will focus on the maintenance of E4S and the continuous integration (CI) on the Frank system at the University of Oregon.

In this presentation, we will offer a concise introduction and overview of the Trilinos project. Established in 2001, Trilinos is a collaborative initiative focused on developing algorithms and technologies to address complex multi-physics engineering and scientific challenges on high-performance computing (HPC) architectures. This includes a range of capabilities such as linear and nonlinear solvers, optimization techniques, and sensitivity analysis. A key mission of Trilinos is to cultivate a vibrant community of developers and users who contribute to a modular software framework comprised of diverse computational packages. This collaborative environment facilitates resource sharing among library developers, enhancing software compatibility and overall efficiency amortization of costs.

1. A Brief Overview of LANL's use of Kokkos - Daniel Holladay, Los Alamos National Laboratory (20 minutes)
Since the commissioning of the first petascale machine, Roadrunner, in 2009 at the Los Alamos
National Laboratory (LANL), the ability for physics codes at LANL to take advantage of accelerators
has provided utility and productivity improvements for code users. The ability to take advantage of an
accelerator, and more specifically general purpose graphics processing units (GPGPUs), will quickly
move from a productivity enhancement to absolutely necessary as more than 90% of the compute
capability of the El Capitan supercomputer at Lawrence Livermore National Laboratory (LLNL) will
only be accessed through effective use of its GPGPUs, a task which has traditionally been
accomplished with vendor specific software extensions such as CUDA or HIP. Many projects with
code bases ranging from large and established FORTRAN codes to new c++ based projects have
made the decision to use Kokkos as the tool that will enable effective use of LLNL's El Capitan
compute resources as well as future machines which could likely benefit from Kokkos's capabilities.
In this talk I will give an overview of several physics code projects at LANL and their usage of Kokkos.

2. Enhancing Fortran Code for Operational Weather Forecasting with Kokkos: Results and Lessons Learned - Timothy Sliwinski, Cooperative Institute for Research in the Atmosphere (CIRA) (20 minutes)
At NOAA, much of the code for numerical weather prediction (NWP) and operational weather forecasting is built upon Fortran, into which decades of scientific research knowledge and expertise has been invested. Therefore, moving away from Fortran and potentially breaking what has been a highly reliable system for many years is a significant challenge.
To demonstrate new methods to modernize NOAA’s NWP models, Kokkos was selected due to its ability to work across multiple GPUs and CPUs with a single source code and the presence of the Fortran Language Compatibility Layer (FLCL), easing development of the interface between Fortran and C++ Kokkos kernels. As a first step, the YSU Planetary Boundary Layer (PBL) scheme was chosen as the target and a prototype with Kokkos was developed, tested, and performance benchmarked. In this presentation, we report the performance of this new Kokkos-enhanced Fortran code on CPU and an Nvidia GPU, the challenges of the C/Fortran interface, potential future prospects for the use of Kokkos at NOAA, and overall lessons learned from this project for anyone else interested in using Kokkos with existing Fortran source codes.

3. Using Umpire's Memory Management Capabilities with Kokkos - Kristi Belcher, LLNL (20 minutes)
Umpire is an open-source data and memory management library created at Lawrence Livermore National Laboratory (LLNL). Although Umpire is part of the RAJA Portability Suite, it was made to be modular and can therefore be used with Kokkos and other performance portability abstractions. Umpire provides memory pools which avoid expensive calls to the underlying device-specific API making allocations, large or small, performant in HPC environments. Umpire provides numerous types of memory resources and allocators (i.e. Device, Host, Unified Memory, IPC Shared Memory, etc.). In this talk, I will discuss key Umpire features and capabilities and showcase a Kokkos example with Umpire.

4. Early Experiences Using Kokkos for Multi-Resolution Analysis - Joseph Schuchart, Stony Brook University (20 minutes)
MADNESS is a framework for multi-resolution analysis with application in quantum chemistry. In this talk, we will present some early experiences in using Kokkos in a port of MADNESS to the TTG data-flow programming model, which includes both a restructuring of the existing program flow and a port to accelerators.

To comprehensively investigate multiphysics coupling in spintronic devices, GPU acceleration is essential to address the spatial and temporal disparities inherent in micromagnetic simulations. Beyond traditional numerical methods, machine learning (ML) offers a powerful approach to replace and accelerate computationally expensive routines, particularly in evaluating demagnetization fields. Leveraging AMReX and python-based ML workflows, we developed an open-source micromagnetics tool that integrates ML-driven surrogate models to enhance computational efficiency. By replacing costly demagnetization field calculations with neural network-based approximations, the framework significantly accelerates simulations while maintaining accuracy. In addition to supporting key magnetic interactions—including Zeeman, demagnetization, anisotropy, exchange, and Dzyaloshinskii-Moriya interactions—it is validated on µMAG standard problems, widely accepted DMI benchmarks, and Skyrmion-based applications. This ML-accelerated approach improves computational performance and enables large-scale, data-driven micromagnetics simulations, advancing the study of spintronic and electronic systems.

The Singularity Image Format (SIF) is a compressed read-only SquashFS filesystem that includes everything needed to run a containerized application. Leveraging its SquashFS-based architecture, Charliecloud has integrated support for the reading and execution of this image format. This talk will provide details about how the ch-run functionality identifies SIF files, analyzes the file header structure, and retrieves the SquashFS partition offset needed for container image execution.

Additionally, the talk is designed for anyone looking to gain a clearer understanding of SIF, especially if you find the upstream documentation challenging to navigate.

LA-UR-25-22166

Numerical weather prediction (NWP) systems are complex, coupled models with several distinct components. They are often developed by different organizations: national agencies, research institutes, universities, and the community. Naturally, they require extensive third-party libraries and run on a wide range of computational platforms, from the largest high-performance computing systems (HPCs) to low-spec GitHub action runners.

To address this challenge of ever-increasing complexity, in 2021 the Joint Center for Satellite Data Assimilation (JCSDA) and NOAA’s Environmental Modeling Center (EMC) created spack-stack, a novel, collaborative effort geared towards universal and portable NWP software environments based on the spack package manager for supercomputers developed at LLNL. The spack-stack collaboration has grown since its inception, and as of 2025 includes the United States Naval Research Lab (NRL) and NOAA’s Earth System Prediction Center (EPIC). The spack-stack software environments are also increasingly used at NASA’s Global Modeling and Assimilation Office (GMAO), making it a core component of some of the Nation’s flagship NWP systems.

The Trilinos core area includes packages that form the basic building blocks for Trilinos capabilities. This talk
will briefly introduce each package and demonstrate how these can be pulled together into an application. We will
cover the following packages. The Kokkos performance portability library provides data structures and parallel
algorithms that are performant on both CPU and GPU architectures. The Kokkos-Kernels library provides
performance portable BLAS and LAPACK routines. The Tpetra library provides MPI-based parallel distributed linear
algebra data structures built on Kokkos. The Teuchos library provides utilities for a common look and feel
across Trilinos packages, including a reference counted smart pointer, print utilities, timers and a parameter list
for user input. The Zoltan library provides parallel distributed load balancing tools. The PyTrilinos package
provides python wrappers for Trilinos capabilities. The Thyra package provides abstraction layers for writing
linear algebra, linear solvers and nonlinear solvers. The talk will conclude with examples of Trilinos capabilities
integrated into the Empire electromagnetic particle-in-cell code.

We introduce a hybrid HPC–ML framework for efficient modeling of magnon–photon interactions. The HPC component uses an explicit FDTD leap-frog Maxwell–LLG solver (second-order accurate), solving Maxwell’s equations in nonmagnetic regions and adding the LLG equation where ferromagnets are present. Parallelization leverages AMReX’s MPI+X model for multicore CPUs or GPUs, partitioning the domain among MPI ranks. Data collected from nine points in the ferromagnet feed a Long Expressive Memory (LEM) encoder–decoder, trained with a composite loss function (reconstruction, prediction, and physics) and guided by Curriculum Learning. During training, we begin with shorter sequences, no physics enforcement, and a higher learning rate, then move to longer sequences, physics constraints, and a lower rate. Using just 1 ns of high-fidelity simulation data, the ML surrogate accurately predicts the magnetic-field evolution and matches frequency responses (13–18 GHz) under various DC biases. With physics constraints included, errors remain low even for longer sequences. The model reproduces transmission spectra and captures both primary and dual resonances (1800–2200 Oe) with high precision, achieving errors below 2.5% and demonstrating robust spatial and spectral generalization.

The typical filesystem image formats for Charliecloud are SquashFS and tar archives. SquashFS is a compressed, read-only filesystem that unprivileged users can mount in user space with SquashFUSE; it is the preferred image format due to its various efficiencies. The previous SquashFS workflow was non-ideal due to user complexity and difficulties with HPC job schedulers.

We have designed a workflow that requires us to link SquashFUSE to Charliecloud to enable the new mount/unmount procedure of only needing a single user command. Also, an additional persistent process is needed to service the FUSE requests called the FUSE loop: once the containerized application process finishes, it unmounts the SquashFS and ends the FUSE loop. Our SquashFS workflow is currently in production with it being more user friendly, cleans up after itself and is more compatible with HPC job schedulers. We were able to reduce user commands from 3 to 1, increase reliability and decrease mount/unmount time by more than 50%.

LA-UR-25-22140

High Energy Physics (HEP) and Nuclear Physics (NP) experiments at accelerators facilities use modular software stacks which evolve over the decades-long lifetimes of these efforts. These software stacks have complex dependency trees, often reaching depths of O(50) levels and containing O(1000) nodes, with detailed versioning constraints. Reproducibility requirements demand that previous versions and their dependencies can be recalled on newer hardware architectures. The software stacks are deployed on computing centers around the world, as part of computing grids for high throughput computing and (increasingly) high performance computing. Current tools for managing these stacks have been around for years, but do not always have support for newer computing practices (containerization, integration in development workflows, heterogeneous architectures, deployment to shared file systems such as CernVM-FS). In this session, I will give an overview of the packaging solutions used in HEP and NP, and compare them with Spack in terms of functionality, adaptability, and usability.

Trilinos provides a variety of high-performance sparse iterative and direct linear solvers that are portable across CPU and GPU architectures. In this talk, I will provide motivation for why scientists and engineers developing a high-performance application should consider using Trilinos solvers. I'll give an overview of current solver capabilities across a spectrum of science applications, and discuss ongoing research as well as future directions.

Do Linux distribution package managers need the privileged operations they request to actually happen? Apparently not, at least when building container images for HPC applications. Charliecloud uses this observation to implement a root emulation mode using a Linux seccomp filter that intercepts some privileged system calls, does nothing, and returns success to the calling program. This approach provides no consistency whatsoever but is sufficient to build a wide selection of Dockerfiles, including some that Docker itself cannot build, simplifying fully-unprivileged workflows needed for HPC application containers. This talk will detail the approach along its advantages and disadvantages. 

LA-UR-25-22140

The Computational Science and AI Directorate at Fermilab is using Spack to support the development efforts of a large number of scientific programmers, in many independent projects and experiments. While independent, these projects share many dependencies. They are typically under continuous and fairly rapid development. They have to support deployment on diverse hardware. This is a different context than is typical for the management of HPC software, where Spack was born. To support our community, we have created a model that enables users to develop code with greater efficiency than is possible with Spack’s current development facilities.

In this talk we will present:
- a brief introduction to the science we support (particle physics)
how the code we work with is naturally organized into several layers of packages
- how we are using Spack to manage those layers
- how we leverage the layering to provide efficient support for developers, using our Spack extension “MPD”.
- some suggestions for changes or additions to Spack to make such work easier.

In this presentation, we introduce the discretization and analysis tools available in the Trilinos software suite. Using real-world scientific applications as exemplars, we briefly explain how to efficiently implement portable high-order finite element discretizations on unstructured grids for a wide variety of problems, including leveraging time integration schemes for transient problems. Additionally, we describe how to utilize the automatic differentiation and adjoint capabilities for solving nonlinear problems and computing sensitivities. Finally, we present the simulation-constrained optimization capabilities available through the ROL package, highlighting how different Trilinos tools work together to efficiently solve large-scale inference problems.

High-fidelity simulations of high-speed, compressible flows require accurately capturing complex features for precise results. AMReX - an exascale, block-structured adaptive mesh refinement (AMR) framework, enables high-resolution simulations for a range of applications. This talk explores two key challenges in high-speed flows: moving bodies and liquid-gas flows. For moving bodies, a ghost-cell method is developed within the Compressible Navier-Stokes (CNS) framework of AMReX to compute fluxes on moving embedded boundary (EB) faces. A third-order least-squares formulation improves wall velocity gradient accuracy, enhancing skin friction coefficient estimation. The method is validated using inviscid and viscous test cases. For liquid-gas flows, an all-Mach multiphase algorithm solves the compressible flow equations using an unsplit volume-of-fluid (VOF) method with piecewise linear interface calculation (PLIC) for liquid-gas interface reconstruction. Simulations include a liquid jet in supersonic crossflow and spray atomization with acoustic excitation.

An ongoing challenge for HPC containers is how to make host resources such as GPU devices and proprietary interconnects performantly available inside a container. In Charliecloud, the key requirement is placing shared libraries (.so files) into the container and then running ldconfig(8) to update its cache. (Other implementations also have to deal with device files and their associated permissions and symlinks, but because Charliecloud bind-mounts host /dev into the container, this is not needed).

Charliecloud has done this for some time using ch-fromhost(1), which is a large, reverse-engineered shell script that copies the needed files into a writeable image. It is difficult to maintain, does not support SquashFS or other write-only images, and adds a workflow step.

Other implementations typically use “OCI hooks”, which are arbitrary vendor-provided or custom programs run at various phases during container setup. These also present maintainability / bit-rot problems, can be opaque, and because their interface is solely “do it for me”, any invalid assumptions that hooks make can be difficult or impossible to work around.

A different approach is the emerging Container Device Interface (CDI) standard, with contributors from nVidia, Intel, Los Alamos, and others. This gives prescriptive JSON/YAML descriptions of what is needed. Charliecloud has implemented CDI in its runtime ch-run(1), bind-mounting requested files and using an unprivileged tmpfs overlay (available since Linux 5.11 in February 2021) to avoid modifying the image. This is a considerably simpler and more maintainable way to make host resources available inside a container.

This talk will provide an overview of CDI, adaptations of the standard to our fully unprivileged workflow, and our C implementation. We will also demonstrate the functionality for nVidia GPUs and HPC/Cray Slingshot interconnect.

LA-UR-25-22140

As High-Performance Computing (HPC) transitions from petascale to exascale, we have observed significant changes and new challenges in HPC software management. This presentation details the choices made for building and deploying HPC applications and tooling on the HPE Cray EX Adastra machine at the French National Computer Science Center for Higher Education (CINES). We present the GAIA project, a home-grown solution on top of Spack, allowing us to deploy software stacks for each of our partitions. We expose our requirements, the trade-offs we faced, the choices we made, and the strategy employed to address them. We explain how our users can leverage the Spack configuration provided by CINES to build their own software and the limitations of the approach. We finally take a look at the general applicability and open-sourcing to our site's user base.

The Trilinos project is one of many in the scientific software community that employs the concept of Continuous Integration and thusly has a testing process that ensures code functionality and quality as part of its contribution process. This talk is aimed at software developers and researchers interested in enhancing their understanding of Trilinos’ CI practices. We will examine the current processes that contributors must navigate, alongside emerging paradigms shaping the evolution of these practices. Key topics will include the implementation of containerized software testing environments, requirements for running tests on Trilinos compute resources, and objective standards that contributions must meet to guarantee software quality. Attendees will also gain insights into the challenges of providing a highly configurable set of software packages while maintaining user-friendly build processes. By the end of the session, participants will have a clearer understanding of how to effectively contribute to Trilinos, and the direction that DevSecOps efforts in Trilinos are heading in the future.

As the demand for efficient DevOps infrastructure for software applications continues to grow, key components such as build processes, build time tests, regression testing, and deployment mechanisms have become critical to successful project delivery. Spack is increasingly being adopted as an orchestration architecture for DevOps, offering a framework that can adapt to various project needs. However, while the overarching patterns among projects may be similar, the specific implementation details can differ significantly, leading to challenges in achieving seamless integration. In this talk, we will present the gaps identified by researchers at Sandia National Laboratories in Spack's current services and our ongoing efforts to address these challenges.Key topics will include advancements in binary caches, binary provenance, reporting test results, enhancing build performance, and improving the overall developer user experience. Attendees will gain valuable insights into successful initiatives that have effectively closed certain gaps, as well as ongoing issues that remain open for the community to tackle.

Wind energy plays a crucial role in meeting the electricity demands of the U.S.; however, high maintenance costs highlight the need for accurate predictions of unsteady loading caused by turbine layout and off-design wind conditions. Existing design tools often neglect fluid-structure interactions that drive costly fatigue loads, prompting the research community to leverage high-performance computing (HPC) solvers to study these effects. Unfortunately, such tools remain too complex and costly for industrial applications, particularly due to challenges in grid generation and setup. To address this, CDI is developing a Cartesian-based hybrid solver that integrates an incompressible vorticity-based far-field formulation with a compressible primitive variable solver in the near field. The framework is built on the AMReX library, enabling block-structured mesh refinement for efficient computation. This talk will explore both the computational and mathematical aspects of coupling these two solvers, highlighting advancements in predictive modeling for wind turbine aerodynamics.

The 4C (Comprehensive Computational Community Code) multiphysics simulation framework has been developed to address complex physical phenomena across various scientific and engineering domains. From its inception, 4C has relied on the Trilinos project, an open-source software library for scalable numerical computations, as its backbone for sparse linear algebra and MPI-parallel computing. This integration enhances 4C's computational capabilities and, more importantly, allows the 4C developers to focus on their core research interest: the numerical modeling of multiphysics systems. The synergy between 4C's physics models and Trilinos' numerical solvers facilitates the simulation of coupled multiphysics systems with improved accuracy and performance. Over the years, this synergy has — in parts — evolved to a co-development of both software frameworks. This presentation will delve into the methodologies employed to incorporate Trilinos into the 4C framework, discuss software and development challenges, and showcase application case studies that demonstrate the practical benefits of this integration in simulating complex multiphysics systems such as fluid-solid interactions, contact mechanics or beam-solid interaction.

Members of the Charliecloud team will be available for office hours to listen to feedback/suggestions, answer questions, and/or help debug issues.

LA-UR-25-22140

1. Experience Porting a Scientific Code from YAKL to Kokkos - James Foucar, Sandia National Labs (10 minutes)
The DoE climate code E3SM recently ported a medium sized scientific code, RRTMGP (computes radiative fluxes in planetary atmospheres), from a kernel launcher called YAKL to Kokkos. We'd like to share tips and pain points from this effort, particularly the struggle to get to performance parity with YAKL. We found that a 1:1 port (YAKL API is very similar to Kokkos) was not nearly sufficient to achieve good performance. The main issues were how to allocate temporary views and dealing with MDRangePolicy.

2. Benchmarking Lattice QCD Staggered Fermion Kernel Written in Kokkos - Simon Schlepphorst, Forschungszentrum Juelich GmbH (10 minutes)
Lattice quantum chromodynamics (QCD) is a numerical approach to studying the interactions of quarks and gluons, where the fundamental eqautions governing their interactions are discretized to a four dimension spacetime lattice. One of the most costly computations is the inversion of the lattice Dirac operator, a large sparse matrix. Calculating this inversion with iterative solvers leads to many applications of that operator. This study builds on previous work where we implemented the staggered fermion Dirac operator as a benchmark in Kokkos. We investigate the effects of the tiling size in combination with the use of a 4D MDRangePolicy and 7D Views.

3. Leveraging Liaisons in Your Network for Software Sustainability - Elaine M. Raybourn, Sandia National Laboratories (10 minutes)
Open source software project sustainability is a sociotechnical endeavor that often extends beyond the efforts of individual projects. HPSF and the Linux Foundation offer rich resources of expertise across communities in industry, academia, and agencies. Leveraging this collective knowledge and experience is vital to enhance project practices, especially in early identification of challenges and potential issues. This lightning talk explores the value of leveraging liaisons — key individuals who are actively participating in cross-team networks, to accelerate project sustainability. Liaisons can bridge gaps, share tacit knowledge and incentivize collaborative efforts across communities, go assist in breaking down silos. The value of leveraging liaisons was identified during the DOE Exascale Computing Project to foster strategic project alignment and outreach. Whether a small team, or a larger network of teams of teams, identifying liaisons early on can foster trust and transparency both within and across teams.

4. Vertex-CFD: A Multi-Physics Solver for Fusion Applications - Marc Olivier Delchini & Daniel Arndt, Oak Ridge National Laboratory (10 minutes)
In this talk we will introduce Vertex-CFD, a multiphysics solver that is being developed in response to needs by Oak Ridge National Laboratory (ORNL) to have accurate simulation software for use in modeling of a fusion blanket problem. Vertex-CFD is built upon Trilinos and Kokkos libraries for compatibility with CPU and GPU platforms. It is designed to generate high-fidelity solutions of multiphysics problems in complex geometries by leveraging state-of-the art computing methods and technologies. We will describe how we leverage Kokkos and Trilinos to solve the governing equations by employing a finite element method and high-order implicit temporal integrators.

5. Toucan: Revolutionizing Microstructure Prediction - Benjamin Stump, ORNL (10 minutes)
Going to describe my code, what it is doing (physically), what I need it to do computationally, how I achieved it using Kokkos and optimized it algorithmically.

6. Performance-Portable Spectral Ewald Summation with PyKokkos - Gabriel K Kosmacher, Oden Institute, The University of Texas at Austin (10 minutes)
We present a performance portable implementation of the Spectral Ewald method, employing shared memory and streaming parallelism to rapidly evaluate periodic two-body potentials in Stokes flow. The method splits dense particle evaluation into near-field and far-field components, where the near-field is singular and the far-field decays rapidly in Fourier space. Far-field interactions resemble a Nonuniform Fast Fourier Transform: source potentials are interpolated onto a uniform grid (p2g), an ndFFT is applied, Fourier potentials are scaled, an ndIFFT is applied, and the potentials are interpolated back (g2p). The p2g, g2p, and near-field (p2p) interactions use Kokkos hierarchical parallelism with scratch-pad memory and thread-vector range reductions.

7. Empowering NSM Supercomputers with Kokkos for Scalable HPC - Harsha Ugave & Samir Shaikh, Centre for Developement of Advanced Computing (C-DAC) (10 minutes)
Kokkos is transforming how high-performance applications run on National Supercomputing Mission (NSM) systems. With NSM deploying a mix of CPUs, GPUs, and other accelerators, ensuring software runs efficiently across all these platforms can be challenging. Kokkos simplifies this by providing a single, flexible programming model that adapts to different hardware without requiring major code changes. It supports multiple backends like CUDA, HIP, SYCL, and OpenMP, making it easier for developers to write performance-portable applications. For NSM’s large-scale supercomputers, Kokkos ensures better performance and scalability, allowing applications to make full use of processors, GPUs, and memory hierarchies. It also optimizes energy efficiency by improving memory access and reducing unnecessary data movement, helping to make supercomputing more sustainable. Since Kokkos is open-source and backed by an active community, it keeps up with emerging technologies, ensuring seamless adoption of next-generation NSM systems and preparing them for the future of exascale computing.

8. Real-Time Performance Characterization of the ADIOS2 Library When Kokkos Is Enabled - Ana Gainaru, Oak Ridge National Laboratory (10 minutes)
Modern performance analysis tools are increasingly capable of capturing a high volume of metrics at ever-finer granularity. This abundance of information presents an opportunity to move beyond post-mortem analysis and leverage data streaming for real-time performance monitoring and decision-making. By streaming performance data, applications can provide immediate feedback, enabling dynamic adjustments and optimizations during execution. Furthermore, this streamed data can be directed to individual scientist workstations, facilitating on-the-fly health checks and user-driven interventions to steer the application's behavior. We will demonstrate the practical application of these concepts within the ADIOS2 library, showcasing how data streaming enables detailed monitoring and analysis of an HPC application during large-scale runs.

9. Cabana: Particles, Structured Grids, and Extensions to Unstructured with Kokkos - Sam Reeve, ORNL (10 minutes)
We discuss updates to Cabana, a Kokkos+MPI library for building particle applications. Cabana was created through the U.S. Department of Energy Exascale Computing Project to enable particle simulation across methods on current and future exascale supercomputers. Cabana includes particle and structured grid parallelism, data structures, algorithms, communication, and interfaces to additional libraries, all extending and working alongside Kokkos. We focus in particular on recent efforts to integrate Cabana particles within Trilinos unstructured grids for broader support of scientific applications. We will highlight further recent Cabana development, performance and portability, and application-level demonstrations.

In this presentation, we will describe how we manage to develop multi-physics applications with a software stack deployed with Spack.

We will describe how we have designed a workflow, first using Spack features for development, such as "setup," "dev-build," and "develop." And how we ended up creating a Spack plugin to generate custom CMake presets.

CMake presets are a portable way to set up CMake configurations. They can describe several configurations. And they can be exploited by different tools, from the command line to IDE.
Generating these presets from Spack concretizations allows users to exploit their classical environment, benefiting both from a correct installation of their dependencies as well as advanced features of the IDE that do not need to integrate explicitly with Spack.

We will present our journey between the different spack solutions, the development of a CMake "preload cache"-based answer, and we will illustrate use cases of why we ultimately switched to CMake presets.

In this presentation I will present the feedback of packaging and deploying the dependencies of the open source library `gyselalibxx` using Spack on a local cluster and on the national supercomputer Adastra. I will explain the challenges faced to deploy the library and why we chose Spack.

AMR-Wind is a high-fidelity computational-fluid-dynamics solver for simulating wind farm flow physics. The solver enables predictive simulations of the atmospheric boundary layer and wind plants by leveraging a block-structured, adaptive-mesh, incompressible-flow solver. AMR-Wind is designed for scalability on high performance computing systems, with an emphasis on performance portability for graphical processing units (GPUs). These flow solver capabilities and performance characteristics were enabled using the AMReX library. In this talk, we present AMR-Wind, its capabilities and performance characteristics. We detail the numerical implementation, verification and validations efforts, as well as demonstrate AMR-Wind for large eddy simulations of wind farm physics. A demonstration simulation is presented for a 12-turbine wind farm operating in a turbulent atmospheric boundary layer with realistic wake interactions. We also discuss AMR-Wind in the wider context of the ExaWind suite of codes, including (1) its integration as a background solver to Nalu-Wind with overset methods to perform geometry-resolved simulations of wind turbines and (2) its use coupled to a mesoscale weather simulation code, ERF.

The solution of multiphysics problems depends on the construction of robust preconditioners which significantly influence the convergence rate and computational performance of linear solvers. We employ physics-based block preconditioning strategies from the Trilinos/Teko package developed by Cyr, Shadid, and Tuminaro [SIAM Journal on Scientific Computing, 38(5):S307–S331, 2016]. Teko preconditioner parameter selection, however, remains a difficult task for users. This talk presents an automated approach for the selection of multiphysics preconditioner parameters in the Trilinos/Teko package. We discuss design principles for preconditioners, emphasizing the importance of physics blocking, subblock ordering, and subblock solver choices based on equation types and coupling strengths. Finally, we present an extension to the Trilinos/Teko package in the form of a user-friendly software tool for automatic multiphysics preconditioner design with minimal user input.

The Linac Coherent Light Source (LCLS) at the SLAC National Accelerator Laboratory takes X-ray snapshots of atoms and molecules in action, revealing fundamental processes in materials, technology and living things. Advanced data and computing systems are playing an increasingly vital role in LCLS’s operation: data acquisition software developed at LCLS allows the collection of very high throughput data, and makes sure that all the collected data is stored to disk. Additionally, LCLS provides scientists with sophisticated data analysis frameworks and helps them run their own bleeding-edge scientific analysis tools. With new detectors and analysis techniques being introduced all the time, new software is constantly being developed and maintaining compatibility with old hardware while supporting new frameworks and programs is an everyday challenge. Spack seems to offer a solid foundation for the software development process and is starting to be used at LCLS. This talk will discuss how Spack is making the development process easier and what challenges the LCLS Data Analysis group is still facing in making Spack a useful tool for everyday work.

So, we got bored with installing stuff. Our project aims to accelerate time to results, improve reproducibility, and reduce reliance on proprietary programming environments and manual installs. Built on Spack, our tooling enables the rapid deployment of versioned programming environments to globally distributed HPC clusters, ensuring consistency across clusters and regions. This talk will present our solution and the problems it solves for us, discuss its benefits for HPC productivity, and invite community feedback on its broader applicability.

Load balancing is an evergreen topic in HPC mesh-and-particle codes like AMReX. Appropriate, fast and effective load balancing strategies are critical to ensure AMReX codes are capable of making the best use of available computational resources and maximizing the size and type of simulations that can be performed. I have begun investigating potential short and long term advancements in load balancing that may be of use to the AMReX community. In this talk, I will give an overview of the current load balancing options in AMReX plus an algorithmic investigation performed last summer by NERSC summer interns which found potential improvements in our current Knapsack and SFC algorithms. Then, I will present an overview of possible next steps, long-term advancements, and where I believe these advances would be most helpful. Hopefully, this will generate a discussion around which investigations would be most helpful to the AMReX community to determine the best targets for this summer’s interns and beyond.

The Trilinos scientific software library is a key enabling technology for application codes in a variety of physics and engineering areas across the US Department of Energy and beyond. This presentation will "pull back the curtain" and describe the process by which the Trilinos Tpetra/Performance team (a) performs nightly testing across five DOE laboratories, (b) how we identify and remedy performance regressions, (c) how we make the validated build scripts available to Trilinos developers, and (d) how we interface with early users and vendors to ensure that vendor library updates work as advertised.

Managing software stacks on high-performance computing (HPC) systems is a complex challenge, particularly when working within vendor-provided programming environments. To address this, the National Center for Computational Sciences (NCCS) at Oak Ridge National Laboratory has developed NCCS Software Provisioning (NSP), a unified framework for deploying and managing software stacks while monitoring their usage.

NSP leverages Spack and Ansible to automate the deployment of software environments. Using templated configurations, it streamlines Spack-based installations while also managing non-Spack software through custom Ansible roles. Additionally, NSP enhances LMOD-based module environments by incorporating hooks and Spack module projections, enabling a dynamic and responsive software layout that adapts seamlessly to changes in the programming environment.

This presentation will discuss the motivation behind NSP, its strategies for managing software complexity in vendor-provided environments, and its implementation on Frontier, the world’s fastest supercomputer for open science.

The rapid growth in features, capabilities, and adoption of Spack has transformed it into a vital tool for managing software dependencies in scientific computing. However, one of the significant challenges faced by large organizations is the effective communication and information sharing across diverse teams. This talk will present a case study from Sandia National Laboratories, detailing the evolution and impact of strategies implemented to address these communication hurdles. We will explore the formation of a self-organized working group dedicated to fostering collaboration and knowledge exchange around Spack, as well as a recently funded initiative aimed at enhancing Spack collaboration and development efforts. By examining the successes and lessons learned from these organizational approaches, we aim to provide insights into best practices for engaging teams in the adoption of Spack, ultimately promoting a more cohesive and efficient development environment. Attendees will leave with a deeper understanding of how structured engagement strategies can facilitate the integration of Spack within large organizations and enhance collaborative software development efforts.

This research develops a framework to simulate multiphase flows with surface tension. Two open-sources are coupled to achieve this goal: interface reconstruction library (IRL), a library of the volume of fluid (VOF) scheme, and PeleLM, a reacting Navier-Stokes equation solver. In addition to the coupling, surface tension is implemented using the continuum surface model (CSF) along with the improved height function technique. The coupling produces spurious errors in the volume fraction field. The spurious error is corrected by geometric consideration, which improves the numerical stability and accuracy. With the developed framework, multiple validation simulations are conducted. The validation simulations are (i) translations and rotations of Zalesak’s disk, (ii) three-dimensional deformations of a sphere droplet, (iii) a stationary circular droplet with surface tension, and (iv) an oscillating elliptical droplet. Quantitative comparisons show that the shape errors of Zalesak’s disk and 3D deformation case show comparable errors with other solvers. The pressure inside the stationary droplet is well maintained within 3.6 % compared to the theoretical value. For the oscillating elliptical droplet case, the oscillation period is within 6.7% compared to the linear theory.

PyTrilinos2 is an auto-generated Python interface for several Trilinos packages. I will explain how additional C++ functionality can be exposed to Python and demonstrate existing solver capabilities.

Spack team members manage a complex continuous integration (CI) infrastructure to compile and test software distributed via a centralized build cache. The workflows are executed in virtualized cloud environments, an approach that offers considerable flexibility in resource provisioning, resulting in quick feedback on pull requests submitted by the Spack community. However, fixed resource allocations for build jobs lead to job failures, slowdowns, and suboptimal resource usage.

spack-gantry aims to address these challenges by providing resource allocation predictions to build pipelines. We use historical build data to forecast future utilization and set resource limits. We will present strategies used to find optimal predictions, as well as experiments to create an online prediction service modeled after a genetic algorithm. The results of this work include improvements in usage efficiency and cost-per-job metrics.

Because spack-gantry involves modifications to the current CI system, we will discuss ramifications for users and developers and solicit feedback about how to make the infrastructure more user-friendly, reliable, and functional for the Spack community.