SC26 Program of Participation

Supercomputers get faster and more complex every year. MPI, long the dominant model for distributed computation, has adapted by combining with models for intra-node parallelism (e.g., OpenMP, CUDA). These MPI+X hybrids offer performance but demand significant programmer effort to write, debug, and tune applications. Alternatives to MPI+X are worth exploring as programmer productivity becomes a major component of the time to science. Alternatives include parallel programming languages (e.g., Chapel, Regent, Fortran), general purpose libraries (e.g., Charm++, COMPSs, HPX, Legion, UPC++), and domain-specific libraries (e.g., Arkouda, Dask, Spark). With many options to choose from, it is hard for programmers to know which alternative models are appropriate for their application and for programming model developers to understand the opportunities for improvement. PAW-ATM brings together both application experts and programming model developers to disseminate knowledge about available applications and models, as well as advance their design.

MPI has long been the default substrate for distributed scientific computing, but it is not the only path to scalable performance—and in Julia, it is often not the most productive one. This talk surveys the landscape of MPI-free distributed computing in Julia, centered on the standard-library Distributed package and its surprisingly performant primitives for remote execution, data movement, and cluster management. I will review which widely-used Julia packages already run on top of Distributed, and how their capabilities compare to their MPI-based counterparts. The core of the talk focuses on Dagger.jl, a task-based parallel runtime that provides unified support for both Distributed and MPI: every algorithm expressed in Dagger runs unchanged across either backend, as well as across multi-CPU and multi-GPU configurations. I will highlight Dagger's Datadeps API, which lets users express data dependencies declaratively and have the scheduler automatically handle communication, synchronization, and placement—whether the underlying transport is Distributed or MPI. Through concrete examples, I will show how this abstraction delivers portability without sacrificing performance, and close with an overview of the current state of distributed computing across the broader Julia package ecosystem.

Weather and climate models are large and complex collections of mathematical modelling software. They can take more than a decade to develop and can be in use for a quarter of century or more. They also typically undergo constant revisions and improvements from teams of developers. The proliferation of programming models in the MPI+X paradigm is therefore particularly problematic as cost of developing and maintaining multiple X implementations for different architectures in such a code base becomes prohibitive. The rapid evolution of the programming models has exacerbated the problem. Fortran has been the de facto standard programming language for weather and climate applications and can considered a low-level domain specific language for numerical computation. The ability to write code that in some sense looks likes the maths is part of its appeal and enables developers to be productive. The invasive level of parallel code additions required for performance degrades the sustainability of the code base. One approach to solving these problems has been to raise the level of abstraction from a general-purpose language to a domain specific language (DSL). Here domain specific information is encoded in and exploited by the programming model for optimisation purposes. Key to this approach is a strong separation of concerns between the science/maths code and the parallel and optimisation code. This approach enables developers to write code which looks like maths whilst allowing the portability and performance by having different routes to optimised codes for different architectures. This comes with the cost of designing and maintaining the DSL. The Met Office is part of the Momentum partnership and is developing the Momentum modelling software system. The atmosphere model, LFRic, is developed and co-designed in a its own DSL, embedded in Fortran. Part of the DSL is the python domain specific compiler, PSyclone. The advantages and limitations of the this approach are discussed, including the consequences of design choices such as embedding the DSL in Fortran. Some performance results from LFRic are presented as evidence to support the arguments. Finally, how emerging agentic programming techniques may complement DSL-based approaches and what this implies for future weather and climate software development is considered.

Cross-facility workflows are no longer optional but a requirement for the success of current and future science campaigns. From remote labs to multi-institutional science campaigns, advances in instrumentation and technological innovation are enabling experimental and observational scientific user facilities to generate data faster than processing and storage can handle. Our work explores EJFAT as a potential solution to these challenges. While EJFAT has been shown to be performant and scalable, this paper explores considerations for integrating EJFAT into real-world scientific experiments. We explore two applications: one highly integrated, the other highly generalizable. The first is a highly tuned and optimized workflow for pushing data as fast as possible to meet the goals of scientific experiments, while the second is a general ecosystem lowering the barrier for scientists to leverage HPC resources with minimal effort representing two common classes of applications typical found in scientific user facilities.

One approach to the development of high-performance computing applications is based on libraries that implement algorithmic motifs in a portable, performant and concise fashion. We develop a GPU-accelerated algorithm for Method of Local Corrections, a particle-particle particle-mesh method for simulating incompressible flow in 3D, using such motif libraries. The algorithm comprises of structured grid calculations, local particle interactions, and free-space convolution. We use two motif libraries: Cabana, a motif library for particles, built on top of Kokkos; and FFTX for fast Fourier Transform, that uses the SPIRAL code generation system. By using motif libraries, we obtain a concise and portable implementation (2K lines of code). We compare the measured performance to that predicted by the roofline model and obtain 52\%-86\% on NVIDIA A100, 42\%-61\% on NVIDIA H100, 22\%-42\% on AMD MI100, and 17\%-38\% on AMD MI300A.

Agentic systems answer operational queries over HPC telemetry for domain scientists who cannot verify the responses. Trustworthiness requires recovering the facts telemetry supports and refusing the questions it does not, since no facility instruments everything it runs. Existing architectures are built for capability on the assumption that reliability follows, and inference remains untested. We compare five configurations, one tool-using agent and four multi-agent designs varying only in inter-agent communication and shared-state structure, on EPIQ, a new benchmark of 55 multi-intent queries over Fugaku job telemetry with 119 verifiable facts and 25 unanswerable sub-questions. The single agent recovers the most facts (84.9%) but refuses least. Pairing peer messaging with typed dialogue-act fields refuses most (92.0%) while matching single-agent recall within noise, at 2.5 times the tokens. Refusal follows whether agents exchange results at all; typing those exchanges recovers recall. Agent count explains neither. Recall and refusal must be designed for separately.

The advancement of Large Language Models and the rapid evolution of AI assistants and agents create an opportunity for the development of highly specialized HPC agents to enable automatic performance analysis. In this paper, we present Custodian, an HPC performance analysis agent that analyzes previously collected job telemetry and application-output data to characterize application behavior, identify potential performance bottlenecks, and transform performance metrics into natural language descriptions and figures that suggest optimizations or highlight computing inefficiencies. We validate Custodian’s telemetry-derived application states and roofline analyses against NVIDIA Nsight Systems and Nsight Compute across four representative applications executed on NERSC Perlmutter. Finally, we discuss the tradeoffs, cost, productivity and systems applicability of HPC agents on the NERSC HPC system.

The symmetric rank-k update (SYRK), C = AA^⊤, computes the dot product between each pair of rows of A. Its sparse variant is central to similarity-based approaches in machine learning, graph analytics, and genomics. Existing distributed sparse matrix multiplication algorithms, such as Sparse SUMMA, treat sparse SYRK as a generic multiplication, leaving performance untapped. In this paper, we present a distributed sparse SYRK algorithm that leverages symmetry. The approach reduces per-process computation compared with state-of-the-art distributed SpGEMM. A second variant reorders communication to avoid materializing A^⊤ and reduce communication volume. The algorithm achieves a 2× speedup over an optimized Sparse SUMMA on matrices. Our variant achieves superior scaling at high process counts. The approach is a drop- in replacement for any application computing C = AA^⊤ via a distributed SpGEMM routine, and its triangular output can be consumed directly by subsequent operations with reduced compute and memory footprint.

As domain-specific accelerators gain importance and workloads increasingly exhibit structured, predictable communication patterns—particularly in machine learning, scientific computing, and tensor operations—the role of explicit communication primitives deserves renewed scrutiny. This panel examines whether the compiler and runtime stack should bear greater responsibility for inferring and optimizing communication, potentially relegating explicit APIs to legacy status. The rise of Tile IRs and polyhedral compilation frameworks suggests a future where communication becomes an emergent property of program structure rather than a programmer directive. When tiling strategies, data dependencies, and memory hierarchies can be analyzed statically or just-in-time, do we still need developers to manually orchestrate point-to-point sends, broadcasts, and reductions? Or does the irregularity and dynamism of real applications—adaptive meshes, sparse data, load imbalance—ensure that explicit control remains essential? This discussion will explore the tension between programmer productivity and performance portability, examining where today's compilation technology succeeds in hiding communication complexity and where it fails. Panelists will debate whether the next decade belongs to smarter runtimes that auto-parallelize and auto-communicate, or whether the most demanding applications will always require the fine-grained control that only explicit communication provides.

Disaggregation is an emerging compute paradigm that splits existing monolithic servers into a number of consolidated single-resource pools that communicate over a fast interconnect. This model decouples individual hardware resources and enables the creation of logical compute platforms with flexible and dynamic hardware configurations. The concept of disaggregation is driven by various recent trends in computation. From an application perspective, the increasing importance of data analytics and machine learning workloads brings unprecedented need for memory capacity, which is in stark contrast with the growing imbalance in the peak compute-to-memory capacity ratio of traditional system board-based servers. At the hardware front, the proliferation of heterogeneous, special-purpose computing elements promotes the need for composable platforms, while the increasing maturity of optical interconnects elevates the prospects of distance independence in networking infrastructure. The workshop intends to explore various aspects of resource disaggregation, composability, and their implications for future HPC platforms.

The slowing of Moore’s Law and the rapid growth of AI are pushing systems toward greater specialization across compute, memory, networking, and storage. At the same time, AI for Science is bringing simulation, analytics, training, inference, and agentic execution into increasingly connected workflows that need to share and move data efficiently. No single architecture is well suited to every part of these workflows. This talk looks at tightly coupled and customizable heterogeneity as a way to build systems around these changing needs. A key focus will be macroheterogeneity, where different computing architectures work together as part of a larger system and each part of a workflow can run where it fits best. We will also look at customizable scale-up hypernodes, bringing compute, memory, accelerators, and high-bandwidth fabrics together in configurations shaped by workload needs. The goal is not simply to add more forms of heterogeneity, but to make them easier to couple, customize, and use as part of an end-to-end AI-HPC system.

In 2025, LLVM released its first Flang Fortran compiler version considered ready for widespread evaluation. We know of no published assessment of Flang compiling a workload-derived portfolio of high-performance computing (HPC) applications. We address this gap using workload data from the National Energy Research Scientific Computing Center (NERSC), which supports more than 10,000 scientists on approximately 1,000 projects. We selected ten Fortran packages heavily used at NERSC with available source code and compiled them using recent versions of Flang on NERSC’s Perlmutter system. Seven compiled without code modifications, though some required build-system changes. Three compiled after minor source edits, mostly to address Fortran standard violations. We evaluated seven additional packages selected for their use or enablement of standard Fortran parallel features: multi-image execution and do concurrent. Six such codes compiled with most or all unit tests passing.

Large language models (LLMs) and agentic systems offer promising pathways for automating high performance computing (HPC) operations, yet their real-world deployment is severely constrained by silent operational failures, uncalibrated confidence, and brittle central control. In this work, we chart a new vision for reliable, agentic AI across supercomputing facilities. We explore the architectural paradigm shift from centralized orchestration to decentralized, peer-to-peer agent topologies, illustrating how typed dialogue and bounded knowledge limits ensure defensible, transparent operational guidance. Furthermore, we examine the critical challenge of stance fidelity, demonstrating how verbalized confidence must be audited as dynamic system telemetry rather than taken at face value. Based on these insights, we advocate for a fundamental re-architecting of facility AI: prioritizing honest refusal over raw recall, establishing auditable ground-truth benchmarks, and transitioning AI tools from passive historical log lookups to active, pre-submission job steering.

As demand for specialized architectures grows in the post-Moore era, this BoF will foster a sustained community around chip prototyping using open-source hardware tools. Building on themes explored in previous editions of this BoF at SC24 and SC25, the session will focus on practical tool experiences, current gaps, domain-specific accelerators, AI-assisted design workflows, and chip prototyping as an emerging HPC workload. Invited speakers from architecture, open-source EDA, accelerator design, and HPC will seed discussion. Expected outcomes include actionable insights, stronger collaboration, and follow-up community initiatives to advance open-source chip prototyping.

AI is rapidly reshaping scientific software through code generation, simulation acceleration, intelligent workflows, and emerging agentic systems. Yet the software ecosystems, collaboration models, trust frameworks, and workforce practices that underpin high performance computing (HPC) were built for a different era. Drawing on findings from a recent workshop series (https://arxiv.org/abs/2510.03413), this BoF invites the international community to challenge assumptions, identify emerging priorities, and help define the next generation of scientific computing ecosystems. Discussion will focus on human-AI collaboration, trust, sustainability, user experience, and workforce evolution — turning shared insights into actionable directions for the community.

Fortran plays a crucial role in numerous applications. This BoF provides a forum for Fortran developers to engage with the language's modern programming features. With features introduced in recent language revisions, Fortran 2023 supports modern programming practices and high performance computing (HPC). This BoF gathers developers from diverse domains to share experiences and explore Fortran's evolving capabilities. After some brief presentations, the session will focus on an interactive discussion where audience members will be encouraged to share their own experiences and ask questions of our experts.

This paper describes the mapping of geometric multigrid (GMG) onto the Cerebras Wafer Scale Engine (WSE-3). The WSE wafer integrates almost a million cores along with a low-latency 2D mesh network, providing unprecedented on-chip bandwidth and fine-grained communication. Although the architecture is predominantly used for deep learning, we explore the suitability of WSE for accelerating GMG. GMG solves sparse linear systems efficiently by recursively coarsening the grid, which leads to more rapid convergence with less computation. As compared to prior implementations of stencils on WSE, this demonstration highlights the challenges of mapping a layered algorithm – and the full set of operators – onto a dataflow architecture. We compare the performance of this implementation to that of the HPGMG benchmark on an NVIDIA GH200 GPU. Across different GMG configurations and problem sizes, we observe a speedup of up to 25× as compared to a single GH200 node.