Close

Posters

All
Research Posters
Poster Blitz
ACM SRC Posters
Interactive Research e-Posters
Doctoral Showcase
Recording
Tag
Poster Blitz Group
10am-5pm Skyline Ballroom North Pre-Function
StrataVR: A Unity-Based Out-of-Core Pipeline for Interactive Exploration of Multi-Terabyte Volumes in Virtual Reality
DescriptionLarge volumetric datasets often exceed GPU memory, making responsive exploration in virtual reality (VR) difficult. StrataVR is a Unity-based out-of-core volume renderer that stores datasets externally and loads a small multi-resolution working set as the view changes. To our knowledge, it is the first Unity-based out-of-core VR volume renderer demonstrated on a multi-terabyte dataset. A C++ tool prepares bricks and metadata, while view-aware planning and asynchronous streaming keep relevant data in a fixed GPU pool. Coarser resident bricks remain visible until finer data arrives, providing continuous feedback and progressive refinement. The working system supports multichannel visualization, empty-region skipping, channel controls, cross sections and cutouts.

The interactive e-poster will show how StrataVR turns a multi-teratbye dataset into a responsive VR experience. Animations will explain how StrataVR works, while Unity and headset footage will show it in use.
Interactive Knowledge Graph Supporting Self-Directed and Personalized High Performance Computing Education
DescriptionAcross universities, compute centers, and industry partners, significant resources are put into developing educational materials for researchers and developers in high performance computing (HPC). It is important to acknowledge that the range of research backgrounds in HPC is beneficial for the community in many ways but poses challenges for education. In particular, many HPC users and developers would benefit from foundational knowledge that may seem obvious to computer scientists. We propose an interactive knowledge graph of fundamental concepts of HPC, allowing learners to choose their own starting point and navigate forwards or backwards through related topics. This content is delivered through accessible, short lecture videos featuring animations that are delivered by HPC specialists. These videos are supplemented with formative assessments, and all of the concepts are structured into an interactive knowledge graph which specifies dependencies between concepts so that the learner can find their own pathways through the learning journey.
From YAML to Insight: Interactive Visualization of hws Hardware Samples
DescriptionThe hws library provides a simple, easy-to-use way to capture hardware metrics for CPUs and GPUs from various manufacturers, including NVIDIA, AMD, and Intel. Having a holistic view of how an application interacts with the underlying hardware is crucial for application developers optimizing not only for peak performance but also for other targets such as energy efficiency. Up until now, hws has exported the hardware samples as YAML files, leaving the data analysis and visualization of the results to the user.

Therefore, in this e-poster, we present a companion visualization tool for hws that generates interactive, standalone HTML reports, enabling users to quickly gain insights from hws data with minimal setup effort. Our interactive research e-poster will include a live version of the visualizer embedded as an iframe, allowing visitors to freely explore the tool with example scenarios and quiz questions on their own using the touchscreen.
OpenCosmo Visualization: In-Browser Exploration of Cosmological Particle Data
DescriptionQuerying a cosmological simulation and seeing it are usually separated by a dedicated tool, a preprocessing step, and a broken workflow. The OpenCosmo Visualization Application (OVA) closes that gap inside the OpenCosmo Portal: a completed query opens directly into an interactive 3D view of the queried particles, in the same browser tab, with no export, installation, or preprocessing. Built on WebGL2 and Babylon.js, OVA adds per-type controls, dynamic filtering by scalar range, a 3D clipping plane, screen-space selection statistics, and one-click immersive WebXR on top of point rendering. Even on integrated laptop graphics, OVA ingests and renders 5M points of a HACC halo end-to-end in about 6.7 seconds, sustains 114.8 FPS, and records zero blocking main-thread tasks.
Streaming Nuclear Physics at Scale
DescriptionNuclear physics experiments have long challenged the limits of high-rate and low-latency logic. Presently, streaming readout can move decision making from fixed detector electronics to software, allowing raw detector data to be processed continuously as they are produced. We highlight the state of Jefferson Lab and ESnet collaborative work with example workflows. First, existing data from the CLAS12 detector were replayed across ESnet through the EJFAT network load balancer to the Perlmutter supercomputer at NERSC, reaching 100 Gb/s as jobs dynamically scaled the workflow. Second, live data direct from the CLAS12 electromagnetic calorimeter were streamed, showing end-to-end capabilities and real-time cosmic ray identification. These demonstrations go beyond earlier transport benchmarks to physics-based streaming workflows, thus combining high-rate data transport with online scientific processing. We also discuss applying this approach to Jefferson Lab’s development of streaming-readout modules for positron emission tomography (PET) processing, enabling future whole-area, whole-body scanning otherwise considered impractical.
Adaptive Error Quantization for Lossy Compression of Scientific Datasets
DescriptionLarge-scale scientific instruments and applications generate massive amounts of data, creating storage and I/O bottlenecks for analysis. Error-bounded lossy compression methods mitigate this, but certain unpredictable datasets make it difficult to obtain large compression ratios with prediction-based compressors without introducing a large error. This work introduces adaptive error quantization, a novel extension to the SZ3 compressor framework. Our implementation dynamically refines the prediction error of an unpredictable data point by allocating additional error quantization bins through continuous bisection of the error, improving data fidelity for hard-to-compress datasets while minimizing storage overhead. We present a comparison of our adaptive method against the baseline SZ3 compressor on the HACC particle simulation datasets, highlighting our algorithm's advantage when compressing high-entropy fields.
Malleable OpenFOAM: Communication-Efficient Dynamic Reconfiguration for CFD
DescriptionWe introduce the first malleable implementation of OpenFOAM, the most widely used open-source CFD solver, allowing it to dynamically change its node allocation mid-run instead of staying fixed for the job's duration. The system uses communication efficiency (CE), measured live by TALP/DLB, to trigger resizing via the DMR framework, which handles checkpoint-restart at a new node count. The key technical contribution is identifying which runtime objects must be redistributed at reconfiguration using OpenFOAM's AUTO_WRITE flag to isolate true solver state, while discarding stale cached objects that otherwise cause deadlocks at scale.

Tested on a 92M-cell automotive CFD benchmark on the MareNostrum 5 supercomputer, the controller successfully converges from both under- and over-provisioned starting points to the target CE band. This malleable implementation of OpenFOAM automatically selects resources so users only pay for the efficient run and do not waste resources or wait longer for results.
Tessera: User-Defined Compiler Optimizations for High-Performance Scientific Computing
DescriptionDespite the extensive capabilities of today's compilers, general-purpose compilers cannot exploit domain-specific properties for optimization in scientific software because the semantic meaning of the code is lost as it is transformed from the application and library layers down to the compiler and hardware. To solve this problem, we present Tessera, an MLIR-based framework that allows domain experts to annotate scientific code with high-level mathematical and structural properties — including symmetries, matrix properties, and algebraic identities — which are automatically compiled into performance optimizations. This enables scientists to benefit from domain-specific optimizations without needing to restructure their code or have deep compiler expertise. To demonstrate Tessera's generality, we show that our framework achieves performance improvements on benchmarks built on both linear algebra and arbitrary-precision floating-point libraries.
A GPU-Friendly SSOR Preconditioner Based on an Approximate Inverse of Triangular Matrices
DescriptionWe develop a GPU-friendly variant of the symmetric successive over-relaxation (SSOR) preconditioner for efficient execution of the preconditioned conjugate gradient (PCG) method on GPUs. To avoid the forward and backward substitutions required by the original SSOR preconditioner, which constitute a major bottleneck on GPUs, we incorporate an approximate inverse of a triangular matrix appearing in the SSOR preconditioner, with a dropping strategy to reduce the cost of applying it. We demonstrate the effectiveness of the proposed SSOR variant against existing parallel SSOR variants on an NVIDIA H100 GPU. The proposed variant substantially reduces the cost of applying the preconditioner by replacing the forward and backward substitutions with SpMVs, while largely preserving the convergence improvement of SSOR. Consequently, despite the additional cost of constructing the approximate inverse, the total PCG execution time is reduced for most of the test matrices, demonstrating that the proposed approach provides an effective GPU-friendly SSOR variant.
Scalable Performance Diagnostics on Leadership Computing Platforms
DescriptionExascale supercomputers Frontier and Aurora provide infrastructure for executing applications across thousands of compute nodes, with massive MPI tasks, intensive CPU multi-threading, and heavy computation offloaded to GPUs. These heterogeneous workloads pose significant challenges for performance measurement and analysis tools. We refined the hpcanalysis framework as a multi-layered infrastructure consisting of a C++ ingestion engine for high-throughput, selective access to performance measurement slices, a query interface for extracting slices via specialized queries, and a Python API for high-level analytical tasks. This provides a scalable, efficient, interactive interface that ingests measurements for an execution across 100K MPI ranks on Aurora in under 10 seconds. We also designed HpcDataFrame, a GPU-accelerated substitute for the Pandas library, offloading heavy computations to NVIDIA, AMD, and Intel GPUs, achieving speedups of up to 314x over Pandas processing. Collectively, our contributions provide a scalable substrate for performance diagnostics at the absolute limit of modern supercomputing.
Design the Plant and the Control Together
DescriptionExascale cooling plants are often sized and operated by convention, making it unclear how much energy can be recovered through control and how much performance is fixed by plant design. We developed and validated a digital twin of the Frontier supercomputer cooling plant using one year of operational telemetry, then optimized control settings, coolant flow, subloop topology, and life cycle cost and carbon. The novel contribution is an end-to-end co-design framework showing that implementable control recovers 27.8% of annual cooling energy, while optimized flow allocation reduces topology sensitivity by 93%, leaving embodied carbon as the main remaining design criterion.

The study has completed model validation, annual optimization, topology enumeration, and life cycle analysis. During the poster session, we will use a system diagram, validation plots, energy savings comparisons, topology results, and a life cycle decision map to show why control should be optimized before hardware redesign.
FFUSE: I/O Fault Injection and Resilience Scoring for HPC and AI Workloads
DescriptionAs HPC and AI/ML workloads increasingly share storage, filesystem faults (errors, partial I/O, latency spikes, silent corruption) can cause crashes or undetected data loss. To our knowledge, no systematic comparison of HPC and AI responses to identical filesystem faults, or unified cross-domain metrics, exists. We present FFUSE, a FUSE-based framework injecting seven filesystem fault categories transparently at the application I/O layer, and FIORE, a metric for failures without error reporting. Across 27 runs per workload, LAMMPS (HDF5 checkpoints) had lower crash (29.6% vs. 51.9%) and failure (44.4% vs. 66.7%) rates than ResNet-50 (pickle-based checkpoints). FIORE was 0.333 (LAMMPS) and 0.222 (ResNet-50), indicating ResNet-50 reported a larger share of its failures. Checkpoint format was associated with differences in I/O-layer fault behavior; a small paired pilot holding the application fixed suggests format can alter recovery outcomes but cannot isolate its effect. These results may inform checkpoint reliability in converged HPC–AI systems.
Leveraging Sparsity for LLM Inference in a Commercial Processing-in-Memory Prototype
DescriptionLM decoding is bounded by the memory wall: weights and KV cache move every token, and the low-arithmetic-intensity matrix–vector products of decode leave throughput set by bandwidth rather than compute. Bank-level PIM attacks this by keeping weights resident and computing in place, but its lockstep execution cannot skip zeros. We present the first end-to-end sparsity-aware inference framework for bank-level PIM. A column-union cost model shows that lockstep cost is set by the union of columns (or KV tokens) a bank-group must visit, not the nonzero count. Activation-aware weight pruning aligns surviving columns across rows and matrices, while a group-aligned adaptation of query-aware KV selection collapses the attention scan. Against a measured NVIDIA H200 at batch-1, this work cuts per-token latency by 4–7× and, beyond moderate context, undercuts the GPU’s most energy-efficient batched configuration (crossing near 10K, around 6× lower at 128K), while preserving accuracy and extending on-board context.
CLASP: Index Compression for Finite Element SpMV
DescriptionSparse matrix-vector multiplication (SpMV) in finite element methods is memory-bound, with index storage consuming a significant fraction of bandwidth. We exploit mesh connectivity to partition the assembled matrix into element-wise blocks each covering at most B = 256 nodes, enabling 8-bit column indices and 16-bit row pointers, a 4x index compression over standard CSR. We show that the encoding is provably compressive with node duplication overhead bounded by $1 + O(B^{-1/d})$ for d-dimensional meshes. We present three GPU kernels: partitioned CSR, partitioned CSR with shared-memory buffering, and a prefix-sum-based COO variant. We test our kernels on four NVIDIA GPU generations and show that the proposed encoding results in a faster SpMV operation achieving 1.4x-1.7x speedup over cuSPARSE CSR. We further show that COO-variant is more suitable for high-bandwidth-equipped GPU systems. A direct CPU implementation of partitioning CSR kernel with vectorization achieves up to 2x speedup over Intel-MKL for SpMV operation.
Computers as Information Channels: A Common Yardstick for the Post-Moore Hardware Zoo
DescriptionWe propose a novel measurement unit for computing performance that's grounded in information theory. Modern computing systems are increasingly diverse, supporting low-precision formats, hardware specialization, and emerging paradigms such as analog, quantum, and neuromorphic hardware. Traditional metrics like floating-point operation (flop) counts no longer accurately capture this complexity. Instead, we frame computation as the transformation of information through a channel and define performance in terms of the mutual information between a system’s inputs and outputs. This approach measures not just the quantity of data processed, but the amount of meaningful information encoded, manipulated, and retained through computation. Our proposal aims to provide a principled, implementation-agnostic foundation for evaluating performance.
Runtime Power Feasibility for Small Modular Nuclear Reactor-Powered Datacenters
DescriptionDatacenters are exploring on-site small modular reactors (SMRs) for low-carbon power, but reactor power carries multi-hour state that conventional power scheduling does not capture. A power maneuver that is feasible when requested can become infeasible hours later as iodine–xenon dynamics evolve. We expose reactor feasibility through a runtime layer that checks the projected reactor state before the workload scheduler commits to a maneuver. Using eight Google Borg workload traces and PJM grid data, we evaluate reactor- and workload-aware policies at one-minute resolution. At low reactor margin, workload-aware scheduling without reactor state leaves 172 MWh unserved and averages 7.4 reactor shutdowns, while adding projected reactor feasibility reduces unserved work to 169 kWh with no shutdowns. Fixed recovery delays do not reproduce this behavior, and sensitivity experiments examine lookahead, enforcement margin, and reactor-model mismatch.
Towards a Distributed QHPC Workflow for Gadget-Aware Circuit Cutting and Pulse Synthesis
DescriptionPulse-level synthesis of compound gadgets (repetitive macroscopic gate blocks) compresses quantum control footprints. However, classically optimizing these schedules via optimal control algorithms creates severe compute bottlenecks, while scaling deep algorithms exhausts classical memory. These constraints demand distributed quantum high-performance computing (QHPC) workflows, but current tools use gate- or wire-level cutting that destroy data boundaries required for compound pulse gadget synthesis. We introduce Kodoki, a pulse gadget optimization framework that enables gadget-aware circuit cutting. Coupled with Qdislib and PyCOMPSs, Kodoki provides a decoupled distributed workflow. PyCOMPSs orchestrates pulse synthesis offline. Online, workers are given subcircuits and query a lookup table (LUT) of pre-computed pulses to execute subcircuits. Evaluations show Kodoki's compound synthesis achieves a 4.38x reduction in pulse execution time (from > 1000𝜇s to 240𝜇s). Shifting synthesis offline replaces an 865.5s compute bottleneck with a 2.326ms online query (𝑃₉₉ = 3.35ms). Ongoing evaluations will quantify scaling behavior across variational ansatzes.
Agentic AI Augmentation for Recursive Mixed-Precision Linear Solvers
DescriptionHigh performance computing increasingly relies on low-precision hardware for throughput, yet scientific applications demand numerical accuracy. Recursive mixed-precision algorithms address this, but extending them to new solvers requires expert-level knowledge. This work investigates agentic AI augmentation to transfer knowledge from a recursive mixed-precision Cholesky solver to new algorithms, evaluating in-context learning (ICL) and parameter-efficient fine-tuning (PEFT), using implementations, documentation, and mathematical formulations as structured knowledge. We find that full-context ICL enables frontier LLMs to generate a high-performance recursive mixed-precision LU factorization achieving up to a 4.9x speedup over cuSOLVER FP32 on H200 GPUs while preserving accuracy, whereas PEFT memorizes the framework but fails to generalize, showing that expert-designed HPC implementations can serve as reusable knowledge for AI systems. At the poster, I will present our knowledge-transfer framework via figures comparing runtime and speedup across ICL prompting levels and models, fine-tuning accuracy results, and our recursive mixed-precision framework and future directions.
Informing Probabilistic Tsunami Forecasting with Massive Earthquake Ensembles: FFT-Based Multi-GPU Source-to-Waveform Generation and Posterior-Start Flow Matching
DescriptionCascadia tsunamis can reach nearby coastlines within minutes, demanding rapid probabilistic forecasts from early seafloor-pressure observations. Gaussian Bayesian inference is fast but cannot capture non-Gaussian earthquake variability, while generating large simulation ensembles is expensive.

We developed a distributed FFT-based source-to-waveform pipeline that reuses precomputed physical responses, generating full-scale Cascadia waveforms in 24 ms per rupture on 64 GB200 GPUs after setup. Our contribution couples this scalable generator with posterior-start flow matching, which transports the pressure-conditioned Gaussian posterior into an earthquake-informed, non-Gaussian distribution. Trained on one million stochastic ruptures, the model reduces RMSE by 79% and CRPS by 86% relative to the Gaussian baseline across 4,096 held-out events.
Learning Within the Laws of the Hardware: Rethinking Multi-GPU Performance Modeling and Workload Characterization
DescriptionPerformance modeling enables runtime estimation, scalability analysis, and bottleneck identification without committing large-scale compute resources. However, existing methods rely on either analytical or empirical models: the former are interpretable and generalize by construction but are limited in accuracy by architectural assumptions, while the latter are accurate only where training data exists and offer no insight into performance-limiting factors. Addressing these concerns, we propose hardware-informed neural networks (HINN), applying the physics-informed neural network (PINN) methodology to multi-GPU performance modeling, where the governing "physics" consists of hardware-derived architectural laws. HINN retains established analytical models as differentiable priors and learns residual corrections subject to hardware-derived constraints enforced via automatic differentiation across the domain. Evaluated on five HPC applications on NVIDIA H100 GPUs, HINN achieves 7.6% and 9.9% median relative estimation error for kernel and communication predictions, while enabling extrapolation to unseen configurations and automated bottleneck classification.
Cheap Plans, Costly Trades: Host-Device Tradeoffs for SpGEMM on AiM
DescriptionSparse matrix–matrix multiplication (SpGEMM) is bandwidth-bound, the kind of kernel a memory-side accelerator ought to absorb, but the processing-in-memory hardware that ships is built for AI inference. We map 𝐶 = 𝐴 · 𝐴 onto SK hynix’s Accelerator-in-Memory (AiM), whose fixed-function units multiply dense bfloat16 vectors but cannot compute an address, so the host must place every product in advance. The mapping trades host planning for device time; we measure the trade over four designs, from almost no planning to a simulator-in-the-loop search. A single packing pass cuts device time 7×–122×, every further plan buys at most 8.5× more, and on a single product each plan costs more host time than it saves.
Characterizing Cooperative I/O Caching for Data Loading at Scale on Aurora
DescriptionDeep-learning jobs on exascale systems begin by reading identical files: Python packages, then training data from a shared filesystem, forcing thousands of processes to issue near-identical requests at once and slowing startup for the whole machine. Cooperative caching can relieve this by serving redundant reads locally, but it adds overhead, so it is not always worthwhile. We ask when it pays off.

We characterize Copper, a cooperative read-caching filesystem, against direct Lustre reads on Aurora, measuring PyTorch startup and ResNet-50 dataset loading, cold and warm, from 2 to 2,048 nodes. We find a crossover: as scale grows, Copper's bounded coordination cost overtakes direct reads whose cost climbs with contention. At 2,048 nodes, startup through Copper is ~3× faster cold, ~11× faster warm. Import-torch results are complete; a synthetic file-size guideline is in progress.

The poster presents the crossover and its mechanism, inviting discussion of when cooperative caching should be applied.
Magellan: A Carbon-Aware Task Scheduler for Geo-Distributed Systems
DescriptionMagellan is a decentralized carbon-aware task scheduler that reduces the carbon footprint of long-running, stateful workloads through checkpoint-restart migration across geo-distributed infrastructure. Prior carbon-aware systems have largely relied on simulation and targeted stateless or batch jobs while overlooking the real overheads of wide-area migration.

Magellan addresses these gaps through three primary contributions: a decision engine that jointly balances computational progress, carbon emissions, migration overhead, and monetary cost under an explicit budget cap; a decentralized bidding and destination-arbitration protocol with a checkpoint-restart runtime using CRIU for unmodified processes and native checkpoints for ML and HPC workloads; and validation on CloudLab and Google Cloud under real WAN conditions and measured destination capacity constraints. Across 72 annual scenarios and three workload classes, Magellan reduces lifecycle carbon by up to 92.8% (13×) with 11.6% lower makespan at approximately neutral cost. The poster presents the architecture, migration workflow, decision model, testbeds, and key carbon-cost-performance tradeoffs.
A Fused Computation-Communication Collective for Irregular Distributed-Memory Applications
DescriptionIrregular distributed-memory applications often perform local computation and memory operations around a many-to-many communication exchange. We introduce AllScatterApply (ASAP), a fused collective communication primitive for this pattern. ASAP overlaps local and remote operations at fine granularity, scales to 32,000 CPU cores on NERSC Perlmutter, and delivers up to 74× speedup over point-to-point implementations built on the same one-sided runtime library.

We evaluate ASAP on genomic k-mer counting (KC) and connected components (CC). For KC, ASAP achieves 2×–5× speedup over bulk-synchronous parallel (BSP) baselines and matches the performance of a hand-tuned asynchronous algorithm. For CC, ASAP is 1.8× faster than both optimized BSP and asynchronous baselines. By avoiding expensive graph partitioning, ASAP also achieves 8.8× faster end-to-end performance than a dedicated asynchronous graph-processing system.
Performance Analysis of Inline Compression on Sparse Matrix Vector Multiplication ​
DescriptionSparse matrix vector multiplication (SPMV) plays a critical role in scientific computing. From computational fluid dynamics, to artificial intelligence, to economics problems, the use cases are vast. Additionally, the data required for high performance computing (HPC) jobs is quickly outgrowing available memory storage. In-line compression aims to mitigate this memory bottleneck by keeping data compressed in storage and only decompressing as needed. We analyze the effects of performing this in-line compression with SPMV and apply various optimizations to examine their effects on execution time and the overall memory footprint.
Towards Verifying OpenMP Target Offloading
DescriptionWith the rise of LLM-generated and translated codes alongside the rise of heterogeneous computing, verification of concurrent programming dialects is becoming a necessity. OpenMP is one of those many concurrency dialects with support for heterogeneous computing using their target offloading feature. There is little work formalizing and verifying this feature. Existing work in OpenMP verification does not handle the added complexities that target offloading brings, such as host-device execution semantics and data mapping semantics.

We help address this by developing a formal model for target offloading using an existing verification tool that supports base OpenMP, CIVL. With this formal model, we simulate multiple simple bugs in OpenMP and show that our model can be used to catch these bugs.

The poster presents how the formal model represents OpenMP target offloading semantics and how some simple bugs were simulated and tested.
HV-Coll: Co-Designing Collective Communication with Vectorized Homomorphic Compression
DescriptionInter-node collective communication constrains large-scale scientific simulations and distributed AI. Error-bounded lossy compression can reduce data volume, but prior CPU frameworks underuse memory bandwidth with scalar packing, lose compression ratio (CR) at SIMD-friendly block sizes, and repeat decompress–operate–compress (DOC) work during reductions. We present HV-Coll, which co-designs a block-aligned representation, SIMD encoding, outlier-aware fixed-length encoding, compressed-domain addition, and MPI collective schedules. Evaluated on 3,584 CPU cores, HV-Coll's homomorphic compression is up to 8.1x faster than hZCCL's scalar DOC workflow, and its outlier-aware encoding improves CR by up to 27.2%. HV-Coll collectives reach up to 47.2x, 23.4x, 43.8x, and 67.6x speedups over native MPI for Bcast, Scatter, Allreduce, and Alltoall, respectively.
Hall Pass: Per-Action Authorization for Shared Agents
DescriptionAutonomous agents deployed across federated research infrastructure are most valuable when shared across teams, yet few frameworks provide a way to control who may invoke which of an agent's actions. An owner must choose between keeping a private copy of an expensive agent or exposing one that any caller can use, inspect, or terminate. We examine three models for authorizing calls to a shared agent and prototype the third in the Academy middleware, backing per-action permissions with Globus Groups and enforcing them on the message path. We demonstrate with a shared SAM3 agent on Purdue Anvil.

At the poster we will walk through the three models and where each enforces access, then present overhead measurements and a larger shared-agent deployment on Anvil with results collected after initial submission.
Algebraic Breadth-First Search on the Cerebras Wafer-Scale Engine
DescriptionGraph traversal is memory bound on conventional hardware: irregular access defeats the cache hierarchy. The Cerebras WSE-3 gives each of its 900,000 cores its own 48 KB of SRAM, turning irregular access into local access, but leaves them coordinating over a 2D mesh and a slow host-device link. We present an algebraic BFS that runs entirely on device, avoiding the link that host-callable SpMV kernels would cross every iteration. Sweeping Graph500-specification R-MAT graphs from scale 10 to 20 across PE grids up to 750x750, we find adding cores helps only up to a point, past which larger collectives outweigh the smaller share of work per PE. At that turning point up to 89% of device time goes into collectives, while exporting results costs two orders of magnitude more than the search itself. Within the kernel, distributed on-chip memory removes the memory wall and leaves collective communication as the next target.
Qdislib: Implementation and Evaluation of Circuit Cutting and Sampling Techniques for Quantum Circuits
DescriptionCircuit cutting enables quantum circuits to exceed the qubit limits of current quantum hardware and simulators by partitioning circuits into independently executable fragments. However, different cutting strategies introduce distinct trade-offs in computational overhead, sampling complexity, and reconstruction accuracy. We present a systematic evaluation of the four circuit-cutting techniques implemented in Qdislib, an open-source framework for scalable hybrid quantum–classical execution across CPUs, GPUs, simulators, and QPUs. Our study compares theoretical complexity, reconstruction accuracy, execution time, and distributed scalability, highlighting an optimized wire-cutting implementation that reduces fragment scaling from 8^k to 3^k+4^k and a Hadamard-based gate-cutting method that eliminates mid-circuit measurements while preserving accuracy. The poster will present the Qdislib workflow, implementation details, and experimental results, providing practical guidelines for selecting circuit-cutting strategies on HPC systems and quantum hardware.
Impact of GPU Multistreaming on Task-Based DAG Execution in Dagger.jl
DescriptionTask-graph runtimes like Dagger.jl can now run independent tasks across multiple concurrent GPU streams, raising two questions: how should tasks be assigned to streams, and do more streams improve performance regardless of placement?

We benchmark four policies (round-robin, random, SDQ, and locality-aware) across four DAG topologies (linear, diamond, chainlink, tangled) and four stream counts (1, 2, 8, 32) on an NVIDIA H200 and an AMD MI300A. Every policy speeds up with more streams, but placement matters. At 32 streams, round-robin is fastest, averaging 4.5x speedup on H200 and 2.5x on MI300A, with SDQ close behind on H200 (4.0x). Locality-aware assignment issues 1.6x to 8x fewer synchronization events but reaches only 2.5x and 1.5x, so policy choice alone changes wall-clock time by up to 2.2x.

At the poster, we will walk attendees through the DAG-topology taxonomy and policy comparisons, and discuss which policy suits each workload and hardware backend.
The Cost of Parallelism: A Measured Comparison of Sequential and Systolic INT8 GEMM on an FPGA
DescriptionMatrix multiplication dominates neural-network inference, and hardware designers choose between reusing one multiply-accumulate (MAC) unit over time and instantiating many that run concurrently. That exchange rate is usually assumed rather than measured, and is least favorable at small problem sizes. This work measures it. Two INT8 architectures, a single-MAC baseline and a 4x4 output-stationary systolic array, were implemented in SystemVerilog behind one shared interface and compared on an Intel Cyclone 10 GX FPGA under identical operands, device, tools, and constraint. The array is 7.4x faster in cycles for 16x the DSP blocks and 1.62x the ALMs, with no loss of clock frequency. Per-cycle occupancy explains the sublinear return: the array peaks at 12 of 16 active elements and never fills. The work is complete and validated on silicon. The poster walks through both architectures, the measured tradeoff, and the occupancy analysis, with QR-linked RTL.
QR-Omega: Communication Avoiding 2.5D Householder QR
DescriptionOrthogonalization is a key step in Krylov methods, tensor-network algorithms, least-squares solvers, and emerging machine-learning methods. Householder QR is numerically robust for orthogonalization, but on GPUs its performance is often limited by data movement and synchronization. We present QR-Ω, a hierarchical 2.5D Householder QR formulation that extends hierarchical QR with four execution operations: Split, Replicate, Combine, and Pipeline. These operations control how data is partitioned, replicated, reduced, and overlapped across the GPU memory hierarchy while preserving the Householder elimination order. On an NVIDIA H200, we compare QR-Ω with tuned cuSOLVER, MAGMA, and SLATE implementations in FP64, FP32, TF32, and 3×TF32. Across matrix sizes up to n = 131,072, QR-Ω approaches matrix-multiplication throughput while maintaining small numerical errors in FP64, FP32. Our implementation surpasses the state-of-the-art libraries cited above in performance by up to two times without loss of accuracy, while maintaining advantage in all tested sizes and precisions.
Predictive Modeling of Effective Peak Throughput for Regional In-Network Caching
DescriptionLarge-scale scientific experiments, particularly in high-energy physics, generate massive datasets repeatedly accessed worldwide. Regional in-network caching reduces redundant long-distance transfers through efficient local data sharing. To optimally allocate bandwidth, we must understand and predict peak cache throughput behavior.

We analyzed three years of cache hit and miss throughputs from the Southern California Petabyte-Scale Cache and built a machine learning model to forecast daily peak throughput. We examined three peak metrics: maximum, 99th percentile, and 95th percentile. Each distinctly guides resource allocation, as maximum captures all traffic but wastes capacity, while percentiles cover most traffic at lower bandwidth.

Results show one-day-ahead forecasts closely following demand, but accuracy degrades at longer horizons. Future work includes enhanced long-horizon models and more granular hourly models.

In the poster session, I’ll explain caching, describe peak throughput trends, and discuss results, limitations, and future work from forecasting.
STORM: Scalable One-Sided Communication for Distributed Monte Carlo Particle Transport
DescriptionDomain-decomposed Monte Carlo transport moves particles between MPI ranks as they cross spatial subdomains. Transfers are irregular, bursty, and unpredictable. Existing asynchronous algorithms commonly use matched MPI messages, requiring receiver participation and progress polling.

STORM converts OFI/libfabric one-sided operations into a receiver-passive migration protocol with ordered publication, dynamic buffer growth, and termination accounting. On 2,240–13,440 ranks of Leonardo, STORM retains 88.3% constant global workload scaling efficiency under constant global transport work and more than 97% weak-scaling efficiency, with up to 1.27× speedup over optimized point-to-point MPI. In one three-dimensional Implicit Monte Carlo Hohlraum run, it is 1.41× faster at 4,480 ranks.
Transit-Layer Tensor Representation for Serverless Inference
DescriptionThe scale of frontier machine learning systems has led to an increasing need to efficiently store and transfer model weights. Existing methods for serverless inference employ scheduling policies to reduce cold start and model swapping latency, but have largely reached the limitations of hardware. In this paper, we introduce Condense, an ultra-fast method of compressing tensor weights across applications. We implement Condense in a serverless runtime as a transit-layer representation and evaluate the latency reduction. Across Llama models from 1B to 13B parameters, Condense reduces stored weight sizes by 2.27x-2.38x and improves cold-start loading time by 1.92x-2.17x over ServerlessLLM while retaining competitive downstream accuracy. We demonstrate that compact tensor representations can be generated quickly to provide significant runtime reductions across machine learning applications.
One Page, Two DMAs: Writing 400 GbE TCP Streams to NVMe Without Touching the Data
DescriptionData transfer nodes write wide-area TCP streams to storage. On a 400GbE testbed, the buffered-write path delivers only 138Gbps on a server whose SSDs sustain 453Gbps: cores saturate copying, dirty-page throttling stalls the application, and stalls leak into TCP as window collapse and spurious retransmissions. We present zcp_ingest, which establishes an end-to-end alignment invariant that lets a NIC RX page serve unmodified as a storage write buffer, using only mainline mechanisms. Header-data split plus one TCP_MAXSEG option makes virtually all payload bytes arrive page-aligned; TCP_ZEROCOPY_RECEIVE maps NIC-written pages into userspace; io_uring writes them to NVMe via O_DIRECT — virtually all payload bytes reach storage without CPU copying. With deterministic sender-side placement (SRAP), 16 flows sustain 373.4Gbps — 2.7x the buffered baseline and 97.4% of the path ceiling — with bit-exact terabyte-scale transfers and 4.4x lower CPU cost. Controlled violations establish one-flow-per-queue placement as a prerequisite for fair, drop-free, reproducible operation.
ND-Locate: Localizing Non-Determinism in MPI Applications
DescriptionLarge-scale MPI applications can yield different scientific results from identical inputs due to non-deterministic execution, yet current tools offer little help in pinpointing its source. We present ND-LOCATE, a framework that localizes execution-level non-determinism to application functions, achieving Pearson correlations up to 0.97 on benchmark applications and identifying the code regions responsible for output variability in the production cosmological simulator Enzo.
Measuring Quantum Key Distribution (QKD) Dependability via Wide Area Network Fault Injection
DescriptionHybrid high-performance computing and quantum computing (HPC-QC) systems rely on quantum networks for secure communication, yet their dependability under real-world conditions has not been systematically studied. This work presents a fault injection study of BB84 QKD using QFabric, a quantum-network emulation platform built on the FABRIC testbed. Unlike simulators, QFabric routes classical sifting traffic over a real WAN link, enabling cross-layer fault injection. We find that polarization fidelity, rather than packet loss, determines QBER, with no significant interaction between the two; detector efficiency similarly affects key rate independently of packet loss. However, individual runs at marginal fidelity still exceed the security failure threshold from ordinary variance alone, despite a mean QBER that appears safely below it, while no such failures occur at higher fidelity. This shows that aggregate QBER statistics can mask real per-session security risk, and that cross-layer fault interaction in BB84 depends on the specific physical mechanism involved.
Collaborative Partitioning of Hybrid Quantum–Classical Workloads: Cost-Model-Driven Planning for Tensor-Network/QPU Execution
DescriptionQuantum processors sit beside CPUs and GPUs in HPC centers, yet nothing decides, before execution, which part of a workload belongs where, and on a noisy device that decision needs two currencies at once, wall-clock time and error. We supply the missing layer for matrix-product-state simulation. A computation is partitioned at one bond: the weakly entangled side is contracted exactly, the strongly entangled fragment becomes a single ancilla-free staircase circuit driven by a seam register of fewer qubits, whose sampling cost is bounded by chi^2 /epsilon^2 and adapts to the Schmidt spectrum. A planner prices every candidate: classical time and quantum time from transpiled gate durations, against a four-term error envelope, always retaining a classical fallback, and emits a per-run receipt comparing prediction with measurement. On 64-site Ising chains the envelope covers the realized error on every executed plan, and the planner correctly declines the QPU.
Exploring Tree-Based Approaches for Collective Communications on Cerebras WSE-3
DescriptionCollective operations are a key performance factor on the Cerebras WSE-3, a wafer-scale processor with 900,000 cores on a 2D mesh. At this scale, communication distance strongly affects latency, making locality a first-order concern in the design of collective algorithms.

We develop tree-style schedules that minimize communication distances for 1D Reduce, the building block of 2D collectives and AllReduce. We port Bine trees, the locality-optimized binomial trees we recently introduced, to the WSE-3; implement balanced binary-tree reductions; and introduce unbalanced binary trees as well as two-phase variants with tree-based outer phases. Each schedule is paired with an analytical cost model and implementation-level optimizations such as fused receive-send transports. On the official cycle-accurate simulator, our schedules outperform fixed-pattern state-of-the-art algorithms by up to 1.63x.
Batched GPU Execution for High-Throughput Combinatorial Search
DescriptionSimplifiable strong uniquely solvable puzzles (SUSPs) connect combinatorial search to upper bounds on the matrix-multiplication exponent. The process of evaluating each candidate requires expensive parallel workloads, which have been handled efficiently using GPUs. However, the existing search sent one candidate at a time to a GPU, so allocation, data transfer, and synchronization cost all the benefits of fast evaluation on a GPU. We redesigned the search by batching same-size candidates into one kernel launch. Besides that, we also optimized the workflow by decoupling GPU work from multi-threaded search expansion on the CPU. In our experiments, the single-GPU pipeline raised end-to-end throughput by 3.09–5.75 times, while the double-GPU pipeline could achieve over 11 times. With a new, better search program, we found a new (79, 10)-SUSP, improving on the best width-10 result reported by Anderson and Le.
Segments: A Reusable Sparse-Data Abstraction for Multicore CPUs and GPUs
DescriptionSparse matrices, graphs, numerical meshes, and particle methods differ in semantics, yet repeatedly process collections of variable-length groups such as matrix rows, adjacency lists, incidence relations, and particle neighborhoods. Implementations commonly bind these groups to a particular storage format and hardware-specific execution strategy, forcing traversal, reduction, and scheduling logic to be duplicated across data structures and backends. We present TNL Segments, a reusable C++ abstraction that separates irregular-data semantics from physical representation and parallel execution. Segments provide the mapping (segmentIdx, localIdx) → globalIdx, while application-specific values, column indices, edge weights, and mesh data remain in independent arrays. The same interface supports multicore CPUs, CUDA GPUs, and HIP GPUs.
When More Cores Hurts: The Vector Database Scaling Paradox in HPC
DescriptionVector databases have been designed and optimized for cloud environments; however, emerging scientific AI workloads (e.g., molecular search, meteorological trajectory detection, and literature-driven hypothesis generation) demand efficient, scalable execution on HPC systems. We present a large-scale evaluation of three state-of-the-art vector databases — Qdrant, Milvus, and Weaviate — on two production supercomputers, scaling to 256 distributed workers across 64 compute nodes. We evaluate VDBs using Yandex-T2I, a multimodal embedding dataset, and Pes2o-VE, a novel real-world scientific dataset. Our results reveal that insertion is bottlenecked by per-batch consistency requirements, additional cores can reduce query throughput by up to 30.67%, and scaling from 16 to 256 workers yields a 2.67x improvement with 16 nodes before QPS begins to decline. This scaling paradox exposes the fundamental mismatch between cloud-oriented designs and HPC systems, highlighting the need for new, HPC-aware vector database designs.
A Cloud Accessible Four-Qubit Electron Spin Quantum Processor in a 300 mm Metal-Oxide-Semiconductor Process
DescriptionWe present a cloud accessible electron spin qubit quantum processor manufactured using a 300 mm metal-oxide-semiconductor process. Four single-electron spin qubits form a linear array with controllable nearest-neighbor exchange coupling; the unit cell can be tiled without design modification, providing a direct path to larger processors. The system is installed at the UK's National Quantum Computing Centre, where automated calibration maintains operation with minimal human input and users submit circuits through industry-standard frameworks including Qiskit and Cirq. This deployment is a prototype for future HPC integration.

Single-qubit gates are driven by magnetic resonance; two-qubit CPhase gates use electrically modulated exchange coupling. Single-shot readout via a parallel array of charge sensors achieves fidelities above 99% in under 10 µs and supports mid-circuit measurement.

We demonstrate two applications: a variational quantum eigensolver determining the equilibrium bond length of molecular hydrogen, and stabilizer measurements demonstrating the building block of quantum error correction.
Megabytes in Murmuration: From 8-MB X-Ray Projections to Interpretable TB-Scale Structure Through Automated HPC
DescriptionSynchrotron tomography beamlines routinely produce large sequences of two-dimensional X-ray projection images as their primary experimental output. Individually, these images often provide limited scientific value: the features of interest in biological samples typically emerge only after transformation into three-dimensional reconstructed volumes. This transformation is computationally demanding, requiring sustained high-throughput data transfers, and multiple processing steps — even more so for samples larger than the field of view. We describe the automated data acquisition and processing system implemented at the EMBL P14 beamline at PETRA III, Hamburg, Germany, and the underlying computing architecture that enables the beamline users to inspect interpretable three-dimensional representations of their samples shortly after X-ray exposure.
VisKnacks: Agentic ParaView Visualization on HPC
DescriptionArtificial intelligence can assist in prototyping scientific visualizations. To assist visualization experts, we introduce VisKnacks, an autonomous ParaView visualization agent enabled by large language models (LLMs). VisKnacks integrates multi-agent orchestration, retrieval-augmented generation, and containerized rendering services for high performance computing (HPC) systems while remaining compatible with existing agent harnesses. The system supports hybrid workflows in which ParaView rendering is distributed to HPC resources while pipeline creation and iterative refinement remain local. We present the system overview, initial benchmarks, visualization quality benchmarks, and lessons learned from deploying this system.
Reliable Numeric Fault Detection During Edge TPU Inference
DescriptionDetecting floating-point exceptions during Edge TPU inference is structurally hard: the accelerator has no floating-point unit, and attaching it fuses the mapped partition into one opaque operation whose values never leave the chip, so tensor inspection is impossible there. We instead read the host CPU's floating-point status register before and after each inference, which every floating-point operation in the pipeline sets because all of them execute on the host. Across five stock models, register polling detected 100% of exception-raising faults, tensor scanning 98.8%, and output inspection 24.6%. Polling adds under 1% to latency; the optional tensor scan costs 7% to 58%. Detection holds on the accelerator, where 90% to 99% of tensors become unobservable. The tool also counts int8 saturation, targeting the 72% of output-corrupting faults that raise no exception.
CoEncode: Reclaiming Idle Encoder GPUs in Multi-Tenant Multimodal LLM Serving
DescriptionDisaggregated multimodal LLM serving improves stage isolation but can leave dedicated encoder GPUs substantially underutilized. We present CoEncode, a workload-aware encoder pooling approach that uses model-specific capacity profiles to provision fractional GPU resources and colocate encoder workloads while accounting for end-to-end pipeline conditions. Our evaluation shows that CoEncode maintains comparable end-to-end TTFT SLO attainment while improving SLO goodput perGPU by 19.3% and reducing encoding energy consumption by 45.9%. These results demonstrate the potential of encoder pooling to improve resource and energy efficiency without sacrificing end-to-end serving quality.
Refuse To Guess: A Declared Precondition in a UXarray MCP Server Caught What No Model Checked
DescriptionWe wrapped UXarray, a Python library for unstructured earth meshes, in a Model Context Protocol server so that language models call the library rather than reimplement it. Beyond schema validation, the server declares scientific preconditions that must hold before it computes. We tested what that buys across 480 runs: six mesh-analysis tasks, four interfaces, four models, five trials. One task was rigged to have no honest answer, asking for a remap onto a target grid with zero overlap with the source data. All 60 server-backed runs reported the server’s structured refusal. Writing their own code against the same library, models produced a confident number in 10 of 20 runs and, in all 20, never noted that the target lay outside the data. Across the other five tasks, interface changes were mostly within noise. This is one server and one library, but it isolates a mechanism model capability did not supply.
Event Type
Posters
TimeTuesday, 17 November 202610:00am - 5:00pm CST
Poster Blitz Groups
Poster Blitz
FPGA-Accelerated Simulation of a RISC-V Vector Architecture
DescriptionA profusion of RISC-V-based system-on-chip (SoC) accelerator architectures has emerged in the past few years, fueled by AI and high performance computing. In many of these architectures, the RISC-V CPU serves as a control processor to route data and instructions to specialized IP blocks. Design, implementation, optimization, and validation of such architectures requires modeling and simulation of the integrated SoC at the register transfer level (RTL) in software simulators and FPGA. In this work, we evaluate the performance of a RISC-V scalar core augmented with the ARA2, a multi-lane floating-point vector unit, on workloads that are challenging for software RTL simulation. To accelerate evaluation, we map the RTL design to a low-cost FPGA development board. Here, we implement a heterogeneous system in which an ARM CPU manages benchmark setup, execution, and result collection for the RISC-V system, enabling fast, autonomous performance evaluation of the ARA2 vector processor.
The Unassessed Attack Surface: Channel-Based Provenance in HPC and Quantum-Computing Open-Source Software
DescriptionSoftware trust is negotiated in communication channels such as the README, the registry listing, or the maintainer's account. AI agents now consume these channels directly, and attackers enter through them: the XZ Utils backdoor arrived through a mailing list, the Shai-Hulud worms phished maintainers to compromise 1,000+ npm packages, and in 2026, AI agents repeatedly installed a hallucinated package that never existed. Existing tools assess repositories, builds, and artifacts, but not this layer. We present channel-based provenance, to our knowledge, the first assessment framework for this layer: 18 signals spanning identity and access, communication channels, knowledge infrastructure, and distribution metadata, measured on 87 HPC and quantum-computing projects with a hand-verified 30-project panel. We find near-total provenance blindness; no missing signal requires new infrastructure, so the gap is adoption. The poster walks viewers from attack timeline to framework to per-project results, closing with concrete calls for maintainers, software stacks, and facilities.
SHARD-DB: Scalable Hash-Based Retrieval for High-Throughput Reference Database Construction
DescriptionReference databases tailored to metabarcoding loci are essential for environmental-DNA analysis, but constructing them can require thousands of searches against multi-terabyte nucleotide collections. CRUX-style workflows commonly expand primer-derived sequences using BLAST. SHARD-DB instead performs broad approximate retrieval with densified one-permutation MinHash and locality-sensitive hashing (LSH), followed by targeted locus localization. On a full NCBI NT MiFish workload of 10,292 queries, SHARD-DB completed retrieval and localization in 73:38 using 28.6 GiB peak RSS, while CRUX-style Merged BLAST completed in 52:16 using approximately 407 GB peak RSS. SHARD-DB retrieved 1,606,861 unique candidate accessions versus 133,387 for BLAST, providing a substantially broader reference pool for database construction. Historical matched-subset experiments also showed large SHARD-DB runtime advantages for MarVer3 16S and PR2 18S, demonstrating strong workload-dependent performance.
Event Type
Posters
TimeTuesday, 17 November 202610:00am - 5:00pm CST
Tensor Contractions on AWS Trainium
DescriptionTensor contractions are fundamental across computational science and machine learning, yet reaching high performance on domain-specific accelerators with large systolic arrays, such as AWS Trainium, remains challenging.

We present a compiler that optimizes a binary tensor contraction, given as an einsum equation with axis sizes, and lowers it into a Neuron Kernel Interface (NKI) kernel. The core contribution of the poster is the automatic search: the contraction is lowered to an intermediate representation, and candidate kernel and SBUF tilings are ranked by a measurement-based model of Trainium2's engines. The compiler is evaluated on Trainium2, where the generated kernels reach 155 of 157 TFLOPS on square matrix multiplication and run 2.3 to 2.9 times faster than torch.einsum on four contractions from the TCCG benchmark.

In the poster session we walk visitors through the pipeline, from einsum equation to emitted NKI code, and discuss the tiling decisions behind the results.
Characterizing Scaling Performance of LLM Inference on GPU-Based Supercomputers
DescriptionLarge language models (LLMs) are increasingly important for scientific computing and agentic coding workflows. With growing model sizes, a single node on current-generation HPC systems no longer suffices for LLM inference. Inference must span slower scale-out interconnects and combine different parallelization strategies. This combinatorial space of strategies is large, and each configuration places different demands on the hardware. Which configuration performs best at a given scale, workload, and model architecture remains unclear. To address this, we empirically sweep hundreds of parallel deployment configurations across models and workloads on two leadership-class systems. We analyze scaling trends and find optimal configurations for different workloads and performance metrics, aiming to provide actionable insights for HPC practitioners.
Helios: A Disaggregated MySQL Database That Scales Without Replication
DescriptionModern in-memory transaction engines can outpace a single SQL query processor, but scaling through replicas or shards adds propagation or coordination. Helios is a disaggregated MySQL database that scales query processing without read-serving replicas. Multiple read/write-capable MySQL nodes share one in-memory LineairDB engine, which validates consumed point and range reads and orders commits to provide external consistency. To avoid row-at-a-time RPCs, Helios compiles MySQL's chosen execution plan into a dependent read plan. Embedded DuckDB executes consistent analytical queries over the same PAX layout using epoch cuts and before-images. Our prototype achieves 40.5k transactions/s with four MySQL nodes at 1,024 TPC-C sessions, 3.24x the one-node throughput. On TPC-H SF=10, Helios is 2.20x faster than TiDB with TiFlash and 62.4x faster than MySQL with InnoDB. We present the architecture, consistency mechanisms, and performance results through diagrams and benchmark figures.
Large-Scale Distributed State-Vector Simulation of IQPE for Early-FTQC
DescriptionIterative quantum phase estimation (IQPE) is promising for Early-FTQC because it recycles one ancilla, but classically validating molecular workloads requires distributed state-vector simulation, where qubit reordering and GPU-to-GPU data movement limit scalability.

We present a communication-aware IQPE implementation in chemqulacs-gpu. Building on published Lazy Qubit Reordering for topology-aware mapping reuse, our IQPE-specific contributions are rank-global Z folding that avoids unnecessary reordering, rank-MSB probability evaluation without amplitude gathering, and their integration for systems-scale execution. All components are implemented and evaluated on ABCI-Q. A 32-qubit chlorine workload retains 90.2% parallel efficiency from 2 to 1,024 H100 GPUs, and the widest completed run uses a 41-qubit, 32-TiB complex-FP64 state vector across 1,024 GPUs.

At the poster, circuit and data-movement diagrams will explain the techniques, while scaling plots and a large-run table will support discussion of communication costs, memory limits, and practical IQPE simulation.
Event Type
Posters
TimeTuesday, 17 November 202610:00am - 5:00pm CST
Poster Blitz Groups
Poster Blitz
TEIR: A Tiled Execution IR for Tensor Contractions
DescriptionTensor contractions are core kernels in scientific computing and machine learning. Efficient execution requires hardware-aware tiling and a schedule across cores and over time that depends on the contraction and the microarchitecture. Existing systems search this space with auto-tuning (TVM), optimize it with library heuristics (BLIS, TBLIS), or transpose whole tensors around a GEMM (TTGT). Recent systems expose tiles explicitly, from programming environments (cuTile, Triton-CPU) to tile-based primitives (KleidiAI, CUTLASS, LIBXSMM). We introduce the Tiled Execution Intermediate Representation (TEIR), which explicitly represents what runs (kernels on tiles), when it runs (an execution schedule), and how data is laid out (per-tensor strides and offsets). We implement TEIR as an MLIR dialect whose optimization passes schedule a contraction and lower it to LIBXSMM kernels. Across 24 TCCG contractions on AVX-512, NEON, and SME, TEIR achieves 1.5×–1.9× the geometric-mean throughput of the next-best backends and leads in 54 of 72 cases.
From Millions to Billions: Scaling Explicit Red Blood Cell Modeling on Exascale Systems
DescriptionExplicitly resolving deformable red blood cells (RBCs) at physiological scale remains a fundamental challenge in computational hemodynamics due to high levels of memory, communication, and initialization demands. We present the first explicit billion-scale RBC simulation using HARVEY, a massively-parallel fluid–structure interaction solver characterizing high-fidelity deformable cell simulations. By combining scalable cell packing, distributed data management, and heterogeneous CPU–GPU execution, we initialize and simulate 4.95 billion RBCs within a 1 mL blood volume using 9,400 Frontier nodes (601,600 CPU cores and 75,200 AMD GPUs). The simulation occupies 3.76 PB of CPU memory and 1.44 PB of GPU memory while maintaining approximately 75% weak-scaling efficiency near full-system scale. These results extend explicit RBC modeling from millions to billions of cells and establish the computational foundation for physiologically-scaled cell-resolved blood flow simulations.
Energy-Efficient Coupled Simulations with Dynamic Voltage and Frequency Scaling
DescriptionDynamic inter-solver load imbalance in coupled multiphysics simulations leaves faster solvers idle at synchronization points, wasting energy. We investigate whether dynamic voltage and frequency scaling can exploit this slack without increasing time-to-solution. Our runtime framework combines preCICE for coupling and timing with MERIC for energy monitoring and online CPU-frequency control. A controller based on the Jitter algorithm maps each solver’s active fraction to a target frequency, while an energy model estimates savings from activity, power, and frequency-induced slowdown. We evaluate the method on a partitioned, iteratively coupled 2D air-water heat transfer problem using DUNE on the Barbora and Karolina clusters. On Barbora, total energy-to-solution fell by 13% with negligible runtime overhead, while the faster air solver used 28% less energy. On Karolina, solver runtime is dominated by communication overhead, causing DVFS to unnecessarily slow the simulation and significantly increase energy-to-solution.
A Model‑Agnostic Orchestration Engine for Multi‑Stage High-Performance Scientific Workflows
DescriptionScientific workflows increasingly require the integration of independently developed models and heterogeneous data sources. We present a model-agnostic orchestration engine that represents both data sources and simulation models as producers of named variables. Given a requested target, the engine recursively resolves variable dependencies, derives an executable workflow, manages intermediate products through a shared data layer, and dispatches computation through configurable execution backends. We demonstrate the approach using an asteroid-impact wildfire scenario in which a requested fire-spread product automatically resolves the data required to execute WRF-SFIRE on high-performance computing resources. The prototype demonstrates target-driven workflow generation, dependency resolution, provenance tracking, and intermediate-product reuse, providing a foundation for multi-stage cascading-hazard workflows.
Union of Containers: Layered Software Stacks with Cross-Container Dependency Reuse for HPC
DescriptionHPC software stacks are typically distributed as one container image per accelerator target, and every image duplicates the CPU-generic majority of the stack. This work splits the stack across containers. A shared provider holds the architecture-generic dependencies; thin specialized layers hold only GPU-compiled packages and reuse the provider's builds instead of recompiling them. The layers compose at run time through absolute RPATH entries under fixed paths, with no search-path configuration. With Spack and E4S recipes, each specialized layer compiled 1 of 20 buildable packages at two facilities, Midway3 and NSF ACCESS Anvil. On Anvil, each further GPU target adds 1,412 files where a monolithic build adds 10,772, rebuilding a layer is 1.8 to 2.8 times faster, and application performance is unchanged on A100 and H100 GPUs. The same install trees run unmodified under Apptainer and Charliecloud. The poster also reports four constraints on where reuse holds.
HPC and AI Water Usage: Findings From 11 Leading Supercomputing Centers
DescriptionHigh-density artificial intelligence (AI) and high performance computing (HPC) workloads are increasing thermal loads and making water use an important facility consideration. This study establishes an operational baseline from 11 large HPC facilities using a 35-question survey covering cooling systems, water consumption, WUE, blowdown, water quality, and conservation barriers. Facilities with hybrid/adiabatic cooling report a lower WUE, indicating higher water efficiency among surveyed sites, while evaporative facilities generally reported higher WUE. Cooling-tower blowdown accounted for approximately 15%–33% of facility water use at surveyed evaporative sites. Higher cycles of concentration (CoC) can reduce water use, but water chemistry can limit operation. The study also identified a definite water-energy trade-off, particularly during peak summer conditions. Finally, closed-loop liquid cooling does not necessarily eliminate on-site water use; water consumption depends on the outdoor heat-rejection method.
Bridging the Semantic Gap in Long-Term Agent Memory Retrieval
DescriptionLLM-based agents perform well across many tasks but still struggle with long-term interactions requiring coherence, continuity, and personalization. LLM-based agents often use RAG-style memory systems to retrieve past experiences, but direct query–memory similarity can fail when user queries and fine-grained memories are semantically misaligned. We address this semantic gap with an iterative, anchor-guided retrieval strategy inspired by spreading activation in associative memory. Starting from a small set of seed memories, the method expands through global semantic associations and local temporal neighbors, while a path-aware cross-encoder selects complementary evidence across multiple hops. Retrieved memories are accumulated and reused as anchors for further exploration.
Load Balancing and Communication Bottlenecks in SpMV on the Cerebras WSE-3
DescriptionSpMV is a fundamental kernel in scientific computing, but irregular memory access limits its scalability on conventional parallel systems. The Cerebras CS-3 distributes all data across on-chip SRAM on a two-dimensional PE mesh, so accessing non-local data becomes inter-PE communication rather than a memory-hierarchy traversal. Whether this low-latency advantage is sustained at scale remains unclear.

We present the first execution-time breakdown of SpMV on the CS-3. Our novel contribution is identifying, under load balancing, which component dominates among computation, inter-PE communication, reduction, and synchronization wait. Load balancing achieved a 3.40x speedup for Poisson3Da, while inter-PE communication reached 71.2% of execution time for F1. We evaluate five matrices from the SuiteSparse collection.

At the poster session, we will walk visitors through our execution-time breakdown charts, explain the bottleneck transition using a simple broadcast-round model, and discuss implications for communication-aware SpMV on wafer-scale processors.
OpenEvolve-Driven Selection and Tuning of Ozaki-Scheme GPU Matrix Multiplication
DescriptionOzaki-Scheme is an established numerical method for emulating high-precision GEMM on low-precision GPU hardware. Using it means navigating a costly accuracy/performance tradeoff across algorithm variants and their tuning parameters. This work automates that process with a multi-stage pipeline combining rule-based variant selection with an LLM-driven evolutionary tuner (OpenEvolve). New features include a monotonicity-constrained XGBoost classifier predicting whether an accuracy target is reachable before spending GPU time and a throughput-priority mode trading bounded accuracy for up to 106.6% higher GFLOPS. A per-island-search fix stabilizes OpenEvolve convergence, widening the best-valid range from about 45-50K to 61-108K GFLOPS. In the Quantum ESPRESSO AUSURF112 workload, native cuBLAS remains 1.21x faster than the tuned complex-GEMM configuration, and the pipeline reaches 20.6x native cuBLAS on GB10 versus 1.42x on GH200. At the poster session, we will talk through the pipeline, presenting five result panels: throughput mode, feasibility classifier, OE-search convergence, AUSURF benchmark, and GH200/GB10 hardware comparison.
ParslBox: Computational Materials Workflow Executor for AI Agents on High Performance Computing Systems
DescriptionArtificial intelligence (AI) agents can autonomously construct large computational materials workflows, but executing these adaptive, fine-grained workloads efficiently across diverse high performance computing (HPC) systems remains challenging. We present ParslBox (PBX), a lightweight workflow execution toolkit for computational materials applications on HPC systems. PBX provides a local job database, fine-grained CPU/GPU resource management, portable execution across heterogeneous HPC systems, and command-line, Python, and Model Context Protocol interfaces for both users and AI agents. Scalability was demonstrated on up to 2,000 nodes and 24,000 concurrent workers while maintaining low orchestration overhead. Strong-scaling studies using LAMMPS with MACE models and VASP demonstrated transparent execution of production scientific applications. Agentic benchmarks showed reliable workflow construction across multiple closed-weight and open-weight language models. End-to-end agent-driven generation of machine-learned force fields for molten LiCl-NaCl and LiCl-KCl systems further demonstrated autonomous orchestration of complex multi-stage HPC workflows.
Understanding AllReduce Performance Through Hardware Telemetry
DescriptionInter-GPU AllReduce operations traverse several tightly coupled hardware components, including the GPU, PCIe interface, NIC, and network. Each component exposes hardware telemetry for its local behavior, and no single telemetry source observes the complete communication path. A combined view is therefore needed to narrow where performance is limited and to guide optimization. We combine selected NVIDIA A100 GPU counters with Cassini NIC counters on HPE Slingshot-11 to analyze a 1 GiB inter-node AllReduce across NCCL protocols, NCCL channel counts, and GPU-aware MPI versus NCCL. Across the three studies, the joint telemetry associates performance differences with distinct behaviors: work amplification for NCCL LL, increased synchronization and reduced transfer progress at high channel counts, and slow transfer progress with additional rank imbalance for MPI. Joint GPU–NIC telemetry therefore helps distinguish different sources of AllReduce slowdown and narrows where optimization effort should be focused.
Fully GPU-Accelerated Distributed Full Configuration Interaction Beyond Trillion-Determinant Scale
DescriptionFull configuration interaction (FCI) provides exact reference energies for benchmarking approximate quantum chemistry methods including emerging quantum algorithms, but its applicability is severely limited by exponential computational and memory requirements. To enable practical large-scale FCI calculations, we present a fully GPU-accelerated distributed implementation that combines chunk-based determinant partitioning, a hybrid GPU–CPU memory scheme, and GPU-native communication using NVIDIA NCCL. The proposed implementation computes the fully converged ground-state energy of NH2OH/6-31G with 1.7 trillion determinants in 13.4 hours and demonstrates execution of C2H4/6-31G with 2.4 trillion determinants, representing the largest determinant space reported to date for an uncompressed FCI implementation. It scales efficiently on up to 1,024 GPUs, and achieves up to a 58× speedup over our previous CPU-based implementation. These results establish the practicality of trillion-determinant FCI calculations on modern GPU clusters and provide large-scale exact benchmark data for validating approximate quantum chemistry methods.
Trustworthy Agentic AI for HPC Operational and Predictive Data Analytics and Forecasting
DescriptionLarge 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.
Kamo: Bringing Many-Core Scalability to MySQL
DescriptionMySQL’s SQL ecosystem is widely used, but its default InnoDB storage engine does not scale well under high concurrency. Kamo is a prototype DBMS built on MySQL that substantially extends the initial LineairDB storage-engine integration. Our contributions include named tables, relational insert/update/delete semantics, secondary and composite indexes, ordered scans, and broader MySQL handler coverage sufficient to execute all five BenchBase TPC-C transaction classes. The current prototype has been implemented and evaluated on single-node and semi-synchronously replicated configurations, reaching up to 18.7× the request throughput of MySQL/InnoDB under the evaluated settings.

In the poster session, we will present Kamo’s system architecture, the key relational and MySQL-integration extensions, and end-to-end TPC-C and YCSB-A results. We will also discuss the observed scaling behavior, current bottlenecks, and limitations of the prototype.
Event Type
Posters
TimeTuesday, 17 November 202610:00am - 5:00pm CST
Tensor Compilers for AI and HPC
DescriptionThe recent developments in AI have prompted an interest in tensor compilers, but their use is not universal and often they are coupled with hand optimized kernels in real deployments. In this work, we dive deep into tensor compilers and adjacent systems to build a holistic systems understanding of tensor program optimization. We define our own tensor operator taxonomy. Using a modern GPU as an example, we condense GPU kernel optimization into two principles, from which many optimization techniques emerge. Using the PyTorch 2.0 compiler backend, TorchInductor, and the Triton compiler as examples, we explain in detail what intermediate representations and optimization techniques are used during the compilation process. We find that kernel fusion is the most consequential optimization. In the end, we are able to understand the value proposition of tensor compilers, the type of optimizations they apply, their limitations and how they can be used effectively and augmented.
OptimasX: An Agentic End-to-End GPU Performance Optimization Workflow in the Code Editor
DescriptionOptimizing a GPU kernel costs 30 manual steps before code changes: pick a profiler, reach a remote system, submit a job, read the report. Domain scientists hold the most GPU hours and the least profiling expertise, so no one tunes the code with the most to gain. OPTIMAS removes two steps by guiding a language model with runtime evidence, but assumes the user can produce it. We transformed OPTIMAS into OPTIMASX, a multi-agentic system that produces the evidence and removes all 32 steps. From a VS Code extension, OPTIMASX profiles code, reads evidence, proposes changes, checks correctness, and measures runtime. The extension holds workflow state, so a queued job or backend restart cannot end the session. On an A100, OPTIMASX reached 4.80× on XSBench and 1.19× on Sobol with bit-identical output, and extends to Cholla and eight HeCBench apps. The speedups are OPTIMAS’s, and the end-to-end automation is ours.
Faster Biobank-Scale Genomics Through Sparse Linear Algebra on Genotype Representation Graph
DescriptionBiobank initiatives include half a million phased genomes, outpacing the tools available to analyze them. Conventional genotype formats treat variants independently and fail to exploit the shared ancestry structure underlying population genetic variation. Prior work introduced the genotype representation graph, a compact graph encoding that captures shared ancestry directly but relies on traversal algorithms that map poorly onto modern accelerators. Here, we show that this computation can be expressed exactly as sparse linear algebra: under a topological ordering, the graph’s adjacency matrix becomes strictly block triangular, so the core genotype matrix–vector product reduces to a block sparse triangular solve. Further, we decompose this solve into a pipelined sequence of blocked sparse matrix-vector multiplications, exposing fine-grained parallelism and enabling mature, hardware-optimized primitives in place of hand-tuned kernels. The result is substantial, portable speedups across accelerator hardware, from cloud deployments to supercomputers.
Chemically Accurate End-to-End Classical Simulation of Qubitization-Based Quantum Phase Estimation on 1,024 GPUs
DescriptionQubitization-based quantum phase estimation (QPE) is a core algorithm for fault-tolerant quantum computing (FTQC), and molecular ground-state energies are among its most promising applications. Resource estimates predict the qubits and gates required, while end-to-end simulation directly tests whether the resulting circuits achieve the target accuracy; yet a naive chemical-accuracy H4 circuit needs 99 qubits and 1.78 billion gates. We combine established qubit- and gate-reduction techniques with distributed state-vector simulation using our prior communication optimizations for hierarchical GPU interconnects, on ABCI-Q's 1,024 NVIDIA H100 GPUs. The H4 circuit shrinks to 28 qubits and 0.32 billion gates, runs in 1.5 hours, and yields a one-million-shot measurement distribution whose peak lies 0.53 milli-Hartree from the exact full configuration interaction (FCI) energy, within chemical accuracy. These runs check, at small scale, that estimated resources deliver the target accuracy. The poster also presents each reduction stage's effect, strong scaling, and remaining bottlenecks.
CADI: Semi-Automatic Insertion of Host-Device Data Transfer Directives Based on Code Analysis
DescriptionIn heterogeneous computing using directive-based parallel programming models such as OpenACC, programmers typically need to explicitly specify host-device data transfer directives, increasing programming effort. Existing automatic approaches may introduce runtime overhead that can degrade performance. To reduce programming effort while preserving opportunities for performance optimization, we propose a semi-automatic approach that combines static code analysis with runtime memory tracking while allowing programmers to specify transfer directions. Based on this approach, we present CADI (Code Analysis-based Data-transfer directive Insertion), a foundation for semi-automatically inserting data transfer directives. CADI automatically determines the base address and transfer size required for each directive, while the programmer specifies the transfer direction to retain control over performance-related data movement. CADI achieved execution performance comparable to manually optimized implementations on the Himeno benchmark, indicating minimal runtime overhead. The poster presents the design of CADI, its code analysis and runtime mechanisms, and experimental results.
Field-Preserving Gaussian Splatting for Interactive Visualization of Large-Scale Cosmological Simulations
DescriptionLarge-scale cosmological simulations generate hundreds of millions of particles, making interactive visualization computationally expensive. Gaussian mixture models (GMMs) provide an efficient compressed representation of particle datasets, but existing GMM-based renderers incur additional computational overhead from depth-plane sampling and alpha compositing, while Gaussian splatting methods are designed for photorealistic rendering rather than scientific visualization. We present a field-preserving Gaussian splatting framework that combines GMM compression with orthographic projection and GPU tile-based rasterization to reconstruct additive particle density and continuous scalar attributes directly from compressed Gaussian representations. Built on the gsplat framework, the proposed renderer executes entirely on the GPU for interactive visualization. Experiments on the Illustris-3 (94,196,375 particles) and HACC cosmological simulations (331,644,184 particles) achieve density PSNRs of 43.27 dB and 46.07 dB, respectively, while sustaining up to 92 FPS on an NVIDIA RTX A6000 GPU.
A-OASIS: Building an AI-Coupled Atmosphere-Ocean Foundation Model
DescriptionU.S. Department of Energy (DOE) water-for-energy planning requires predictions of precipitation and hydroclimate variability from weeks to years, yet these horizons depend on coupled atmosphere-ocean-land feedback that are difficult to learn from observations. Established dynamical Earth system models and explicit couplers remain the scientific reference, but producing long simulations and forecast ensembles is computationally intensive. This work in progress asks a bounded question: after careful, domain-guided data harmonization, how much of the coupling workflow can a unified AI foundation model learn directly, and where does that strategy become limited? We present the Atmosphere-Ocean Artificial System for Integrated Simulation (A-OASIS), an Aurora-derived model that jointly encodes atmosphere, ocean, and land states in one latent space rather than training and coupling separate emulators. Initial experiments demonstrate stable full resolution distributed training and decreasing validation loss with increased model capacity. These results establish implementation feasibility, driving the next step of validating forecast capability.
Skyway My Way! InfiniBand to Ethernet Optimization and Benchmarking
DescriptionModern high performance computing and AI/ML workloads increasingly require efficient bridges between InfiniBand compute fabrics and Ethernet storage systems to enable large data transfer capabilities. The NVIDIA Skyway is a gateway device designed to translate IPoIB (Internet Protocol over InfiniBand) for external Ethernet services. This work seeks to evaluate and optimize the Skyway by benchmarking bandwidth performance, validating multi-tenant partition security boundaries, and identifying optimal deployment strategies for HPC workloads. Testing is performed on a nine-node cluster with an InfiniBand, Ethernet, and Skyway switch. A modified version of GPCNeT is used to measure cluster bandwidth under congestion. NFS performance is benchmarked within both the Ethernet network and across the Skyway. Finally, the network is partitioned to separate traffic of two controller nodes, emulating a secure user compute system. Our experimentation paves the way for Skyway implementation on production clusters, providing insight on hashing and storage I/O improvements for future work.
Analyzing the Impact of Architectural Design Decisions on Performance Across Generations of NVIDIA GPUs
DescriptionThe high performance computing (HPC) industry is moving past an era in which each new generation of devices provided uniform performance improvements across all workloads. In this work, we profile a diverse suite of applications across multiple generations of NVIDIA HPC GPUs to evaluate how architectural design decisions translate into real-world application performance, in terms of speedup and energy efficiency. The suite of applications was hand-picked to represent the modern HPC landscape; it covers scientific computing, AI inference, AI training, and targeted microbenchmarks. GPU-level performance counters, execution time, power, and energy measurements were collected and analyzed to identify which architectural improvements provide the greatest benefit, which are less impactful, and what workload characteristics determine their effectiveness. Relative to the increase in transistor count, the data exhibits significant performance gains among Tensor Core bound applications, expected gains in memory-bound applications and below-expected gains in vector throughput-bound applications.​
Benchmarking AI Vector Databases for Genesis Mission
DescriptionIn support of the Genesis Mission, the U.S. government's national AI initiative, Circe is an HPC-hosted AI service environment that supports model access, custom knowledge databases, and external tool integration. A central feature of Circe is effective retrieval-augmented generation (RAG), which requires streamlined vector databases. This work aims to identify and recommend the best-performing vector database backend for Circe's RAG services, promoting efficient and accurate query retrieval at scale.

We benchmarked five databases—Qdrant, Redis, Weaviate, ChromaDB, and Elasticsearch—using Qdrant's vector-db-benchmark framework, comparing their scalability, query speed, latency, and retrieval accuracy across three configurations. Redis achieved the strongest baseline performance, with Weaviate following closely behind. With tuning, Weaviate reached the highest throughput (3,002.3 requests per second), while Qdrant demonstrated the largest proportional improvement (620.0 to 1,504.3 requests per second). We conclude that Weaviate is the strongest candidate for maximum query speed, while Qdrant offers the greatest flexibility for tuning.
Adaptive Orchestration of Heterogeneous LLMs with Dynamic Escalation for Multi-Agent Collaboration
DescriptionLLM-based multi-agent systems offer strong reasoning capabilities but often incur substantial computational and operational costs. This work presents an adaptive two-orchestrator framework for coordinating heterogeneous small and large LLMs. Orchestrator-1 (O-1) determines the initial number of expert agents and model tier using task-level risk signals. The primary adaptive component, Orchestrator-2 (O-2) evaluates multiple round-level signals using a heuristic approach and selectively escalates only when the current model configuration is deemed insufficient. After evaluation across various benchmarks using models deployed with vLLM we found that compared with the Large-only configuration, the Small + Large configuration improved accuracy by 0.51–6.67 percentage points, reduced average cost per task by 15.99%–33.65%, and decreased execution time by 8.1%–18.06%. Only 0.10%–3.60% of tasks required escalation, demonstrating the effectiveness of O-2’s signal-driven decision mechanism. These results validate that dynamic escalation can preserve or improve performance while reducing unnecessary use of Larger models.
Performance-Portable GPU Acceleration of the Hybrid PIC Code dHybridR
DescriptionHybrid particle-in-cell simulations are widely used to study kinetic processes in collisionless astrophysical and space plasmas, yet the high cost of large-scale three-dimensional runs has largely confined production studies to two dimensions or restricted domains. To address this challenge, we present a performance-portable GPU implementation of the hybrid particle-in-cell code dHybridR. It combines OpenMP target offloading with specialized SYCL kernels for the most expensive operations in a unified CPU-GPU codebase for Intel, AMD, and NVIDIA GPUs. On the exascale supercomputers Aurora and Frontier, dHybridR achieves weak scaling efficiencies of 86%–97% at 49,152 accelerators on each machine, and at 256 particles per cell, its full-node GPU throughput is up to 32x that of the vectorized CPU implementation at approximately 90% less energy per particle-update. To our knowledge, no other hybrid particle-in-cell code has reported GPU performance at this scale. These advances lower the barrier to large-scale three-dimensional hybrid-kinetic simulations.
Structure-Aware Linear Solvers for Matrix-Free High-Order Finite-Element Simulations on GPUs
DescriptionHigher-order finite-element simulations solve the same Poisson and shifted-Helmholtz systems repeatedly, and preconditioned conjugate gradient (PCG) needs iterations that climb with polynomial order and mesh grading, each ending in a latency-bound global reduction. We present two GPU solvers selected from the structure the mesh and the operator retain. On tensor-product meshes, an exact fast-diagonalization inverse needs one apply and no iterations. It is 138 to 4,570 times faster than converged Chebyshev-Jacobi PCG and 14 to 140 times faster than our own p-multigrid solve on uniform meshes. Where that structure is gone, a device-resident Chebyshev-Jacobi p-multigrid preconditioner converges in five to seven iterations against 106 to 668 for Jacobi PCG. Both are measured in DFT-FE on up to 128 A100 GPUs and 1,024 MI250X GCDs. This is unpublished work in preparation. The poster walks from the problem through the choice of solver to the measured gains and limits of each.
Accelerating Materials Discovery with ADAM: An AI Co-Pilot for Physical Experimentation
DescriptionThe rapid discovery of new materials for energy storage, advanced computing, and other technologies requires us to remake scientific experimentation beyond the limits of human cognition and manual interaction. Most existing autonomous experimentation relies on deterministic scripts or narrowly-scoped post-hoc machine learning. Large language models offer a fundamentally different capability, in the form of generalized reasoning from natural language goals, but we must still address safe LLM reasoning with real-time instrument feedback in a closed-loop workflow. Here we present ADAM, a multi-agent large language model framework integrating a retrieval augmented generation pipeline grounded in internal documentation, a validated instrument tool registry, and human-in-the-loop oversight positioned at semantic reversibility boundaries. By inferring these boundaries from natural language rather than hard-coded rules, ADAM achieves high autonomy in routine experiments and applies precise human oversight only when needed. We demonstrate this system in two materials characterization and processings examples.
Proposal of a Transparent Dynamic Core Allocation Method for MPI/OpenMP Hybrid Parallelization
DescriptionLoad balancing is essential for maximizing performance and energy efficiency in MPI/OpenMP hybrid applications on supercomputers. While dynamic core binding (DCB) mitigates process-level imbalances by dynamically binding CPU cores, conventional methods require manual source code modifications. We propose a fully transparent DCB method eliminating user-level code alterations. By leveraging OpenMP Tools (OMPT) and Profiling MPI (PMPI) via a dynamically linked shared library, our method automatically intercepts computation phases and calculates load parameters from actual computation time by subtracting MPI wait time from the execution time of OpenMP parallel regions.

Evaluations on the Miyabi-C supercomputer using a Lattice H-matrix application demonstrate up to a 1.54x speedup and 32.0% energy reduction on a single node. Furthermore, 16-node tests demonstrate performance and energy benefits at scale.

Our poster will feature architectural diagrams of the OMPT/PMPI integration and performance graphs comparing static mapping, conventional DCB, and our transparent approach.
Extending I/O Observability to Explainability for Targeted Optimization
DescriptionHPC I/O profilers such as Darshan report POSIX-level metrics but do not trace the kernel stack: VFS, page cache, block layer, NVMe driver, and storage media. We present PEARL, an eBPF-based cross-layer tracing plugin for DataCrumbs, that builds one causal timeline per request from syscall to disk completion. We evaluate PEARL on Chameleon Cloud with IOR workloads. Page-cache faults account for 82% to 93% of kernel I/O time, a signal Darshan cannot capture. PEARL traces the same requests at 9.0 to 15.7 microseconds where Darshan reports 0.45 to 5.88 milliseconds. Overhead is negligible and within system noise. PEARL moves profiling from reporting what happened to explaining why, enabling targeted evidence-based optimization.
ToolFuse: Provenance-Aware In-Flight Coalescing of Redundant Agent Tool Calls
DescriptionScientific workflows increasingly run as fleets of LLM agents analyzing immutable datasets. Independent agents can issue equivalent expensive read-only tool calls simultaneously, before a completed-result cache has anything to reuse. ToolFuse addresses this cold-wave gap by coalescing active calls at a gateway between agents and tool handlers. Its contribution is a provenance-aware execution identity that establishes equivalence from versioned dependencies and execution context, rather than arguments alone. Under contention on an exclusive HPC node, 16 equivalent requests become one execution, reducing CPU time by 11.79× and makespan by 2.36×. Peak memory growth falls from 6.44 GiB to 0.53 GiB. Trace replay shows that sharing depends on call duration and arrival timing. For cheap calls, coalescing remains inactive with negligible overhead.
Continental-Scale, High-Order, High Spatial-Resolution Ice Flow Modeling Based on Graphics Processing Units (GPUs)
DescriptionSolving time-independent stress-balance equations to predict ice velocity is the most computationally demanding part of ice-sheet simulations, both for memory and execution time. In this study, we develop numerical algorithms that use the parallel processing power of graphics processing units (GPUs) and implement them in the Ice-sheet and Sea-level System Model (ISSM) three-dimensional (3-D) Blatter-Pattyn higher-order (HO) module. Our setups are based on the ISSM Antarctic model from the Ice Sheet Model Intercomparison for CMIP6 (ISMIP6), with about 10^7 degrees of freedom (DoFs), and a higher-resolution version with about 10^8 DoFs. We compare the GPU-accelerated 3-D HO ISSM stress balance module to the standard CPU-based version. We evaluate predictive accuracy, computational efficiency, and robustness. The poster will present the science question being investigated in this study, the methodology, results, and implications of the findings, and will outline future research objectives.
FBench: A Flexible Benchmark for CFG-Based What-If Exploration of HPC I/O Patterns
DescriptionThe I/O performance of large-scale HPC applications depends on a complex interplay of access patterns, middleware optimizations, and file system configurations. To explore these effects without rerunning full applications, we introduce FBench, a flexible, code-transparent benchmark for what-if analysis. FBench leverages context-free grammars (CFGs) derived from Recorder traces to either generate a simplified global configuration file or replay I/O patterns on-the-fly without preprocessing. It supports POSIX and MPI-IO and injects optimization hints via JSON. FBench reproduces IOR's scaling within 6.9%, captures the irregular file-per-process pattern of HACC-IO, and reveals a 30% collective/independent gap on Lustre that striping cannot close.
Event Type
Posters
TimeTuesday, 17 November 202610:00am - 5:00pm CST
JUNIQ Benchmark Suite: A Decade of Application Benchmarks on Quantum Computers
DescriptionAs quantum computing hardware rapidly evolves, traditional metrics like gate fidelity and Quantum Volume are insufficient for predicting real-world utility. Researchers and industry users need objective, application-centric benchmarks to gauge when quantum processors will be ready for practical tasks. However, the lack of standardized infrastructure often leads to non-reproducible performance claims and makes it difficult to track progress across different hardware generations and technologies.

We present the JUNIQ Benchmark Suite (JBS), a large collection of benchmark problems and a vendor-agnostic, open-source initiative designed to track quantum technology readiness over decades. Unlike suites focused on synthetic benchmarks, JBS (https://go.fzj.de/juniq-benchmark-suite-page) emphasizes application-domains including computational biology, logistics, and hardware-diagnostics.

JBS hosts an extensive repository of empirical performance data collected over more than a decade (2016–2026) across over 30 analog and digital quantum processing units, tracking quantum technology readiness over successive hardware generations.
Evaluating All-Reduce Operations in DDP Training with FABRIC: Framework for Architecture, Backend, and Reduction Interchange Comparison
DescriptionDistributed deep learning increasingly relies on large GPU systems, where distributed data parallel (DDP) training replicates models across devices and synchronizes gradients each step. As model sizes and GPU counts grow, gradient synchronization becomes a major overhead. Although many optimized all-reduce algorithms exist, they are often embedded in different communication libraries or stack layers, making controlled comparison in full training workflows difficult. We present FABRIC (Framework for Architecture, Backend, and Reduction Interchange Comparison), an open-source, portable, and extensible framework for evaluating PyTorch DDP across communication backends and collective strategies. Using DDP communication hooks, FABRIC integrates alternative all-reduce algorithms without modifying PyTorch internals or training code, enabling reproducible comparisons across models, datasets, and backends including MPI, NCCL, and RCCL, and letting researchers add and benchmark custom communication methods. Experiments on Frontier and Polaris reveal meaningful performance differences among synchronization strategies. The poster presents FABRIC's architecture, extensibility, and productivity, and current results.
A Viskores-Enhanced Vision Transformer Framework for MRI-Based Cancer Image Classification on Frontier
DescriptionHigh performance computing (HPC) enables workflows that integrate scientific visualization and artificial intelligence to accelerate scientific discovery. This work investigates the integration of Viskores, a performance-portable visualization framework, into a Vision Transformer (ViT)-based MRI classification pipeline executed on the Frontier supercomputer. Instead of training directly on raw magnetic resonance imaging (MRI) data, our approach generates visualization-derived feature representations using Viskores operations, including median filtering, Sobel gradients, Laplacian filtering, texture extraction, Otsu thresholding, and morphological processing. We evaluate these representations on a four-class brain tumor MRI dataset containing 7,200 images and compare them with a conventional raw-image ViT baseline. The best-performing visualization-enhanced pipeline improves classification accuracy from 91.94% to 95.50%. The poster presents the end-to-end HPC workflow, performance comparison, and an ablation study, demonstrating the potential of integrating scientific visualization and AI within scalable, reproducible workflows for medical imaging applications.
Building an HPC User Documentation Process Via Layers of Writing Infrastructure
DescriptionWe are technical communication scholars working as guest faculty researchers at Argonne Leadership Computing Facility (ALCF) at Argonne National Laboratory in Lemont, IL. We research documentation processes for high performance computing (HPC). We are building an applied theory of writing infrastructure to model these processes. Building and maintaining user documentation that is responsive to changing user needs and technologies for complex computing systems, such as the exascale machine Aurora, is challenging. It is a whole-facility endeavor that depends on layers of writing infrastructure that are built incrementally over time. This poster builds on our model of the documentation process for the supercomputer Aurora. It traces the timeline of building the layers of writing infrastructure, such as cross-cutting committees, networked communication tools and diverse document types, to illustrate how the process was implemented. Takeaways include the importance of a collaborative culture for documentation and a metric-driven culture of continuous improvement.
A Physics-Informed AI Architecture for One-Dimensional Turbulence Modeling
DescriptionOne-dimensional turbulence (ODT) represents turbulent flow on a one-dimensional domain through continuous molecular diffusion and stochastic triplet-map eddy events. This work examines what a deterministic machine-learning surrogate can learn from such a stochastic system. Fourier neural operators trained on individual ODT realizations converge toward ensemble-mean dynamics because future eddy events cannot be inferred uniquely from the instantaneous flow state. Training directly on ensemble averages confirms accurate interpolation across unseen jet velocities and widths, with more than 300× speedup relative to generating the corresponding ensembles. We therefore propose a hybrid physics-informed architecture that mirrors the ODT solver: a neural operator advances the continuous diffusion dynamics, while stochastic triplet-map events are applied explicitly. Using the same eddy sequence, the hybrid model reconstructs individual realizations with a final relative L2 error of 0.028 and approximately 9× faster rollout than the original solver. This decomposition provides a practical framework for learning stochastic turbulence models.
GNNs Beyond HBM: Compressed, Bit-Exact Feature Streaming for Out-of-Core Training
DescriptionGraph neural networks increasingly train on node-feature matrices that exceed GPU high-bandwidth memory: ogbn-papers100M's is ~57 GB, beyond a commodity 8-40 GB card. Out-of-core systems (GIDS, Ginex, MariusGNN, GraphBolt, HMGraph) already stream features from host memory past HBM, but always uncompressed. GnnPress compresses the streamed feature store: it exposes an ordinary float array to the GNN while storing features compressed and materializing only a small, double-buffered resident window. On an NVIDIA A100-40GB, GnnPress trains ogbn-papers100M (52.9 GiB), which out-of-memories an in-core layout. A lossless zstd codec is bit-identical to the in-core run every epoch (max|dloss|=|dacc|=0), including under mini-batch SGD; a GPU-native lossy codec, cuSZp, reaches 3.13x while perturbing training loss by at most 1e-6 over 30 epochs. Mini-batch SGD reaches 61% accuracy at a measured 1.7 GiB peak GPU (31x below in-core). Compressing the feature stream, not merely avoiding OOM, distinguishes GnnPress from prior uncompressed out-of-core GNN training.
BFS-FAR: Fragmented Asynchronous Breadth-First Search on UPMEM Processing-in-Memory
DescriptionBreadth-first search (BFS) is difficult to accelerate because of irregular memory access, low work per edge, and frequent synchronization. On UPMEM Processing-in-Memory systems, DPUs cannot communicate directly, so existing PIM-BFS designs rely heavily on host-mediated frontier exchange.

We present BFS-FAR, a completed fragmented BFS design that combines locally asynchronous relaxation within each DPU with host-side minimum-level reconciliation. Its key contribution is allowing improved levels to be reused within the same DPU launch, reducing repeated global frontier exchange and host coordination. Experiments using up to 2,540 DPUs cover R-MAT graphs with approximately 262K–4.2M vertices and 4.2M–67.1M directed edges, and controlled-size synthetic graphs ranging from 200K vertices and 10M edges to 13.6M vertices and 730M edges. BFS-FAR achieves 18.0×–86.5× algorithm-only speedup over UPMEM baseline, PrIM-BFS.

The poster will present the BFS-FAR workflow, performance results, timing breakdowns, DPU scaling, and the effects of locality and workload balance.
Pumped Two-Phase Cooling for the Next-Gen Chips with Heat Flux Over 4 W/mm2
DescriptionPumped two-phase cooling is a promising solution for the increasing heat flux of next-generation GPUs. This study presents a pumped two-phase cooling distribution unit (CDU) and loop architecture and compares the thermal performance of a two-phase cold plate with the same design operating with PG25 coolant. Test results show that the two-phase cold plate can dissipate over 3500 W, while both refrigerant and PG25 cooling can meet the projected thermal requirements of future GPUs with average heat flux above 1 W/mm² and hotspot heat flux above 3 W/mm². Although cooling performance is ultimately limited by fluid thermophysical properties and flow conditions, the thermal challenges of upcoming GPU generations remain manageable. Future work will investigate alternative cold plate materials and thermal conductivity optimization to further enhance cooling performance.
A Taxonomy of Application Properties for Mixed-Precision Autotuning
DescriptionModern HPC platforms increasingly rely on reduced-precision hardware for performance and energy efficiency, but many scientific applications still default to FP64. Although parts of these applications may tolerate lower precision, identifying safe and profitable precision reductions remains difficult. Tool-based mixed-precision autotuners help automate this task, yet their success varies widely across applications. Existing work focuses mainly on autotuning tools rather than application suitability.

We present a completed application-centric study of the properties that make mixed-precision autotuning feasible, costly, fragile, or beneficial. Our novel contribution is a taxonomy that organizes these properties into structural, behavioral, numerical/domain, and performance/architectural categories, maps them to autotuning workflow costs, and expresses them as decision gates for readiness assessment.

In the poster session, we will present the framework using visual summaries and examples to discuss tool assumptions, benchmark design, and practical adoption.
DPGraph: Code Optimization with Dynamic Program Graphs Using Heterogeneous GNNs
DescriptionHeterogeneous high-performance computing systems require selecting suitable devices (e.g., CPU or GPU) and optimization parameters such as vectorization and interleave factors. Existing LLVM-IR-based program representations mostly rely on static information and may miss runtime behavior important for performance optimization. We propose DPGraph, an execution-flow-aware program graph representation that augments fine-grained LLVM-IR-based program representations with dynamic data dependencies to better capture runtime program behavior and identify effective optimization configurations. We evaluate DPGraph on vectorization and interleave factor prediction, CPU/GPU parallelism detection, and optimal loop-order prediction tasks. Across these tasks, DPGraph achieves around 13.6%, 7.06%, and 7.05% higher performance gains than state-of-the-art approaches, respectively. DPGraph is also data- and compute-efficient: it achieves 13.6% better speedup than MIREncoder while using over 40X fewer training samples and reduces training time by about 86% for CPU/GPU configuration prediction compared to state-of-the-art method ConTraPh.
AI for Quantum at the Quantum Science Center: Towards Building a Connective Layer Across the Quantum Computing Stack
DescriptionWe present the AI for Quantum efforts of the Agentic Software team at the Quantum Science Center (QSC), Oak Ridge National Laboratory, advancing a unifying thesis: that artificial intelligence can serve as the connective and accelerating substrate of the quantum computing stack. Our portfolio spans three axes. For **knowledge infrastructure**, Quantum RAG grounds frontier models in curated quantum corpora, and the Quantum Computing LLMWiki provides a machine-readable knowledge resource. For **evaluation**, the Quantum Computing Benchmark Leaderboard rigorously benchmarks frontier models on quantum code generation, coupled with a hard benchmark and shared-task problems developed for IEEE Quantum Week (QCE). For **domain reasoning and systems**, ChatQEC, FTQEC, and hardware-aware error correction lower the barrier to reasoning about codes and decoders under realistic device constraints, while a multi-agent framework decomposes quantum-HPC workflows across specialized agents. We further extend EPIC toward quantum-HPC co-execution, integrating these capabilities into a unified orchestration substrate.
A Hybrid Quantum-Classical Framework for Solving Computational Fluid Dynamics and Nuclear Physics Equations Using Quantum Singular Value Decomposition and Transformation
DescriptionQuantum computing offers a great promise to significantly reduce the computational cost of solving multidimensional partial differential equations (PDEs). However, existing quantum linear solvers, such as the Harrow–Hassidim–Lloyd (HHL) algorithm, exhibit limited scalability, prolonged execution times, and low accuracy. We propose a hybrid quantum-classical framework comprising two quantum PDE solvers based on quantum singular value decomposition (QSVD) and quantum singular value transformation (QSVT). The proposed methodology is validated on PDEs from computational fluid dynamics and nuclear engineering — potential flow past a 2D cylinder and a Joukowsky airfoil, and the neutron transport equation (NTE) — using noise-free and noisy simulators and hardware emulators from IBM-Quantum. The results demonstrate the feasibility of the proposed methods.
Automated Isolation of Vulnerable Workloads
DescriptionKubernetes and OpenShift support scientific services, data platforms, and artificial-intelligence workflows at high performance computing facilities. Red Hat Advanced Cluster Security (RHACS/StackRox) identifies vulnerable images, policy violations, and risky deployments, but operators still must interpret risk and coordinate containment. That handoff is slow; immediate deny-all isolation can interrupt shared services before owners remediate. We present an automated, risk-based system that converts RHACS findings into controlled Kubernetes NetworkPolicy actions. A shared backend classifies risk, assigns configurable remediation windows, stores workload state, and applies or removes managed policies. Dashboard, CLI, operator, REST API, and Splunk integrations support manual and automated response. Namespace scoping, policy simulation, rollback, opt-out metadata, and structured audit events preserve operational control. Prototype validation demonstrates end-to-end detection, tracking, containment, and recovery for representative vulnerable workloads. Together, these mechanisms make response timing visible, repeatable, and recoverable instead of relying on ad hoc operator judgment.
Event Type
Posters
TimeTuesday, 17 November 202610:00am - 5:00pm CST
Early Lessons From Characterizing Unified CPU-GPU Memory on DGX Spark
DescriptionNVIDIA DGX Spark integrates an Arm CPU and Blackwell GPU behind one coherent LPDDR5X memory pool. A roofline view captures throughput, but the shared-memory programming model can blur where CPU–GPU memory-policy costs are charged. We isolate three attribution factors: ownership state, lifecycle boundary, and timing window. Handoff tests show cold first touch reaches 35x steady reuse, with managed-family paths still 1.6x–1.7x above steady at 256 MiB. Lifecycle tests show explicit and mapped host paths spend 264 ms and 246 ms in 256 MiB setup+teardown, versus 0.22–0.24 ms for managed-family paths. In a 400 MiB-per-array vector addition, end-to-end and steady-state timing change policy ranking. Unified physical memory simplifies data visibility, but it does not remove ownership, lifecycle, or timing-window cost attribution.
Optimizing HPC Performance for CDC-Based Storage and Reconstruction of High-Resolution Imagery
DescriptionHigh-resolution imagery is increasingly used for community asset management, environmental monitoring, and disaster response. These missions preserve details needed for inspection, but they can generate hundreds of gigabytes of data, creating long-term storage and transfer burdens. To reduce this burden, this study evaluates conditional diffusion compression (CDC) for storing and reconstructing high-resolution imagery on GPU supercomputers. We do not propose a new compression model. Instead, we study how CDC should be configured to make better use of HPC resources. Using 100 RGB images from Galveston, Texas, on NCSA DeltaAI GH200, we compare checkpoint and tiling settings by measuring compression ratio, runtime, throughput, peak GPU memory, image quality, artifacts, object detection, and segmentation stability. The balanced b00064 checkpoint with 256 × 256 tiling reduces peak GPU memory to 1.57 GB, reaches 45.4 images per hour, and keeps a 79.98× compression ratio.
Completion-Driven, Staging-Free AlltoAllv with Local-NIC Balancing
DescriptionMixture-of-Experts (MoE) training workloads use imbalanced AlltoAllv collectives at bandwidth-bound message sizes. On Frontier, one-sided AlltoAll can beat RCCL and Cray-MPICH, but only with the right schedule and only as per-peer fetches shrink. Other approaches balance load across a node's NICs by explicitly copying data between GPUs, which costs GPU staging buffers and overlaps that copy with network traffic only coarsely. We introduce CURLEW, a completion-driven, GPU-staging-free RDMA AlltoAllv with dynamic local-NIC balancing. CURLEW achieves near-flat bandwidth across GPU counts and message sizes on balanced patterns, is 1.9x faster than previous work at max-to-mean skew above 8, and reduces end-to-end training time of a 201B-parameter model by 22% at a capacity factor of 1.25.
Nexus: Malleable Physical Infrastructure for Dynamic Workload Convergence
DescriptionContemporary research environments demand the integration of heterogeneous computing paradigms. This poster introduces Nexus, an incubator research project and empirical testbed designed to deploy complex, dynamic bare-metal infrastructure. Nexus bridges bare-metal immutability with cloud-native orchestration to enable the automated convergence of disjoint computational paradigms onto unified, reproducible hardware.
Event Type
Posters
TimeTuesday, 17 November 202610:00am - 5:00pm CST
Poster Blitz Groups
Poster Blitz
E-dLLM: Energy-Efficient Diffusion LLM Inference via Phase-Aware DVFS
DescriptionExisting diffusion LLM (dLLM) serving systems focus on optimizing latency and throughput, while their energy efficiency remains less studied. We show that dLLM decoding moves between compute-bound cache-refresh and memory-bound cache-reuse phases, and that decoding configurations create a broad accuracy–energy trade-off. We present E-dLLM, which combines configuration selection with phase-aware dynamic voltage and frequency scaling (DVFS). On LLaDA-8B, reactive DVFS reduces energy by 17% with less than 1% latency overhead, while preserving model outputs.
Digitizing the Chicago Assyrian Dictionary: Accelerating Document Analysis with VLMs and HPC Infrastructure
DescriptionThe Chicago Assyrian Dictionary (CAD), completed in 21-plus volumes over 90 years (1921–2011), is a foundational Akkadian lexical reference locked in print and print-derived images. Manual text generation from dictionary scanned images requires domain expertise and is time-consuming. We present a generalizable pipeline that converts dense mixed-script dictionary pages into accurate UTF-8-encoded structured data. The HPC-enabled pipeline combines image preprocessing and layout segmentation with Vision Language Model (VLM)–based Optical Character Recognition (OCR), prompt engineering, and post-processing. In few-shot experiments on the gold standard dataset, Claude Opus 4.6 achieved a 1.45% CER and 5.75% WER on the training set (for optimal prompt design and selection) and 1.49% CER and 4.73% WER on the validation set. Using the pipeline, running on CPU compute nodes, we extracted raw text in less than a week, with domain expert text verification underway to finalize the scholarly dataset for human-environment history research.
Event Type
Posters
TimeTuesday, 17 November 202610:00am - 5:00pm CST
VLIW Scheduling: Timing Is All You Need
DescriptionAMD's XDNA2 NPU packs 32 six-issue VLIW cores where the schedule must resolve nearly all pipeline hazards. Each core achieves 1,843 GFLOPS by always issuing a VMAC.F operation, an 8×8×8 block-floating-point (BFP16) matrix multiply-accumulate. This corresponds to an array-wide performance of 59 TFLOPS. One obstacle is register pressure: a standard double-buffered 2×2 output block needs eight accumulator registers, whereas a core has only five.

We present a hand-scheduled VLIW BFP16 tensor-contraction kernel that time-multiplexes the output block's four accumulation chains onto two registers and issues a VMAC.F in every steady-state cycle.

On one core with L1-resident data, our kernel achieves 96.4% of theoretical peak (5.0× faster than the compiled mm_bfp.cc kernel). With the operands streamed from DRAM, a pre-tiled M3840×N3840×K8192 matrix multiplication reaches 21.4 TFLOPS on the whole NPU.

At the poster, we will walk visitors through the VLIW scheduling diagrams and the scannable artifact reproducing every measurement.
OpenCCL: A Proposed Open Standard and Reference Implementation Unifying *CCLs for Performance, Portability, and Productivity
DescriptionNVIDIA's NCCL is the de-facto GPU communication API for distributed AI, but it is a toolkit rather than a specification: its semantics are thin, it is tied to one vendor's stack, and other *CCLs re-implement or fork it. OpenCCL proposes an open standard and reference implementation: a normative specification with an ABI-stable header over pluggable transports and collective engines, so one library spans vendors and fabrics without application changes. OpenCCL runs unmodified NCCL codes and addresses all 33 entry points of NCCL 2.23.4. On Slingshot-11 it builds on RAPIDS Cascade APIs: kernel-initiated transfers behind a stream-triggered interface that fits NCCL semantics. Preliminary results on LLNL's Tuolumne, an El Capitan-class system, outperform RCCL and Cray MPICH for Allreduce from 256 bytes to 16 KiB, and Cascade outperforms Cray MPICH and our earlier stream-triggered MPI for small messages. MSCCL's AllToNext is implemented. The poster invites participation in standardization, implementation, and AI adoption.
Plexus-v2: Extreme-Scale GNN Training with Communication-Free Sampling and 4D Hybrid Parallelism
DescriptionGNNs are widely used for learning on graph datasets derived from various real-world scenarios. Learning from extremely large graphs requires distributed training, and mini-batch training is a popular approach for parallelizing GNN training. Existing distributed mini-batch approaches have significant performance bottlenecks due to expensive sampling methods and limited scaling when using data parallelism. We present Plexus-v2, a four-dimensional hybrid parallel framework for scalable mini-batch GNN training that combines communication-free distributed sampling, three-dimensional parallel matrix multiplication, and data parallelism. Plexus-v2 introduces a uniform vertex sampling algorithm, enabling each process to construct its local shard of subgraph without any inter-process communication. Combining 3D PMM with data parallelism enables Plexus-v2 to scale to much larger GPU counts than vanilla data parallelism with significantly lower communication overheads. We evaluate Plexus-v2 on five graph datasets and scale to 2,048 GPUs/GCDs. On Perlmutter, Plexus-v2 achieves 3.5x end-to-end training speedup over the best-performing SOTA frameworks on ogbn-products.
Mallet: An Open-Source Formal Verification Flow for Agile Domain-Specific Accelerator Development
DescriptionCustom domain-specific accelerators are gaining attention for the significant performance gains they deliver on specialized workloads: scientific instruments utilize custom accelerators to sustain extreme data rates, and molecular dynamics accelerators can achieve orders-of-magnitude speedups over general-purpose supercomputing systems. However, their increasing complexity and specialization make verification challenging, allowing design flaws to escape detection and leading to incorrect results. Formal verification can fill this gap, but accelerator designs shift quickly, formal properties are hard to write, and LLM-generated designs often mirror bugs in the very properties meant to catch them. We present Mallet, an open-source formal verification flow for the Chisel stack. Mallet renders properties from human-specified AXI memory-map annotations, so design-spec drift is caught at compile time, and issues them to multiple model-checking engines, producing an adjudication matrix that ranks proof strength and flags vacuous passes. We demonstrate Mallet across five AXI4-Lite DUTs and a fault-injection suite.
Useful Data, Not Just More Data: Cost-Aware Floating Car Data Generation in Large-Scale Traffic Simulation
DescriptionLarge-scale traffic simulations can generate millions of floating car data (FCD) records, but more output does not necessarily provide more useful information. Using Ruth on LUMI, we study a Chicago scenario with 6.9 million input vehicle trips and 748,509 road-network nodes. We compare output size, road-edge coverage, temporal coverage, and speed similarity against a high-detail simulation reference. With vehicle updates fixed at 20 seconds, increasing the FCD sampling period from 5 to 20 seconds halves output while retaining 97.1% road-edge coverage and 88.9% temporal coverage. Tests on 1–16 nodes show sublinear gains in the traffic-time interval recorded within a fixed wall-time budget. Reducing rerouting participation from 80% to 50% extends this interval by 18%–22% and lowers wall time per second of recorded traffic time by 15%–18%. We recommend selecting the smallest output meeting task-specific coverage and speed-error requirements; rerouting changes still require validation of traffic outcomes.
Bigger Networks, More Trajectories: Scaling Exact Stochastic Simulation on GPUs Through Sparse Storage and a Warp-ary Propensity Tree
DescriptionExact stochastic simulation of biochemical networks requires large trajectory ensembles for increasingly large reaction models, creating two main bottlenecks: dense model storage can exceed device memory, while serial reaction selection costs O(M) per step.

We built an exact GPU Gillespie solver in Lattice Microbes software that stores stoichiometry and the reaction dependency graph in a compressed sparse row format and selects reactions using a warp-cooperative 32-ary propensity tree in O(log₃₂M). Our major contribution combines sparse storage with warp-cooperative logarithmic selection for exact GPU SSA. The solver is implemented and validated against StochKit2; release in Lattice Microbes v3.0 is planned.

On an NVIDIA B200 across five models with 18–58,276 reactions, memory use decreases by ~800×, enabling up to 100K trajectories where other tools run out of memory. This poster presents the algorithm, sparse data layout, scaling, and comparative performance, including up to ~20× higher throughput where competing tools still fit.
A Naive D3Q27 Lattice Boltzmann Implementation on the Cerebras CS-3: Comparison with GPUs
DescriptionThe lattice Boltzmann method (LBM) is a stencil-based CFD method widely used across engineering fields, in which the domain is divided into a lattice, each element is computed independently, and data is exchanged with adjacent elements. Thus, it is expected to map well onto the Cerebras CS-3, which features large distributed on-chip memory and high-bandwidth inter-PE communication.

In this work, we naively implement a three-dimensional LBM (D3Q27 Model) on the CS-3 by assigning a 1x1xn lattice to each processing element (PE). To the best of our knowledge, this study is the first attempt made to implement 3-D LBM and measure its performance.

On the largest domain, the CS-3 achieves 83.74 GLUPS — a 17.4× and 8.5× speedup over the NVIDIA A100 and GH200 — while sustaining a parallel efficiency of 1.0 under weak scaling. These results indicate that wafer-scale computing can serve as a promising platform for memory-bound stencil computations.
Breaking the Chain: Geometry-Native State Preparation with ASPIRE
DescriptionLoading data into quantum computers is a key bottleneck threatening end-to-end quantum advantage. Compilers for structured states, like matrix product states (MPS), help manage this bottleneck in quantum chemistry, finance, and many-body simulation. Approximate MPS preparation typically uses layered staircases of nearest-neighbor gates. We present Adaptive State Preparation by Iterative Removal of Entanglement (ASPIRE). ASPIRE approximately compiles state-preparation circuits by selecting gates using the state's entanglement geometry and target processor's connectivity. It scores candidate qubit pairs on entanglement removability and identifies layers of parallel long-range gates removing the most entanglement. We test ASPIRE on Hamiltonian ground states and multivariate amplitude-encoded functions, including qubit connectivity, hardware noise, NISQ, and early-fault-tolerant settings. For states with long-range entanglement, ASPIRE typically achieves higher fidelities and shallower circuits than existing methods, even including classical optimization. ASPIRE is a competitive, resource-frugal protocol, especially promising for applications tolerant to imperfect fidelity, like quantum phase estimation guide states.
How the NERSC User Community Connects
DescriptionHigh performance computing centers, such as NERSC, serve thousands of projects and users across many science domains and funding offices, yet staff have few systematic ways to see how these communities form, persist, and connect for planning and outreach. As an exploratory step toward surfacing actionable insights from allocation data, 2020–2026 Perlmutter allocation records are turned into yearly project and user networks, and community detection, weighted betweenness bridge detection, and liaison ranking. Null-model and matched-popularity tests confirm the structure is real and actionable: communities stay above the 95% null modularity band every year; about 10% of projects carry 66%–74% of cross-office connectivity; and the top 200 liaison candidates reach 69% of active users. To our knowledge, this is the first network analysis of an HPC facility’s community.
Cache-Driven Super-Linear Scaling in a Python Fluid Solver
DescriptionTurbulent convection transports heat in stars, planets, and the Earth’s atmosphere, and simulating it demands extreme-scale computing. We present DHARA, a modular fluid solver written in Python (NumPy, CuPy, mpi4py) with compiled stencil kernels for CPUs and GPUs. On the CPU-based Shaheen III (KAUST), DHARA scales to 786,432 cores for compressible convection, and its strong scaling is super-linear: adding cores speeds up each step by more than the ratio of the core counts. Profiling explains why. As the domain is split across more cores, each subdomain’s stencil working set drops into the fast L1/L2 caches, so cache misses collapse, leading to a better than doubling of the per-core throughput. The same code carries over to the Frontier (OLCF) and Polaris (ALCF) GPU systems with near-ideal strong scaling.
GenASPEN: Agentic AI for Automatic Performance Modeling of HPC Codes
DescriptionThe growing heterogeneity of HPC programming models and hardware architectures has made automated performance modeling more essential and more difficult. Compiler-based frameworks such as COMPASS and MAPredict need programming model-specific integration; frontier LLMs are flexible but predict runtime poorly; custom LLMs buy accuracy at prohibitive cost. We present GenASPEN, an agentic AI framework that assigns each task to the component best equipped for it: a Code Translation Agent (a context-aware chain-of-thought pipeline over GPT-OSS 120B, or a Code Llama 7B assistant fine-tuned with ChatHPC) converts CUDA/HIP kernels into ASPEN application models, and a Performance Modeling Agent combines them with machine and analytical models to predict FLOPs, loads, stores, and execution time on modern GPUs. Across 22 benchmarks on NVIDIA H100 and AMD MI300A, GenASPEN reaches 98.5% operation-count and 94.40%/93.09% execution-time accuracy, beating four frontier LLMs on 16 of 22 kernels with zero manual annotation.
APQF: Agentic Profiling-Guided Structured Pruning and Mixed-Precision Quantization with Adaptive Fine-Tuning
DescriptionDeep neural networks are powerful but too large to run cheaply on edge devices. Pruning and quantization help, but deciding how and where to compress a model is still manual, or relies on algorithms that are hard to apply across architectures. We introduce APQF, an agentic profiling-guided framework that combines structured pruning, mixed-precision quantization-aware training, and accuracy recovery in one automated pipeline. A profiling agent measures cost distribution and pruning sensitivity, which then drive per-group pruning ratios, per-layer bit-widths, and the recovery strategy. Our experiments on ImageNet and CIFAR-10 show that APQF compresses convolutional and transformer models further than a joint pruning and quantization baseline at comparable or higher accuracy, and stays stable across different planners, including free open-weight ones.
Resource Adaptivity in the GPTune Autotuning Framework
DescriptionAutotuning frameworks often consist of various phases, such as sampling, modeling, and search, each with different resource requirements. Hence, traditional, static resource management for such frameworks often leads to wasted resources since not all allocated resources are used throughout all phases of the tuning process.

To address this inefficiency, we demonstrate the use of dynamic resource management for autotuning frameworks, building on the well-known GPTune framework. The original GPTune implementation uses MPI Spawn to launch processes for each phase within a static allocation. We adapt the implementation to use MPI Sessions and Dynamic Processes with PSets (DPP), expressing resource needs of each phase using DPP's generic, graph-based abstraction. This allows resource managers to adapt allocation to current resource needs.

Our evaluation shows that dynamic resource management can reduce the resource usage of GPTune by 46% compared to the static GPTune version.
High-Performance Star-M SVD for Big Data Compression
DescriptionIn the era of big data, effectively compressing large datasets while performing complex mathematical operations is crucial. Tensor-based decomposition methods have shown superior compression capabilities with minimal loss of accuracy compared to traditional matrix methods. Under the star-M tensor framework, tensors can be decomposed in a matrix-mimetic way, including using the star-M SVD. This tensor SVD has optimality guarantees and has shown exceptional performance on specific types of data, but software implementations have been mostly limited to productivity-oriented languages. In this work, we present our development of a shared-memory parallel, high-performance solution designed to efficiently implement the underlying algorithms. This software will enable optimal compression of extensive scientific datasets, paving the way for enhanced data analysis and insights.
A Linear-Scaling, Sparse Matrix Electronic Structure Solver on the Cerebras Wafer-Scale Engine
DescriptionWe present a linear-scaling electronic structure solver for the Cerebras Wafer-Scale Engine (WSE), a data-flow architecture integrating more than 900,000 processors on a single silicon wafer. We combine a novel, WSE-optimized sparse-matrix squaring kernel with a sparse, recursive Fermi-operator expansion to construct the density matrix on this massively parallel architecture. Our approach solves the quantum-mechanical eigenvalue problem for one self-consistent-field iteration with a computational complexity that is linear in the number of atoms. For a bulk water system described at the density-functional tight-binding level of theory, we achieve a 31x speedup for a single density-matrix solve relative to a single-GPU reference calculation running on an NVIDIA GH200 Grace Hopper superchip.
Training-Free Mixture-of-Agents for CUDA Kernel Translation and Optimization
DescriptionThis poster presents a kernel-aware multi-agent framework for CUDA optimization that analyzes both performance gains and optimization cost. We compare Fixed, Adaptive, and Collaborative optimization modes across two kernels: Lattice-Boltzmann Method (LBM) and SYMM. Fixed applies a predefined sequence of coalescing, tiling, and atomic-focused transformations, while Adaptive uses routing to stop when additional layers are unnecessary. Collaborative uses multi-model proposals with GPT-OSS aggregation. Our layer-influence analysis measures how strongly each intermediate optimization layer shapes the final kernel using similarity-based scores. Results show that LBM benefits from deeper staged refinement, with later layers contributing most to the final output, whereas SYMM converges earlier after coalescing and tiling. Cost analysis further shows that Adaptive optimization can reduce tokens, energy, and optimization time by avoiding unnecessary transformations. Overall, the results highlight the importance of kernel-aware routing and layer-aware stopping for practical LLM-driven GPU optimization.
StageOnce: Speculative Cross-Job Data Staging for LLM Agent Fleets
DescriptionScientific workflows increasingly run as fleets of LLM agents analyzing the same large immutable datasets. On a shared compute node, independent staging repeats source reads and creates storage contention, while each job discovers its inputs during reasoning. StageOnce coordinates these speculative path predictions through a node-local daemon, coalescing concurrent misses into one immutable copy while preserving dataset versions and private outputs. Tools read staged inputs directly from the filesystem, without per-read coordination. Recorded-session replays in genomics and astronomy on SSD and HDD backends reduce fleet makespan by 31%–51% at 12 concurrent jobs against independent staging. Logical staging remains one copy across every tested fleet size. An ablation isolates speculation, which reduces makespan by 8%–49% against reactive shared caching.
Energy and Carbon Footprint of the x3d2 CFD Solver on AI-First and HPC-Class GPUs
DescriptionEstimates of the energy and carbon cost of computation are almost never checked against direct measurement. We instrument x3d2, a compact, high-order finite-difference CFD solver, across three GPU architectures and a 24-core server CPU.

While an AI-first accelerator uses 1.27x–1.40x lower energy than either HPC-class GPU, hardware selection is second-order: shifting a job's start time across 12 months alters emissions by 28x. Four standard carbon-accounting tools, all correctly configured, agree within 1.3x on that accelerator while overestimating energy measured at the wall socket by 1.9x–2.9x. On an A100 node, the same tools land within 0.64x–1.11x of whole-node energy.

The measurement campaign is complete: 124 instrumented runs on two platforms, plus a 36-run arm on a third, with full per-run telemetry and a complete analysis pipeline.

During the poster session, we will guide attendees through the power telemetry, visual tool-accuracy breakdowns, and the practical realities of carbon-aware scheduling.
GIFT: Geometry-Informed Low-Precision Gradient Communication for LLM Pretraining
DescriptionGradient communication is a major scaling bottleneck in large language model (LLM) pretraining. While FP8 can substantially reduce communication cost, direct quantization in Euclidean coordinates can distort highly anisotropic gradients. We present GIFT, a geometry-informed gradient communication method that transforms gradients into more isotropic coordinates before low-precision quantization. To make this practical, GIFT uses a one-sided, low-rank geometry approximation and applies it selectively to layers most sensitive to quantization error, while leaving the optimizer, training recipe, communication collective, and FP8 format unchanged. Across Llama-style models with approximately 600M and 2B parameters, GIFT achieves downstream performance comparable to Muon training with FP32 gradients. On 64 NVIDIA GH200 Superchips, GIFT reduces end-to-end training step time by 10.87% for Llama-600M and 17.05% for Llama-2B relative to FP32 gradient communication.
Agents of Intelligence: Lowering the Barrier to AI for Domain Scientists
DescriptionArtificial intelligence is reshaping how science is done, yet most domain scientists face a steep barrier to adopting it. The landscape of models, platforms, and data pipelines is fragmented, and navigating it rewards tacit expertise accumulated over years of practice. We present Agents of Intelligence (AoI): a modular, composable, human-in-the-loop framework of AI agents that sense workflow context, automate routine decisions, recommend models and compute resources, and learn from usage. AoI is grounded in interviews with 11 Schmidt AI postdoctoral researchers spanning eight scientific domains, and it integrates with the National Data Platform to support the full research lifecycle from data acquisition through model deployment, making AI-assisted science accessible across domains.
MATCH: Multimodal Alignment Through Contrastive Learning of Heterogeneous Sensor Streams at Static Nodes
DescriptionMultimodal environmental sensing networks routinely capture temporally co-occurring conditions across incompatible representations: an RGB frame, a thermal frame, an audio clip, and environmental readings share no common feature space. We present MATCH, a contrastive learning framework that combines frozen, domain-matched pretrained backbones with lightweight trainable projection heads to align real-world node data across all four modalities in a shared 512-dimensional embedding space without task-specific labels. A multi-view InfoNCE loss aligns all six modality pairs. Evaluated on a 195-observation held-out test set from a single deployed node, retrieval improves over random across all six pairs, with RGB↔Thermal strongest — notably, 73.3% of its incorrect top-5 retrievals fall within ±2 hours of the correct time of day, versus a 20.4% chance baseline, indicating the learned space captures coarse diurnal structure.

At the poster we'll present our architecture, cross-modal retrieval examples, quantitative alignment results, and discuss next steps toward node-specific adaptation.
Data-Driven GPU Performance Model for Molecular Dynamics in Computational Drug Discovery
DescriptionMolecular dynamics (MD) simulations increasingly rely on GPU acceleration to meet the computational demands of large biomolecular systems. However, predicting application performance across diverse molecular systems and heterogeneous GPU architectures remains challenging due to complex heterogeneous MD kernels with varying compute and memory demands. Conventional analytical models, including Roofline analysis, provide only coarse estimates and cannot capture the heterogeneous execution characteristics of modern MD workloads.

This work presents a hierarchical, reasonably explainable surrogate model that integrates molecular descriptors, simulation parameters, GPU architectural features to learn architecture-aware representations of MD execution on GPUs. Proposed teacher-student model's knowledge distillation removes the dependence on expensive runtime profiling while maintaining strong accuracy across previously unseen GPU architectures, providing a practical foundation for architecture-aware performance modeling in computational drug discovery.
An MLIR Dialect for Fault-Tolerant Quantum Computing
DescriptionTo achieve fault-tolerant quantum computing (FTQC), a compilation pipeline must address quantum error-correcting codes, syndrome extraction, magic-state distillation, and physical-gate decomposition. We introduce ftqc, an open-source dialect for MLIR (Multi-Level Intermediate Representation) that treats these concerns as first-class constructs in the intermediate representation (IR). Logical qubits are type-safe static single-assignment (SSA) values parameterized by their error-correcting code and distance, letting the compiler enforce code and distance compatibility at the type level. The dialect provides operations covering the logical life-cycle: encoded initialization, transversal Clifford gates, T gates and Toffoli gates by magic-state injection, syndrome extraction, and distillation. A resource estimator derives physical-qubit counts and logical error rates directly from ECC metadata in the IR, and three validated backends emit OpenQASM 3, QIR (Quantum Intermediate Representation), and Stim. Across four benchmarking quantum circuits, end-to-end compilation completes in under 15 ms, and a full logical-error-rate sweep through Stim runs in under 4 s.
Correlation-Aware Uncertainty Visualization of Multivariate Data with Many-Core Acceleration
DescriptionThis research addresses a fundamental limitation in state-of-the-art uncertainty visualization of multivariate data: omission of statistical correlation between underlying data fields. Existing approaches either ignore correlation, yielding overconfident or underconfident uncertainty estimates and potentially misleading visualizations, or rely on computationally expensive Monte Carlo integration that limits practical applicability. We enable efficient, scalable, and reliable correlation-aware uncertainty visualization by modeling bivariate uncertainty using correlated Gaussian distributions and multivariate uncertainty using kernel density estimation (KDE), both capturing data correlation. We develop analytical frameworks for Gaussian and KDE models to propagate uncertainty into extracted level sets, providing the first rigorous study of correlation effects on multivariate level-set uncertainty while eliminating costly numerical integration. Compared to Monte Carlo methods, our approaches achieve speedups of up to 500x on equivalent serial and parallel hardware using the Viskores library. Results on synthetic and real-world datasets underscore the criticality of correlation-aware uncertainty quantification for trustworthy data analysis.
Drava: An Event-Driven Runtime for Scientific Pipelines with Agentic Configuration Optimization
DescriptionNext-generation X-ray science (XRS) detectors are driving continuous, multi-stage streaming pipelines with facility-scale data rates approaching petabytes per second. These workflows require real-time reconstruction, AI inference, and feedback-driven control under strict performance and energy constraints, yet current software stacks often require manual tuning of batching, transport, and resource decisions.

We propose Drava, an event-driven runtime for scientific streaming pipelines. Developers express application stages as reusable components, while Drava manages scheduling, batching, data movement, and execution across heterogeneous resources. Integrated with ptychography and tomography applications, Drava sustains high-rate streaming at about 31 kHz. Compared with PvaPy, it handles unpaced input without dropping frames and achieves up to 2.36× higher throughput. Batching improves throughput by up to 2.44×, while agentic Bayesian optimization identifies a configuration 2.24× faster than the best manual configuration. Drava also exposes throughput-energy trade-offs for performance- and energy-aware scientific workflows.
Toward HEPScore4GPU: Scaling and Power of Real HEP GPU Applications on the A100 and H100
DescriptionThe HEPiX Benchmarking Working Group is developing HEPScore4GPU, a GPU benchmark for high-energy physics (HEP) built from real HEP applications for the High Lumi-LHC program. A key question is how efficiently GPUs can be used for HEP today. We take three candidate applications under development, a Monte Carlo Generator, a detector full simulation and an AI-based end-to-end simulation application, and run them on NVIDIA A100 and H100 GPUs, measuring how throughput scales from one to four GPUs and how much power they use. In this contribution we will describe the measurement process and the understanding of the different behaviors, with the objective of providing input to the application developers to further improve the software and exploit the maximum power of the GPUs.
A Side-Channel Methodology for DL Model Recovery Using Power Traces
DescriptionDeep learning architecture represents proprietary intellectual property and serves as a basis for model extraction and adversarial attack techniques. By analyzing only the total GPU power consumption, sampled every 20ms via standard telemetry during inference, without access to weights, inputs, activations, or the computational graph, we can reconstruct the sequence of layer types executed. Our methodology involves segmenting the power trace, matching each segment against a library of per-layer power templates using k-Nearest Neighbors (k-NN), and refining the classification with a Hidden Markov Model (HMM) that encodes typical layer transition patterns with a Viterbi decoder. Evaluations across 21 models and 8-layer classes reveal an average layer-type sequence recovery accuracy of 60.1%, reaching up to 92% for some models.
Characterizing GPU Performance in AI Inference with Power Metrics
DescriptionLarge language model inference is increasingly limited not only by raw compute capability, but also by memory bandwidth, runtime behavior, and GPU power efficiency. We study how LLM inference performance and energy use vary across hardware platforms and inference frameworks. Experiments are conducted on NVIDIA's Jetson Thor, and A100 and H200 GPUs using two inference frameworks: vLLM and Hugging Face Transformers. Three open-weight LLMs are evaluated. For each hardware, framework, and model combination, inference metrics are collected. Pareto and histogram analyses are used to study the trade-off between throughput and energy efficiency. To connect inference behavior to hardware limits, BabelStream benchmark's triad kernel is used to measure host-memory and GPU-memory bandwidth. In addition, roofline analysis separates prefill and decode phases to show when performance is compute-bound or memory-bound. These measurements help explain why the Jetson Thor can be energy-efficient, while A100 and H200 provide higher throughput but consume more power.
A Multi-Phase GPU Pipeline for Biconnected Components
DescriptionGraph biconnectivity is a fundamental primitive for structural analysis, but classical algorithms rely on depth-first search, which is inherently sequential and does not scale to GPUs. We present a multi-phase, GPU-resident pipeline for computing biconnected components on large-scale undirected graphs. Our pipeline first removes 1-core vertices through iterative peeling, then grows depth-capped breadth-first search trees from multiple random roots in parallel, ensuring each vertex joins exactly one tree. We resolve each tree's non-tree edges into local biconnected components, then merge components across tree boundaries using the remaining cross-tree edges. We evaluate our approach on 17 real-world networks on a single NVIDIA A100 GPU. Our approach substantially outperforms earlier GPU and CPU baselines, including WK-17, WK-18, and CPU-based FAST-BCC, and achieves an average speedup of 2.49x over FAST-BCC-Filter, the current state-of-the-art GPU approach.
Understanding and Improving Multi-Rack Symmetric-Memory AllGather in NCCL
DescriptionRack-scale GPU systems such as the GB200 NVL72 extend the NVLink scale-up domain from four or eight GPUs per server to 72 GPUs per rack. Large language model (LLM) training still scales across many racks, with all-gathers spanning heterogeneous NVLink and InfiniBand fabrics. These all-gathers operate in a message-size regime where both latency and bandwidth matter. In this work, we characterize NCCL's symmetric-memory and legacy all-gather performance for this regime. We derive a closed-form topology-aware bandwidth bound and extend it with a latency term for comparison with empirical measurements. Based on observed trends and model insights, we design two new GPU-initiated symmetric-memory all-gather implementations that outperform NCCL's symmetric-memory all-gathers by up to 2.6x for 32-512MB messages.
Sparse Matrix-Vector Multiplication on Cerebras WSE-3
DescriptionSparse matrix-vector multiplication (SpMV) is bounded by data movement rather than arithmetic, since every nonzero fetches from an unpredictable address. We present a general tile-wise SpMV kernel for the Cerebras WSE-3, whose ~893,000 processing elements (PE) hold the working set in on-chip SRAM. The kernel partitions the matrix with a deterministic host-side balancing algorithm and sums per-PE partials eastward along each grid row. Sweeping to the full wafer, the local compute scales linearly and a two-parameter model predicts it exactly across 17 configurations; the eastward reduction, parallel along one axis only, is the sole limit on total scaling, and a standalone chain-latency model underpredicts it by up to 26% once it overlaps compute. On a biobank-scale genotype matrix of 5.28 billion nonzeros the kernel sustains 64,700 GFLOP/s; on a matched smaller instance it completes in 59.6 μs against 5.46 ms for four A100 GPUs.
Communication Strategies for Wafer-Scale Iterative Solvers
DescriptionCollective communication strongly affects the performance of iterative scientific applications. Conjugate gradient repeatedly computes global dot products that require reductions across many processing elements. This work evaluates chain and hierarchical XY two-phase reductions on a Cerebras Wafer-Scale Engine. We developed a reproducible workflow for compiling wavelet programs, executing them on hardware, collecting distributed timer values, and producing graph-ready data. Measurements across 262,144 processing elements show a payload-dependent crossover. XY two-phase communication performs best for small payloads, but chain communication becomes faster as the payload grows. These results motivate adaptive collective selection based on message size.
Do AI Workloads Fail Differently? A Cross-Cluster Characterization of Failure Types in AI and HPC Systems
DescriptionHigh performance computing studies conclude that user error causes most job failures, while large-scale AI training reports attribute most interruptions to hardware. The two literatures are rarely read together, because they publish failure evidence in incompatible forms: attributed causes, scheduler outcome labels, or bare event rates.

We surveyed 162 public datasets and operational reports, assigned every one an evidence verdict, and normalized the usable evidence into an 11-class taxonomy that tags each failure type as a cause, a symptom, or an outcome label. The resulting denominator-disciplined maps cover 38 systems across 44 matrix columns and include a GPU error-class characterization spanning five hardware generations. The work is complete: every value passed three verification passes, and the artifact is public.
QoS Coverage Maps for Placement and Readiness in Urgent Digital Twins
DescriptionUrgent continuum workflows may miss deadlines because of poor task placement, delayed artifact readiness, insufficient compute capacity, or excessive full-fidelity execution time. We isolate placement and readiness while holding capacity and fidelity fixed. We introduce QoS coverage maps, which vary offered load and readiness delay, and classify whether the primary diagnostic target (tau) of 50% on-time completion is met by the best-performing of three non-learning baselines, learned placement, advance artifact staging, or neither. The threshold separates operating regions. For wildfire, learned placement improves on-time completion by up to 85.5 percentage points, while increasing readiness delay from 0 to 10 s at 1.0 fps reduces completion from 87.7% to 0.4%. For earthquake-tsunami, learned placement adds no coverage relative to the primary baseline because 96.4% of critical-path computation is fixed to HPC. At tau = 50%, 10 of 30 tested conditions remain uncovered in each workflow, motivating capacity scaling or bounded approximation.
Online Load Balancing of High-Order Mixed-Element Simulations on Heterogeneous Architectures
DescriptionScale-resolving simulations performed on clusters can be expensive, spanning hours to months. Efficient use of shared HPC resources increasingly involves allocations combining devices with different throughputs, requiring effective load partitioning across heterogeneous architectures. This work develops an online, distributed, diffusion-based repartitioning strategy driven by observed MPI wait-time statistics at runtime. The method infers cost imbalance to derive a target load distribution, then incrementally relocates interface-adjacent elements across ranks while preserving the existing partition structure. Integrated into the open-source compressible Navier–Stokes solver PyFR, the method is evaluated for flow around a circular cylinder at Re = 3900. Online load balancing achieves 101%, 116%, and 119% of homogeneous sum-of-parts performance targets across three heterogeneous configurations. Completed RK45 simulations achieve 2.4x, 2.8x, and 7.7x time-to-solution speedups.
Scalable OpenCHAMI Node Infrastructure Collection (SONIC)
DescriptionReliable hardware telemetry is foundational to HPC cluster operations, enabling proactive thermal management, power optimization, and failure prediction. HPC monitoring systems often struggle with data loss, service interruptions, and scalability limitations. This work presents a BMC telemetry system deployed on Los Alamos National Laboratory's SI research cluster that achieves high availability through event-driven architecture combining intelligent polling, triple-redundant data paths, and fault-isolated services. Intelligent polling reduces network overhead by 81% while maintaining sub-second latency. A centralized consumer with batched writes achieves 82% reduction in database CPU utilization. Load testing collected over 77,000 samples across multiple load levels, demonstrating counterintuitive inverse scaling where consumer performance improves as cluster load increases. The poster will present the hybrid architecture pipeline, performance metrics under realistic workloads, and Grafana visualization dashboards demonstrating operational deployment on a nine-node production testbed.
Query-Driven Visualization Over Compressed Scientific Data via Data–Index Co-Compression
DescriptionLarge-scale scientific simulations routinely produce petabyte-scale datasets, making error-bounded lossy compression indispensable for alleviating storage and I/O bottlenecks. However, most visualization pipelines still reconstruct the entire compressed dataset before analysis, even when a visualization query accesses only a small subset of the volume, resulting in substantial computational overhead and limited interactive responsiveness.

We apply data–index co-compression to enable efficient query-driven visualization, jointly compressing block-level index with scientific data to support selective decompression while minimizing index overhead. During visualization, only the compressed blocks satisfying the query predicate are decompressed, avoiding unnecessary data access and reducing end-to-end visualization cost.

Experimental evaluation on three representative scientific applications demonstrates substantial end-to-end acceleration, achieving up to 50.1× speedup over conventional full-decompression workflows while preserving comparable visualization quality.
Understanding the NERSC User Community Through Network Analysis
DescriptionNERSC users collaborate, forming a network. Which users occupy the most structurally influential positions in the NERSC user community? Using 2020–2026 NERSC allocation records, a proxy collaboration graph was analyzed to reveal the user community’s dynamics. Two definitions of user connectivity were compared using available data on project allocation size: unweighted degree and repository-size-adjusted (RSA) strength. Degree distributions, program-office affiliation, and user roles were analyzed. Results show that RSA strength is a more accurate measurement of user connectivity than unweighted degree. The strongest connectors in the network are career scientists and users associated with high-energy physics. These findings suggest that in HPC network data, unweighted connectivity is not a reliable measurement of network influence or cross-disciplinary reach. Findings also suggest that allocation networks reflect certain field-specific collaboration patterns, implying that allocation networks may provide a useful proxy for co-authorship networks in the same field.
Performance Analysis of Phaseless Auxiliary Field Quantum Monte Carlo
DescriptionPredicting molecular behavior requires knowing a molecule's ground-state energy, a calculation whose exact cost grows exponentially with system size. Phaseless auxiliary-field quantum Monte Carlo (ph-AFQMC) approximates this energy via guided random walks, where accuracy and cost depend heavily on the quality of the trial wavefunction used to steer the walk. We compare two quantum methods for preparing this trial wavefunction, the Variational Quantum Eigensolver (VQE) and the Generative Quantum Eigensolver (GQE), benchmarked on NERSC Perlmutter using linear hydrogen chains. At H8 (16 qubits), GQE reduces end-to-end pipeline wall-time by roughly 5x relative to ADAPT-UCCSD, while matching VQE-family accuracy near equilibrium bond length. These results motivate extending the study to H10 chains and multi-node scaling to determine whether GQE's cost advantage persists at larger, more strongly correlated systems.
A Distributed Mixed-Precision N-Body Engine: Scaling Behavior and the Precision Limits of a Direct-Summation Kernel
DescriptionWe report a distributed direct-summation N-body engine used to study two coupled limits: where the single collective per step begins to limit strong scaling, and where reduced-precision arithmetic begins to corrupt the physics. At fixed N = 32768 on one 96-core node, the kernel scales almost ideally to 16 ranks and reaches 57× speedup at 96. In-core phase timers show that the loss beyond 16 ranks comes from one straggling rank, whose peers wait at the collective, rather than from data transfer, which stays under 1% of a step. A precision ladder from FP64 down to FP8 shows that the accumulator, not the individual force terms, sets the error floor: rounding the running sum costs 92×–125× more force error than rounding the terms alone.
K2S-Gate: A Secure Kubernetes-to-Slurm Gateway with Unified Service Catalogs for Web-Based AI and HPC Applications
DescriptionThe rapid growth of AI and high performance computing (HPC) applications demands seamless integration of cloud-native and HPC environments, yet heterogeneous software stacks keep these systems isolated, limiting unified deployment of and access to web-based applications. This work presents K2S-Gate, a secure Kubernetes-to-Slurm gateway that bridges cloud-native and HPC infrastructures through a unified web platform. K2S-Gate introduces a job-to-service transformation paradigm that converts Slurm batch jobs into dynamically accessible web services, enabling one-click execution on HPC compute nodes without SSH tunneling or port forwarding. It also provides a template-based Unified Service Catalog for deployment across heterogeneous environments. For secure, scalable access, K2S-Gate integrates a Secure Access Layer combining single sign-on (SSO), an OAuth2-based identity provider (IdP), and an Istio ingress gateway. Validated on the KISTI-5 supercomputer and integrated into the MyKSC portal, K2S-Gate demonstrates its practicality in real-world HPC environments.
From Microbenchmarks to LLM Inference: An End-to-End Analysis on the Energy Efficiency of the Grace Hopper Superchip
DescriptionThe NVIDIA Grace Hopper (GH200) Superchip introduces a tightly integrated CPU-GPU architecture with shared power management, enabling new opportunities for energy-efficient high performance computing and AI inference. However, the impact of its power controls across different workloads remains largely unexplored. We present an end-to-end analysis of the GH200, spanning power sensor validation, HPL and HPL-MxP benchmarking, and LLM inference using Llama-3.1-8B. Our study quantifies the interaction between module and GPU power limits, evaluates energy-performance trade-offs, and analyzes operational and total cost of ownership. We demonstrate highly accurate onboard power measurements, identify workload-dependent optimal power settings, and show that mixed precision and inference workloads respond differently to power capping. During the poster session, we will present our experimental methodology, discuss the observed trade-offs, and highlight practical guidelines for energy-efficient deployment of GH200-based HPC and AI systems.
Performance Evaluation of a Heterogeneous CPU-GPU Framework for Real-Time ECG Analytics
DescriptionReal-time cardiac digital twins require analytics pipelines that are both computationally efficient and diagnostically accurate. This paper presents a heterogeneous high performance computing framework integrating OpenMP parallelized CPU preprocessing with a CUDA-accelerated convolutional neural network for ECG beat classification using the MIT-BIH Arrhythmia Database. The preprocessing pipeline achieved a 4.85× speedup and 79% runtime reduction using eight CPU threads. The GPU classifier achieved 78.17% accuracy, a macro-ROC–AUC of 0.773, and throughput of 175,712 beats/s, representing an 11.2× improvement over CPU batch inference. A Digital Twin Readiness Assessment Framework evaluated predictive performance, computational efficiency, scalability, and deployment feasibility. Results indicate that preprocessing and inference satisfy real-time requirements, while classification of minority arrhythmia classes remains the primary limitation. Future work will focus on optimizing the classification model to improve minority-class performance and overall digital twin readiness.
Exploring the Performance Portability of Modern Programming Languages
DescriptionThis poster evaluates the performance portability of Julia, Mojo, Python, and Rust across NVIDIA and AMD accelerators using four scientific benchmarks: seven-point stencil, BabelStream, Hartree–Fock, and miniBUDE. Native CUDA and HIP implementations were ported idiomatically to KernelAbstractions.jl (Julia), Mojo, Triton (Python), and CubeCL (Rust), respectively, and assessed in single and double precision. Results highlight the tradeoffs each language makes with its programming model and compiler design. Although these languages are relatively immature, they demonstrate promising potential for productive, performance-portable high performance computing (HPC) development.
Diamond Agent: Agentic Control of Federated HPC Resources as a Service
DescriptionWe present Diamond Agent, an agentic system that enables intelligent execution of HPC workflows across heterogeneous clusters with typed skills as the interface. Diamond Agent provides an agent-facing workspace and skills that unify cross-site resource discovery, resource specification, data movement, task execution, and result retrieval. A centralized Diamond Agent instance can operate multiple supercomputers without being deployed separately on each login node. Diamond Agent translates high-level agent actions into valid site-specific executions, moves data through Globus Transfer, and uses live system capability and queue information to select feasible placements. Its event-driven continuation mechanism decouples agent actions from long-running batch jobs: persistent services monitor remote execution and resume the agent only when a result or decision-relevant event is available.
PERNIX: High-Throughput SIMD Floating-Point Compression
DescriptionScientific applications increasingly spend time and energy moving floating-point data between CPUs, memory, and accelerators. PERNIX is an open-source C++ library for block-wise floating-point compression and decompression on CPUs, motivated by the transfer and storage of electron repulsion integrals in CP2K. It combines established quantization with novel SIMD bit-packing and unpacking kernels for AVX2, AVX2+BMI2, and AVX-512-VBMI. Table-driven permutations, shifts, and sign extension enable efficient processing of non-byte-aligned widths. ARM NEON and SVE2 backends are under development. We evaluate in-core throughput, cache and DRAM behavior, and end-to-end host-to-device and device-to-host PCIe pipelines. The poster presents the 512-bit format, SIMD design, measured-versus-modeled throughput, and end-to-end transfer results.
VisionHPC: AI Generation of Expert-Level HPC Codes From High-Level Mathematical Abstractions
DescriptionWe present VisionHPC, an agentic AI framework that generates expert-level high performance computing (HPC) code directly from high-level mathematical abstractions. Following extensive expert-guided training, it produces HPC implementations for multicore CPUs and GPUs using widely adopted parallel programming models, including OpenMP, OpenACC, and CUDA/HIP. The framework accepts images of mathematical formulations from three representative scientific domains — linear algebra, partial differential equations, and computational fluid dynamics — and translates them into efficient parallel code. Compared with state-of-the-art multimodal models, including ChatGPT, MathGPT, and Claude, VisionHPC achieves up to 12× higher correctness than the strongest baseline, reaching an average correctness exceeding 95%. These results demonstrate that AI can reliably bridge high-level mathematical descriptions and expert-quality HPC software, substantially improving productivity for scientific software development.
Data Layout and Differentiation for Efficient Training of Physics-Informed Deep Operator Networks
DescriptionPhysics-informed Deep Operator Networks reduce dependence on simulation-generated training data, but their training requires higher-order spatial derivatives at many function-coordinate pairs, causing severe computational and memory costs. We reorganize PI-DeepONet training around its tensor-product structure. Our compact data layout eliminates duplicated Branch inputs and Trunk coordinates, enables GEMM-based contraction, and shares Trunk derivatives among input functions. We further compare forward-mode automatic differentiation, zero coordinate shift, and explicit derivative propagation. In a completed two-dimensional Navier–Stokes benchmark, the optimized implementation achieved a 4.87-fold speedup and a 144-fold reduction in peak GPU memory for a representative case while preserving numerical equivalence. The implementation has also enabled a three-dimensional indoor ventilation demonstration. The poster will present the data layouts and differentiation strategies using schematic diagrams, summarize the complete performance sweep, and show the three-dimensional predicted flow fields as an animation.
HARD: Leveraging FleCSI for Heterogeneous Multi-Material Hydrodynamics
DescriptionSimulating multi-material hydrodynamic systems with disparate equations of state requires maintaining sharp material interfaces without numerical diffusion, a challenge for traditional methods that compromise accuracy or computational efficiency.

In this poster we extend HARD, a multi-material hydrodynamics code built on FleCSI that employs the Ghost Fluid Method enhanced with a multi-material Riemann solver for physically consistent interface treatment. Our novel contributions include sparse data structures reducing memory footprint by 25% and FleCSI backend optimizations enabling exceptional GPU scalability. We achieve 98.3% weak scaling efficiency on 32 CPU nodes and 81.3% on 16 GPU nodes, with single GPU nodes delivering 12.2× speedup over 128-core CPU nodes.

The implementation is complete and validated against analytical solutions and experimental data through shock tube, Rayleigh-Taylor instability, and 3D shock-bubble benchmarks.

Our poster will demonstrate performance metrics, showcase high-resolution 3D simulations, and provide live comparisons between CPU and GPU execution on representative multiphysics problems.
Revisiting Distributed Particle-Based Volume Rendering on Fugaku and Beyond
DescriptionLarge-scale simulations produce substantial data, making data output and interactive visualization costly. We implement and evaluate a distributed particle-based volume rendering (PBVR) workflow on Fugaku that separates CPU-based particle generation from interactive rendering on a GPU-equipped local PC. Building on JAEA's PBVR framework, we integrate in-situ particle generation into OpenFOAM using VTK and KVS. Experiments demonstrate scalability to 110,592 CPU cores (2,304 MPI processes with 48 OpenMP threads each). Separate evaluations on a smaller model show output data reductions of approximately 55%–90%. Although particle generation adds computation, reduced output can offset this overhead by lowering I/O costs. This architecture also offers a model for utilizing available CPUs during GPU-dominated simulations. At the poster session, we will present the system architecture, integration workflow, scalability results, and opacity-dependent data reduction.
Measurement Error for CPU Performance Counters
DescriptionUnderstanding supercomputers’ performance and behavior is critical for their optimization and acquisition. Performance counters, which count the number of various types of CPU events, are the primary means of profiling CPUs. However, they may be inaccurate due to measurement errors. We can identify measurement error if we can calculate the true event count, but the true count is obscured by hardware and software unknowns. We handle hardware unknowns by measuring events that do not depend on the hardware implementation, and we handle software unknowns by carefully configuring standardized benchmarks. While we find measuring errors up to 0.45% of the true count, the measuring errors we find are typically much less than 0.01%.
This content is available for: Technical Program Reg Pass. Upgrade Registration
Towards Scalable and Efficient Deep Learning: Structured Optimization Across Training and Fine-Tuning
DescriptionModern deep learning systems must balance optimization quality against computation, memory, communication, and reliability constraints, whose relative importance varies across supercomputing architectures. This dissertation develops controlled relaxation as a structured optimization strategy: preserve information essential to learning while relaxing costly requirements in synchronization, curvature representation, and parameterization.

The thesis develops this principle through three contributions. AD-KFAC relaxes global synchronization in distributed second-order optimization while retaining curvature information in asynchronous, versioned, and recoverable state. BD-KFAC replaces dense curvature representations with block-diagonal structure, exposing a controllable trade-off between statistical fidelity and resource cost. RRLoRA relaxes the requirement for an uninterrupted low-rank optimization trajectory by periodically refactorizing the learned update and restarting the learning-rate schedule, allowing the parameterization to evolve without discarding accumulated information.

Together, these methods address complementary bottlenecks in distributed second-order training, resource-efficient curvature estimation, and parameter-efficient fine-tuning while preserving the optimization structure that makes each approach effective. The results support controlled relaxation as a systems-aware design principle: preserve signal-carrying structure, relax constraints that impose disproportionate system cost, and keep the resulting approximation or asynchronous state observable and recoverable. This principle offers a practical framework for designing efficient and reliable machine-learning systems on large-scale supercomputing platforms.
This content is available for: Technical Program Reg Pass. Upgrade Registration
Finite-Element Methods and Exascale Algorithms for Fully Relativistic Noncollinear Pseudopotential Density Functional Theory: From Mathematical Formulations to Efficient Computational Realization and Magnetic Materials Applications
DescriptionFully relativistic noncollinear density functional theory (DFT) is essential for simulating spintronic and topological materials but costs 12–30 times more than unpolarized DFT, largely because each electron state becomes a two-component spinor. This cost is dominated by a sparse Hermitian eigenproblem with ~10^8 unknowns and ~10^5 eigenvectors, re-solved every self-consistent-field iteration in complex arithmetic. This thesis co-designs finite-element discretizations, eigensolvers, and GPU implementations within the open-source DFT-FE code.

The central contribution is residual-based Chebyshev-filtered subspace iteration (R-ChFSI), which reformulates the Chebyshev recurrence around the residual so that errors from inexact operations shrink with it. Whereas standard Chebyshev filtering stalls, R-ChFSI converges to residuals of 10^-8 with approximate overlap-matrix inverses and FP32/TF32 arithmetic, making reduced precision and compressed communication safe. On Aurora, combining TF32 filtering with 10–12-bit block-floating-point compression of point-to-point messages accelerates filtering by up to 3.5x and the full ground-state solve by 2.27x over FP64, changing the energy by 1.3x10^-10 Ha/atom.

Band parallelization sustains 94% filtering efficiency when strong-scaling an 11,468-electron system to 384 nodes, and calculations reach 78,988 electrons on 800 Aurora nodes. On CPUs, DFT-FE achieves 8x–10x lower minimum wall time than Quantum ESPRESSO at equal accuracy, and GPU runs need 40x–70x fewer node-hours than CPU runs. The thesis also derives consistent forces and stresses and introduces adaptive-coordinate meshes that reduce energy errors up to 28x at fixed degrees of freedom. These capabilities enable a novel study of how vacancies reshape magnetism in the two-dimensional magnet Fe3GeTe2.
This content is available for: Technical Program Reg Pass. Upgrade Registration
Embrace the Chaos: Harnessing Variability in Accelerator-Rich Systems
DescriptionHPC and ML workload scaling have led supercomputers to deploy large, heterogeneous systems with extreme power limits. Current GPU thermal design power limits (TDPs) range from 1,400–2,000W, scaling to extreme power budgets at scale. Thus, power has displaced performance as the dominant constraint. My research addresses this challenge by co-optimizing power and performance at scale through cross-stack approaches spanning hardware, firmware, systems, and applications.

Power management (PM) causes performance variation across accelerators, making it hard for users to get repeatable performance and for administrators to balance resource utilization. I was the first to characterize GPU variability across production clusters, uncovering consistent variability. This work guided MLCommons' benchmarking effort on handling variability. To harness this variability, I developed PAL, a cluster scheduler that leverages application-specific variability during job placement to optimize latencies and resource utilization.

Further investigating PM, we found GPU power often spikes above TDP (temporarily), triggering frequency throttling that hurts performance. I investigated these power excursions, especially frequent in compute-intensive workloads, and developed solutions that reduce excursions and improve latency.

As workloads rapidly evolve, new workloads often show different excursion characteristics as well as power/performance variability. To adapt our solutions to new, unseen workloads, I developed Minos, which groups similar workloads using power and utilization characteristics while reducing profiling overheads.

Overall, my research demonstrates the critical impact of excursions and GPU variability on large-scale systems. As power constraints intensify and hardware limits are pushed, this cross-stack co-design offers essential techniques to improve power-constrained supercomputing in the future.
This content is available for: Technical Program Reg Pass. Upgrade Registration
Near-Real-Time Performance Visualization of MPI Applications: Integrating Performance Analysis Into HPC Education
DescriptionHigh performance computing (HPC) has become an essential capability in both industrial practice and scientific research, making the acquisition of practical HPC skills an increasingly important objective in higher education. Parallel programming with models such as MPI and OpenMP is central to this training, and students should gain experience on real HPC clusters rather than on local machines. However, universities often have access only to limited, partitioned, or decommissioned cluster resources, while learners must also master operational concepts such as SSH, SCP, and batch-based job management with systems such as SLURM. In addition, efficient MPI programs require performance analysis, yet established tools are designed for experts and assume prior knowledge of instrumentation, measurement, and interpretation.

EduMPI Suite addresses this gap by providing an educational environment for executing and analyzing MPI programs on HPC clusters in near-real-time. It automatically delivers visual feedback on MPI communication events during execution, enabling students to observe program behavior and understand the performance characteristics. A distinctive feature is the visualization of internal algorithmic communication patterns of collective operations, which are often hidden in professional tools but are crucial for understanding the performance implications of collective communication.

Usability evaluations over multiple semesters show that EduMPI Suite lowers the barriers to practical HPC performance analysis, is recommended by students, and improves the success rate of identifying and explaining performance problems to 96%, compared with 60% for professional analysis tools. Its near-real-time performance analysis is enabled by low measurement overhead <3.8% and low query latency <0.09 s.
This content is available for: Technical Program Reg Pass. Upgrade Registration
Towards Resource-Efficient Parallel Concept Drift Detection in Data Streams
DescriptionModern data science increasingly outpaces the efficient use of parallel hardware, creating a need for computational performance engineering. Because HPC tools are not embedded in exploratory data science environments, data scientists lack support for such investigations. This PhD project therefore bridges HPC and data science, using concept drift detection as a case study.

Concept drift—the change in data distributions after ML model deployment—must be detected to ensure robust streaming ML systems. However, the computational overhead of drift detectors (DDs) remains underexplored, even though directly affecting latency, energy consumption, and deployability. This gap motivates the thesis contributions.

First, a framework is introduced for systematically investigating the computational performance of DDs, including complexity analysis, benchmarking and performance analysis. Second, building on this framework, a survey and benchmark evaluate DDs bi-objectively, measuring both runtime and accuracy. The results reveal that computational performance is treated as secondary in the literature, no single detector dominates across scenarios, and higher accuracy consistently requires longer runtimes. Simultaneously, timely drift detection can reduce pipeline runtime by avoiding unnecessary model updates. Third, performance analysis identifies bottlenecks in state-of-the-art DD implementations, particularly inefficient BLAS and OpenMP usage in streaming scenarios. Consequently, the thesis presents MoPEDDs, a modular parallel ensemble of DDs that exploits unused parallel resources improving detection with negligible runtime overhead.

Finally, because performance engineering remains complex for most data scientists, the thesis introduces JUmPER (Jupyter meets Performance). It embeds performance engineering into Jupyter through coarse- and fine-grained monitoring, making HPC expertise accessible where data science happens.
This content is available for: Technical Program Reg Pass. Upgrade Registration
Machine Learning-Based Multi-Objective Optimization for HPC Workload Scheduling
DescriptionAs high-performance computing (HPC) systems reach exascale, schedulers that optimize a single objective, typically throughput, prove inadequate for facilities that must simultaneously manage performance, energy consumption, and resilience under substantial workload uncertainty. This dissertation develops and empirically validates a three-component multi-objective scheduling framework built on graph neural networks (GNNs) and reinforcement learning (RL), testing the hypothesis that graph-structured representations of jobs and system state, combined with adaptive multi-objective learning, outperform traditional and single-objective learned schedulers in production HPC environments. The framework comprises (1) GNN-RL, a graph attention network and PPO-based scheduler encoding job dependencies and resource contention; (2) HARMONIC, a Bayesian uncertainty-aware optimizer that separates aleatoric from epistemic uncertainty and balances performance, energy, and resilience via a multi-objective DDPG agent with Pareto-front guarantees; and (3) EA-GATSched, a GATv2-based scheduler driven by a GEOPM-calibrated physics power model and a state-conditioned Pareto-weighting network. GNN-RL and HARMONIC evaluations are complete: GNN-RL improves utilization by 13.8%–20.2% and throughput by 15.0%–50.0% over EASY-backfilling across 377,234 production jobs on three ALCF systems; HARMONIC reduces energy by 10%–19%, improves throughput by 16%–25%, and cuts performance variability by 18%–32% across simulation and a 64-node testbed. EA-GATSched, the framework's in-progress third component, has achieved 27.3%–56.6% energy reduction and up to 95.8% utilization across 389,604 jobs on the same three systems, with cross-architecture GEOPM validation remaining as future work. These two studies draw on overlapping, not additive, job sets from the same ALCF systems and together establish relational, uncertainty-aware, and physics-grounded learning as jointly necessary for sustainable exascale HPC scheduling.
This content is available for: Technical Program Reg Pass. Upgrade Registration
Real-Time High-Fidelity Bayesian Inference and Forecasting of Tsunamis: A Digital Twin for Tsunami Early Warning Applied to the Cascadia Subduction Zone
DescriptionTsunamis resulting from megathrust earthquakes are rare events that can cause devastating socioeconomic damage and loss of life. State-of-the-art early-warning systems rely on simplified physics models that can be inaccurate for near-field predictions, leading to delayed, missed, or false warnings. Tsunami propagation codes typically use shallow-water equations, which omit coupled ocean-acoustic and surface-gravity wave dynamics, while high-fidelity hydrodynamics codes are too computationally expensive for real-time use. My doctoral research develops a digital twin framework for tsunami early warning that incorporates high-fidelity physics, uses Bayesian data assimilation, and leverages GPU-oriented algorithms to enable accurate, real-time forecasts with rigorously quantified uncertainties for the Cascadia Subduction Zone.

The computational advance is an offline–online decomposition exploiting time-shift invariance in the parameter-to-observable and parameter-to-prediction maps. Their block-triangular Toeplitz structure enables fast Fourier transform-based matrix-vector products, delivering approximately one-hundred-thousand-fold speedups over repeated partial differential equation solves. The Bayesian inverse problem is reformulated in the smaller observation space using the Sherman-Morrison-Woodbury identity, enabling offline factorization and real-time inference.

For a margin-wide Cascadia rupture with 600 hypothetical pressure sensors, the method infers more than one billion parameters and predicts wave heights at 21 locations in under 0.2 seconds on 512 NVIDIA A100 GPUs, a ten-billion-fold speedup over state-of-the-art methods—a breakthrough recognized with the 2025 ACM Gordon Bell Prize. The framework also enables scalable Bayesian optimal experimental design by recasting sensor placement as dense matrix subset selection to minimize uncertainty in inferred seafloor motion or wave-height forecasts. This digital twin paves the way toward accurate, uncertainty-aware tsunami forecasts worldwide.
This content is available for: Technical Program Reg Pass. Upgrade Registration
Subgraph Counting: Methods, Frameworks, and Applications
DescriptionSubgraph counting and matching are core primitives in network analysis, underpinning applications from computational biology to fraud detection to performance analysis in HPC. Existing methods assume static, small networks, rely on hardware-specific kernels that do not scale across the accelerator ecosystem, and emphasize counting over the harder problem of locating pattern instances. This dissertation addresses all three.

We develop ParaDyMS, a parallel method for counting all motifs of size k ≤ 5 on fully dynamic networks under batched edge insertions and deletions. Rather than recomputing from scratch, ParaDyMS updates motif counts incrementally using only the delta induced by a batch of changes. Implemented in the Kokkos C++ Performance Portability ecosystem, ParaDyMS targets both OpenMP and CUDA from one source, achieving up to 124× speedup over the state-of-the-art static method and outperforming 112 CPU cores with a single GPU.

To address hardware portability, we present PyGB-LAPIS, a compilation pipeline lowering graph algorithms written in Python-GraphBLAS through MLIR and the LAPIS backend into Kokkos-flavored C++. PyGB-LAPIS generates kernels across five sparse storage formats and multiple hardware backends from one source, matching hand-written Kokkos performance while eliminating per-backend engineering effort.

Finally, we develop an exact subgraph matching method that decomposes query and host graphs into size-4 graphlets and searches a compressed graphlet-overlap representation. This supports arbitrary-size queries and, uniquely, resolves multiple simultaneous queries in one pass through a shared search tree rather than restarting per query, with the union graph traversed on the fly and pruned by graphlet frequency to control its size.
This content is available for: Technical Program Reg Pass. Upgrade Registration
Efficient Representation Learning for Heterogeneous Systems and Continual Task Adaptation
DescriptionThis dissertation addresses two fundamental challenges in distributed machine learning: client heterogeneity and continual adaptation to new tasks. It develops efficient fine-tuning and representation-learning frameworks that let distributed models acquire new knowledge and align it across clients without communication bottlenecks or catastrophic forgetting.

First, we introduce a dual-distilled federated learning framework for clients with heterogeneous systems and data. Trainable global prototypes with adaptive margins align local representations and logits without requiring a shared model architecture, enabling robust knowledge transfer and stable convergence.

Next, we propose a communication-efficient federated framework for large language models (LLMs) based on representation fine-tuning. By intervening on hidden states rather than weights, and combining All-But-Me aggregation with dynamic test-time computing, it reduces communication cost while balancing local personalization and global generalization.

We then present SETA, a mixture of sparse experts for task-agnostic continual learning in LLMs. SETA resolves the plasticity–stability dilemma by structurally decomposing the parameter space into shared and task-specific experts, protecting shared knowledge from semantic drift while preserving task-specific features.

Finally, we introduce FedSEAM, which extends sparse experts to federated continual learning. Clients learn experts on private task streams, and the server merges them through subspace agreement: it combines only the update directions clients share, keeps disagreeing directions as client-private experts, and protects prior-task subspaces from being overwritten.

Together, these contributions chart a path toward scalable, resource-aware machine learning systems that bridge decentralized efficiency and continual real-world deployment, learning new tasks across privacy-constrained environments without forgetting.
This content is available for: Technical Program Reg Pass. Upgrade Registration
Genome Variant Representation in Genome LMs and Multi-Omic AI: Efficiency, Scalability, and Medical Actionability
DescriptionThe recent rapid growth and curation of large multi-omic datasets, driven largely by high-throughput sequencing, have provided unprecedented opportunities in medical and clinical research, especially for precision medicine. This presents an opportunity for improved multi-omic deep learning implementations for oncology tasks. However, it comes with a set of challenges, namely:

1. Granularity in genomic variant representation: representing complex, arbitrary-length genomic variant data without destroying spatial context or non-coding regulatory signals in both standalone and multi-omic models

2. Scalability and efficiency: establishing efficient and domain-informed data loading strategies, hyperparameter optimization guidelines and computationally scalable architectural choices, especially for resource-intensive medical applications

3. Systematized multi-omic integration: How can we rigorously evaluate multi-omics integration strategies and assess which combinations of omics modalities yield the most informative biological representations for oncology tasks?

To address these issues, we have made the following contributions. First, we developed a feasibility study into the representation of genomic variant data, leveraging genome language models (gLMs) to capture nucleotide-level dependencies across variable-length somatic variant-associated sequences for pan-cancer classification and survival analysis. Next, we scaled our framework to combine both coding exomes and non-coding regions by implementing input load balancing and architectural changes, improving performance on chosen oncology tasks. Finally, we introduced a generalized, versatile, and modular framework that incorporates key autoencoder architectures for representation learning, enabling exploration and robust evaluation of multi-modal omics integration.

The cumulative findings bridge hardware-efficient scaling, biological representation learning, and cancer-specific multi-omics to drive medical actionability.
This content is available for: Technical Program Reg Pass. Upgrade Registration
Foundation Models for Discovery and Exploration in Chemical Space
DescriptionAccurate, rapid prediction of molecular properties remains a bottleneck in materials innovation because experiments and conventional simulations are too costly to explore vast, high-dimensional chemical spaces. Scalable and interpretable molecular foundation models can accelerate discovery across chemical space while using computational resources efficiently. We demonstrate this with MIST, a family of molecular foundation models trained with up to an order of magnitude more data and parameters than prior work. To train MIST we developed Smirk, a tokenizer which preserves nuclear, electronic, and geometric information, enabling representation learning across chemical systems.

The largest MIST model has 1.8B parameters and was trained on 2B molecules. Training such a large model is an expensive endeavor. To make model development tractable on an academic compute budget we developed hyperparameter-penalized neural scaling laws which guided identification of compute-optimal model configurations without exhaustive sweeps at every scale, reducing model-development cost by an order of magnitude.

MIST models have been fine-tuned to predict over 400 structure–property relationships spanning domains from psychophysics to electrochemistry. They demonstrate state-of-the-art benchmark performance and enable real-world applications including stereochemical reasoning for organometallics, olfactory perception mapping, and electrolyte formulation design.

Beyond raw predictive accuracy, using mechanistic-interpretability methods we determine MIST learns chemically meaningful concepts during training. Analysis of token vectors, low-dimensional embedding projections and model logits reveals concept-aligned structures not explicitly labeled during training.

Together, these contributions connect molecular representation learning, compute-optimal scaling, and broad scientific validation, establishing scientific foundation models as robust tools for materials discovery and optimization.
This content is available for: Technical Program Reg Pass. Upgrade Registration
Hardware-Aware Matrix-Free Algorithms for Accelerating Large-Scale Finite-Element Simulations on Distributed CPU and GPU Architectures
DescriptionLarge-scale simulations governed by partial differential equations reduce, after finite-element (FE) discretization, to two kernels: operator action on large blocks of vectors inside eigensolvers, and the solution of Poisson or Helmholtz systems inside linear solvers. Both are limited by data movement rather than floating-point throughput, and the traditional assembled sparse-matrix and cell-matrix strategies scale poorly at high polynomial order, the first bound by memory traffic, the second by an operation count that grows as the sixth power of the order.

This dissertation develops hardware-aware matrix-free algorithms that evaluate operator actions on the fly through sum factorization, batched over the multivector dimension. The contributions are batched FE Helmholtz matrix-multivector products, using even-odd decomposition and SIMD vectorization on CPUs and fused register-blocked kernels on GPUs, a matrix-free Kohn-Sham density functional theory (DFT) Hamiltonian action covering nonlocal projectors, real and complex arithmetic and inline constraint handling on AVX2/AVX-512/SVE CPUs and on GPUs with tensor cores and reduced-precision ghost exchange, a distributed-memory GPU fast-diagonalization solver that inverts the FE Laplacian exactly at O(N^(4/3)) FLOPs, and a device-native fused conjugate-gradient solver with a Chebyshev-Jacobi p-multigrid preconditioner.

Measured inside DFT-FE against existing baselines on Summit, Frontier, Fugaku, Polaris, Pravega and Aurora, the operator actions run 2.6x–5.8x faster than cell-matrix. The fused solve runs 5.86x faster than deal.II on 384 Aurora GPUs, and p-multigrid holds it at 5–7 iterations across polynomial orders. On tensor-product meshes one exact solve is 34x–3,186x faster than p-multigrid. The algorithms assume nothing specific to DFT and carry over to higher-order FE applications.
5:15pm-7pm Skyline Ballroom North Pre-Function
One-Sided: A Portrait of the New OpenSHMEM Standard
DescriptionIn MPI, every memory transfer requires negotiation. The sender announces. The receiver posts a matching receive. Both wait. This is the contract at the heart of parallel communication — and this visualization begins there, in the weight of it: 256 processing elements, bilateral arcs crossing in every direction, a single REQUEST suspended at its target with no response coming.

Then the model changes.

OpenSHMEM eliminates the contract. Any process can write directly into any other's memory. No handshake. No prior agreement. The target is simply — a destination.

This 90-second visualization is a portrait of that principle, built entirely from real benchmark data captured on an HPE internal research cluster: four nodes, 256 processing elements, HPE Slingshot fabric.

The visual language is built around directionality. 256 PEs are arranged in four organic galaxy clusters — Realms α, β, γ, δ, 64 PEs each — with arcs cycling through one source cluster at a time so the viewer can track individual operations to their specific destinations, not interpret a global blur. Periodic spotlights isolate single PE-to-PE operations. The contrast with the MPI opening is deliberate and exact.

The data behind the animation is 500,000 real GUPS operations — Giga Updates Per Second, a standard benchmark for irregular remote atomic writes — captured live on the HPE Slingshot fabric. Each arc is a real operation. The pattern it makes is not designed; it is measured.

The closing act shows the full system in motion, with the GUPS source code, an operation counter climbing to 500,000, and the key argument: this workload cannot be handled without a global synchronization barrier in MPI — a cost that scales with every PE added. In OpenSHMEM, it just runs.
Event Type
Art of HPC
Posters
TimeTuesday, 17 November 20265:15pm - 7:00pm CST
Tags
Art of HPC
Fatal Attraction
DescriptionSupermassive black holes are among the largest objects in the Universe. Their masses range from at least one hundred thousand to many billions of times that of our Sun. In a tidal disruption event, a star is captured by the black hole’s gravitational field.

This artwork illustrates the different phases of destruction of a star by the tidal field of a supermassive black hole.

The right panel combines multiple instants of times highlighting the enormous stretch incurred by the star as it is pulled back toward the black hole.

The left panel shows the star after its first orbit around the black hole. The star is then subsequently destroyed when colliding with its own accretion stream.
Portrait of Data Center
DescriptionA supercomputer has vital signs: a temperature, a metabolism, and a heartbeat. This piece paints them. Streaming GPU telemetry (utilization, power draw, temperature, and interconnect traffic) drives a generative flow field: thousands of particles drift and glow, each colored by heat, brightened by power, their speed set by how hard the machine is thinking. Nothing is invented; every gesture is a reading of the machine's own body.

The work is deliberately multi-dimensional. One dimension is data, which is the honest mapping of live signals to light. Another is choreography, drawn from Martha Graham's foundational language of modern dance: contraction and release. Graham built movement from the body's core, a gathering inward that coils tension, then an expansive release outward. Here the machine's heartbeat performs exactly that: on each slow breath the particles are drawn toward the core, gathering; then, on the release, they are expelled outward in a bloom of light and sparks, timed to the pulse. As load climbs from idle to peak, the breath deepens and the release becomes a throw. A supercomputer that is moving through its own register, from rest to full, dramatic exertion.

The third dimension is metaphor: the data center as a living, feeling body, its telemetry the score to which it dances. By borrowing Graham's grammar of gather-and-expel, the piece asks the audience to read a machine not as cold infrastructure but as a performer; one whose choreography is authored not by a human hand but by the physics of computation itself. High performance computing, rendered as contemporary dance.
Event Type
Art of HPC
Posters
TimeTuesday, 17 November 20265:15pm - 7:00pm CST
Tags
Art of HPC
2011 Tōhoku–Oki Earthquake and Tsunami: Dynamic Rupture and Acoustic–Gravity Simulations
DescriptionThis video visualizes data obtained from large-scale earthquake and tsunami simulations based on a dynamic rupture model of the 2011 Tōhoku–Oki earthquake, a magnitude 9.1 megathrust earthquake in the Japan Trench that caused over 20,000 deaths and $300B in damages. The 3D dynamic rupture simulation (Wong et al., Nature Communications, 2026) computes the seismic wave propagation in the Earth, generating the earthquake-induced seafloor motion that is visualized by the seafloor velocity and seafloor displacement fields in the video. These seafloor motion data are used as an input to a 3D acoustic–gravity simulation that computes the coupled ocean acoustic and tsunami wave propagation, which is visualized by the sea bottom pressure and surface wave height perturbations. The implementation of these earthquake and tsunami models is an integral part of an ongoing effort to develop a digital twin for tsunami early warning in the Japan Trench. This work is an extension of the Cascadia Subduction Zone digital twin that was recognized with the ACM Gordon Bell Prize at SC25 (Henneking et al., SC25 Proceedings, 2025).
An Exascale Universe in Warm and Cool
DescriptionThis image opens onto a world that feels at once immense and intimate: a turbulent landscape constructed from data generated by one of the largest cosmology simulations run on exascale supercomputers. Vast orange forms move across the frame like heated clouds, molten currents, or a weather system caught mid-motion. Cooler blue structures gather around and beneath them, forming translucent streams and pockets that suggest an opposing climate. Their overlap turns temperature into a visual conversation — warm and cool masses pressing together, passing through one another, and creating a layered terrain with no familiar ground or horizon.

The orange and blue bodies are isosurfaces extracted from temperature data: boundaries that give form to conditions that cannot ordinarily be seen. Their fine wireframe skins deliberately retain the visual language of early computer graphics. Rather than conceal the construction of the image behind smooth, seamless surfaces, the mesh makes the digital scaffold visible. It recalls the moment when computer-generated worlds announced themselves through grids, polygons, and luminous lines — an artificial landscape honest about the machinery that makes it possible.

Across this shifting terrain, small magenta, violet, and pale spheres drift like beads, sparks, or distant lights. Each represents an element from the simulation and can stand for an extraordinary amount of matter — many solar masses compressed into a point of visual scale. Individually, they appear delicate; collectively, they trace a crowded and intricate environment.

By combining translucent temperature forms, deliberately exposed polygonal meshes, and floating matter, the work lets computational data become a place to linger. It invites the viewer to move between recognition and uncertainty: to see clouds, currents, constellations, and cellular structures, while remembering that the landscape is entirely constructed from a numerical model. The result is an artificial world with its own texture, atmosphere, and visual history — an image where calculation becomes environment.
JASMIN in July (Per Day): Brownian Bouquet
DescriptionThis artwork explores the computational life of JASMIN, a UK research computing facility supporting environmental and Earth-system science. Rather than presenting activity as a conventional graph or dashboard, it translates the rhythms of a month of work on the facility to an abstract visual form.

In Brownian Bouquet, each "spindle" form is a polar representation of Brownian motion representing one day in the month of July where normalized power and job statistics were used to set the parameters controlling the Brownian motion and its relative appearance.

As with its sister piece Stochastic Sea (which instead plots one spindle for one hour), characteristics of JASMIN's computational workload from July 2026 are mapped to different properties of each spindle. Power consumption controls its overall scale; the number of completed jobs controls the variance and resulting diffuseness of its Brownian trajectories; running jobs control the number of points used to construct those trajectories; pending jobs determine their rotation; and failed jobs select the color palette. Each metric is independently normalized over the range observed in the dataset before being mapped to the corresponding visual parameter, to create an abstract piece which can be interpreted as a physical form, in this case a bouquet of flowers. The flower-like nature is encouraged by coercing the spindle centers into a sunflower-inspired pattern.

Brownian Bouquet invites the viewer to see computational infrastructure not simply as an invisible technical resource, but as a dynamic system where countless individual processes combine to produce rhythms, fluctuations and patterns at a larger scale. The work deliberately occupies the space between data visualization and abstract art.
Event Type
Art of HPC
Posters
TimeTuesday, 17 November 20265:15pm - 7:00pm CST
Tags
Art of HPC
Entropy on the Edge of Collapse
DescriptionThis is a dynamical rendering of a detailed three-dimensional simulation of the explosion of the very-rapidly rotating core of a massive star that is exploding as a supernova. Rapid rotation leads to a powerful jet-like explosion along the two poles, accompanied by the generation and tangling of strong magnetic fields. This movie depicts the earliest phases of the supernova explosion that is simultaneously giving birth to a rapidly rotating radio pulsar.
Event Type
Art of HPC
Posters
TimeTuesday, 17 November 20265:15pm - 7:00pm CST
Tags
Art of HPC
Oil on Canvas: Galactic Center on Palette
DescriptionMy painting (Oil on Canvas) translates a radio-astronomy observation of our galaxy's heart into a dusky, nebular atmosphere, its aubergine and violet field that surrounds the Milky Way's core.

The source of my interpretation of the galactic center stemmed from discussions with Prof. Florina Ciorba from the University of Basel (UniBas), Switzerland, who is the co-founder member and PI of the UniBas node of the SKACH project — The SKA (Square Kilometre Array) of Switzerland Consortium (SKACH, https://skach.org/about-skach/). The underlying data comes from the 1.28 GHz MeerKAT galactic center mosaic created by Heywood et al. (2022), released by the South African Radio Astronomy Observatory (SARAO). The image that inspired me and my painting is a re-rendered version by J.C. Muñoz-Mateos and branded by SKACH (the Swiss SKA Consortium) and SKAO (the Square Kilometre Array Observatory).

https://science.nasa.gov/asset/webb/milky-way-center-meerkat-and-webb/
Simulation of Tungsten Transport in the ASDEX-U Tokamak Plasma
DescriptionSimulation of tungsten transport in the ASDEX-U tokamak plasma reveals critical insights for fusion reactor design. Tungsten, used for its heat resistance, ionizes during operation and can penetrate the core, radiating energy and reducing efficiency. These simulations explore the interaction of tungsten ions with rotation and light impurities like boron and helium in the complex edge region near the wall. The study highlights the role of binary collisions and asymmetries in tungsten penetration. Confidence in the model is bolstered by recent validation on a separate physics problem.
Event Type
Art of HPC
Posters
TimeTuesday, 17 November 20265:15pm - 7:00pm CST
Tags
Art of HPC
Open Polarity
DescriptionThis image depicts the 3D structure of the Sun's open coronal magnetic field from a snapshot of the “Live Prediction” HPC simulation developed by Predictive Science Inc. as part of their research for the August 12, 2026, total solar eclipse. See eclipse.predsci.com for more details on the simulation, which was created using the Magnetohydrodynamic Algorithm outside a Sphere Fortran code (github.com/predsci/mas) at a resolution of over 50 million cells. It ran faster than real time using 24 128-core EPYC Turin 9745 CPUs (3,072 total cores) on NASA's Athena supercomputer.
Event Type
Art of HPC
Posters
TimeTuesday, 17 November 20265:15pm - 7:00pm CST
Tags
Art of HPC
Flow Through a Pebble-Bed Reactor in NekRS
DescriptionThe pb146 case in NekRS is a benchmark computational fluid dynamics problem that simulates flow through a packed bed of 146 spherical particles, representing a simplified pebble-bed reactor geometry. It features a densely packed arrangement of spheres inside a cylindrical domain, producing complex flow behavior with tight gaps, recirculation zones, and turbulent interactions that are challenging to resolve numerically. Using NekRS’s high-order spectral element method, the case captures detailed boundary-layer physics and serves as a realistic yet standardized workload, making it widely used for testing solver accuracy, scalability, and performance on GPU-based high performance computing systems.
Fulfillment: Artistic Encounters with the Hidden Labor and Environmental Footprint of High Performance Computing
DescriptionHigh performance computing (HPC) has become one of the defining infrastructures of contemporary society. Beyond enabling scientific discovery, HPC increasingly powers artificial intelligence, climate modeling, logistics, digital commerce, autonomous systems, and large-scale simulation. Despite its transformative role, HPC largely remains invisible to the public, obscuring the vast networks of human labor, material extraction, energy consumption, and environmental impact required to sustain computational infrastructures.

This project argues that artistic practice can make HPC visible, not only by visualizing scientific data, but by revealing the social, ecological, and political systems in which computational infrastructures are embedded. Rather than treating HPC solely as a technological achievement, the work positions it as part of a cultural-material landscape whose hidden operations shape everyday life.

Fulfillment is an interdisciplinary virtual reality artwork developed at the Electronic Visualization Laboratory (EVL), University of Illinois Chicago, in collaboration with anthropologists, designers, and computer scientists from several research institutions spanning the U.S., Europe, and Asia with support from the National Science Foundation. This proposal is for a public exhibition of the Fulfillment project as part of the Art Gallery Program at the SC26 conference. While the original work investigates global logistics and supply chain capitalism, this exhibition reframes those systems through the computational infrastructures that increasingly govern them. Warehouses, AI-driven optimization, cloud computing, data centers, predictive algorithms, and real-time simulation are presented as interconnected expressions of contemporary HPC ecosystems.
Biological Interfaces
DescriptionWater at biological interfaces contributes substantially to the mechanical behavior of membranes, yet how it responds to mechanical stress is not well characterized. This artwork was developed from molecular simulations, which examined how lateral tension influences interfacial water in lipid model membranes representative of mammalian and bacterial composition under physiological conditions.

In the resting state, interfacial water organizes into hydrogen-bonded networks, with small ring-like arrangements linking adjacent lipid. In the video, these ring-like arrangements are highlighted by the glowing planes between golden spheres. When lateral stress is applied, these arrangements persist in one mammalian membrane type, while in the other, stress-induced flattening of the membrane surface causes interfacial water to become partially decoupled from the lipid interface. This differential behavior points to a close relationship between a membrane's mechanical properties and the structural organization of its associated water network, offering insight into the mechanisms by which interfacial water contributes to membrane resilience under mechanical load. Whilst the video is mostly for aesthetical purposes, the findings of the molecular simulations suggest that interfacial water is not merely a passive boundary layer but an active participant in membrane stability that responds dynamically to stress, with implications extending across biophysics, drug design, and the study of biological adaptation.
Event Type
Art of HPC
Posters
TimeTuesday, 17 November 20265:15pm - 7:00pm CST
Tags
Art of HPC
Spiral Wave: The Heart's Chaotic Dance
DescriptionA spiral of crimson, gold, mocha, and magenta moves through the heart, tracing the electrical activity that coordinates every heartbeat. Here, that rhythm has broken down. The spiral is a rotor, a self-sustaining electrical wave that drives atrial fibrillation, one of the most common and dangerous cardiac arrhythmias.

Every frame is generated directly from a high-performance cardiac electrophysiology simulation. The left atrium is modeled as a large network of electrically coupled tissue, simulated in near real time using custom CUDA code running on NVIDIA GPUs. This computational framework allows researchers to investigate how atrial fibrillation begins, evolves, and responds to targeted intervention.

The colors are not arbitrary; they are the language of physiology. Crimson marks tissue at rest, ready to activate. Gold follows the wave of depolarization as it propagates through the muscle. Mocha and magenta represent the refractory period, when the tissue is recovering before it can fire again. In this simulation, the refractory period is shortened, and a precisely timed electrical stimulus initiates the spiral wave.

Spiral Wave lives at the intersection of computation, medicine, and art. Every color, every curve, and every swirl emerges from the underlying physics of cardiac tissue. Nothing in this animation was designed to be beautiful. It simply is.
Antarctica: Looking Through the Ice Into the Past
DescriptionThis work is an interdisciplinary collaboration between artists, designers, scientific researchers, and visualization experts. The team aimed to address two primary objectives. To start, we incorporated the human language of art to set the foundation for science communication to open the conversation between communities and the scientific endeavors of the scientist, a part of the NSF Center for Oldest Ice Exploration (COLDEX). The second aim was to assist the team, Dr. Duncan Young and colleagues, in understanding the ice sheet layers they are currently studying.

Dr. Duncan Young and colleagues use airborne ice-penetrating radar, gravity, and magnetic surveys to image the internal structure of the East Antarctic Ice Sheet and the geology hidden beneath more than three kilometers of ice. Their work spans three key regions of East Antarctica — the South Pole region, Dome A, the Allan Hills, and Dome C. These measurements reveal how ice has flowed, deformed, melted, and interacted with the underlying landscapes over millions of years. One of their primary goals is to locate regions where the oldest continuous ice has remained preserved and to understand how the ice sheet layers have changed over time to predict future movements.

Incorporated in the video are artistic representations of the data reflecting the ice sheet layers of Antarctica. These scientifically directed visualizations of the data were transformed into 3D prints that proved to be valuable in communicating with colleagues to determine the next drilling site in Antarctica to test hypotheses. Additionally, the 3D printing allowed the scientists to see and hold a physical representation of their findings.
Event Type
Art of HPC
Posters
TimeTuesday, 17 November 20265:15pm - 7:00pm CST
Tags
Art of HPC
Morphogenesis
DescriptionLong before computers, Alan Turing asked how a smooth egg becomes a spotted, striped, branching creature. His answer, reaction-diffusion, is the chemistry of pattern itself. Here that chemistry runs as living paint: two competing substances diffuse and react across a field, blooming into coral, fingerprints, dividing cells, and restless worms, cycling endlessly through nature's vocabulary of form.

But look closely, and the field is split into three vertical territories, each a separate GPU. The luminous seams between them are the secret of large-scale simulation: the halo exchange, where neighboring processors trade their edge values every timestep so the pattern can flow seamlessly across boundaries. Gold packets pulse along the seams and communication is made visible.

This is how we simulate weather, galaxies, and combustion: cut reality into pieces, solve each in parallel, and stitch the edges back together. The pattern is the phenomenon; the seams are the high performance computing. Turing's morphogenesis is computed the way modern science actually computes it.
Event Type
Art of HPC
Posters
TimeTuesday, 17 November 20265:15pm - 7:00pm CST
Tags
Art of HPC
Vortex Bubbles in Anabatic Upslope Flow During Morning Transition
DescriptionSea of bubbling vortices arising in upslope (anabatic) flow at a slope angle of eight degrees after sudden imposition of surface heat flux against a constant ambient stratification. This serves as a simplified model for the morning transition from nighttime downslope (katabatic) drainage to daytime upslope flow occurring during sunrise in valleys or mountains when solar radiation starts to heat up the sloped terrain, reversing the buoyancy and pressure gradients established during the cooler nocturnal conditions. Flow shown here is in an intermediate regime between laminar and fully turbulent.
Event Type
Art of HPC
Posters
TimeTuesday, 17 November 20265:15pm - 7:00pm CST
Tags
Art of HPC
Boiling the Ocean ... Literally
DescriptionThe video shows monthly averaged sea surface temperature anomalies in the North Atlantic since 1980. The colors represent warming and cooling up to 2026 compared to the monthly averages from 1980 to 1995. The visualization highlights the rapid speed at which our oceans have been warming in a period of just over 45 years.

The video was made as realistic as possible with satellite imagery, realistic atmosphere thickness and density, a topography map and the use of ray-traced renders to present the data as realistically and prominently as possible.
Event Type
Art of HPC
Posters
TimeTuesday, 17 November 20265:15pm - 7:00pm CST
Tags
Art of HPC
Radiation: When Steels Fall Apart
DescriptionThis visualization uses a high performance computing-based workflow to reveal the atomic-scale structure of neutron-irradiated steel. Highlighted in the image are nanoscale defects and chemical features that formed or evolved as a result of irradiation.

The specimen examined in this study was prepared from an HT-9 alloy irradiated to 0.68 displacements per atom (dpa) at 478 degrees Celsius in Idaho National Laboratory’s Advanced Test Reactor. The visualization combines two correlative datasets collected from the same specimen: a two-dimensional image acquired using transmission electron microscopy (TEM) and a three-dimensional dataset acquired using atom probe tomography (APT).

The combined datasets reveal several complex microstructural features associated with radiation damage. These include spherical clusters enriched in nickel and silicon, dislocation lines decorated with solute clusters, and a grain boundary exhibiting radiation-induced solute segregation. The dataset also captures a pre-existing vanadium nitride precipitate. Characterizing these features is important because they can influence the physical and mechanical properties of the alloy.

Using high performance computing and advanced deep-learning methods, this image-based workflow improves feature identification and enables more accurate spatial correlation of the complementary TEM and APT datasets. The multimodal computational model under development uses structural information obtained from TEM to support further analysis of the APT dataset and improve the identification and characterization of solute clusters.

This visualization is composed entirely of experimental data obtained from TEM and APT measurements. Rendering the datasets in this form allows researchers to more effectively interpret correlative measurements, identify and analyze complex radiation-induced features, validate computational methods, and communicate scientific findings.
Ligand Dynamics Control Structure, Elasticity, and High-Pressure Behavior of Nanoparticle Superlattices
DescriptionThe spherical clusters in this image are a molecular dynamics simulation of lead sulfide nanocrystals, each seven nanometers wide, coated with radiating oleic acid ligands that allow such particles to self-assemble into an ordered crystal called a nanoparticle superlattice. The underlying research found that below a critical ligand coverage density, nanoparticles collapse and fuse together, while above it, the ligand layer cushions the structure enough to withstand applied pressures up to nearly 56 gigapascals while largely retaining its ordered arrangement. The image renders this simulated nanoscale structure alongside additional micrographs of nanoparticle superlattice material from the same body of research.
Event Type
Art of HPC
Posters
TimeTuesday, 17 November 20265:15pm - 7:00pm CST
Tags
Art of HPC
Colourful Wind Assistance
DescriptionThe video shows the flow past two wing sails arranged in tandem, representative of wind-assisted propulsion devices. The simulation was performed with x3d2, a high-order finite-difference incompressible-flow solver developed within the Xcompact3d framework (https://www.incompact3d.com). The simulation uses the immersed-boundary method to represent the foil geometry, together with non-periodic streamwise inflow/outflow boundary conditions and periodic transverse boundaries.

The calculation uses a uniform Cartesian mesh of approximately 381 million grid points. Based on the wing-sail chord and imposed inflow velocity, the Reynolds number is approximately 28,000. The case is an illustrative demonstration of the numerical methodology rather than a full-scale wing-sail prediction. Simulations were run in double precision on an NVIDIA Grace Hopper GH200 GPU using x3d2’s CUDA backend.
JASMIN in July (Per Hour): Stochastic Sea
DescriptionThis artwork explores the computational life of JASMIN, a UK research computing facility supporting environmental and Earth-system science. Rather than presenting activity as a conventional graph or dashboard, it translates the rhythms of a month of work on the facility to an abstract visual form.

In Stochastic Sea, each "spindle" form is a polar representation of Brownian motion representing one hour in the month of July where normalized power and job statistics were used to set the parameters controlling the Brownian motion and its relative appearance.

As with its sister piece Brownian Bouquet (which instead plots one spindle for one day), characteristics of JASMIN's computational workload from July 2026 are mapped to different properties of each spindle. Power consumption controls its overall scale; the number of completed jobs controls the variance and resulting diffuseness of its Brownian trajectories; running jobs control the number of points used to construct those trajectories; pending jobs determine their rotation; and failed jobs select the color palette. Each metric is independently normalized over the range observed in the dataset before being mapped to the corresponding visual parameter, to create an abstract piece which can be interpreted as a physical form, in this case suggestive of a filamentary superstructure such as galactic super-clusters or a network of synapses. The spindle centers are randomly distributed across the composition, reinforcing this impression of a complex, interconnected structure.

Stochastic Sea invites the viewer to see computational infrastructure not simply as an invisible technical resource, but as a dynamic system where countless individual processes combine to produce rhythms, fluctuations and patterns at a larger scale. The work deliberately occupies the space between data visualization and abstract art.
Event Type
Art of HPC
Posters
TimeTuesday, 17 November 20265:15pm - 7:00pm CST
Tags
Art of HPC
Where Data Becomes Light: The Beauty of Scientific Visualization
DescriptionWhere Data Becomes Light is a digital light projection and immersive visual experience that celebrates the beauty of science through contemporary visualization. On view nightly, Thursday through Sunday, at THE MART (artonthemart.com) September through mid-November, the large-scale imagery transforms the 2.5-acre building façade into a luminous canvas, where sweeping animations and vivid imagery inspire curiosity and wonder, and invite audiences to witness the elegance and complexity of the natural world through modern scientific computing.

Scientific discovery often begins with numbers, signals, and equations, but its deepest insights emerge when those patterns become visible. Scientific visualization transforms complex data into images that reveal structure, motion, and meaning, allowing us to see phenomena that would otherwise remain hidden. In these images, turbulence becomes choreography, molecular interactions resemble intricate architecture, and the evolution of galaxies unfolds like a vast celestial landscape.

Like Art of HPC, Where Data Becomes Light celebrates creativity and beauty in computational science. The projection includes several works from past SC Art of HPC exhibits and Scientific Visualization and Data Analytics Showcases, bringing the SC community's work to the city's skyline.

The Collaboration

For decades, researchers have used visualization to transform massive datasets into images that reveal patterns hidden in raw numbers. As high-performance computing has grown in prominence to address the biggest challenges in science and engineering, Argonne National Laboratory has played a key role in this evolution, operating world-class supercomputers and producing visualizations that illuminate everything from the structure of materials and the behavior of turbulent flows to the formation of galaxies and the dynamics of climate systems.

At the same time, the Electronic Visualization Laboratory at the University of Illinois Chicago helped define the modern field of visualization. EVL researchers’ work contributed to the landmark National Science Foundation report on scientific visualization, which helped establish visualization as a critical component of scientific discovery. EVL’s innovations in immersive visualization environments and collaborative visual computing have expanded the ways scientists and the public experience complex data.

Join us for a special screening during SC26:

Wednesday, November 18, 2026
7:30-8:00 pm
THE MART, Chicago Riverwalk between Wells and Franklin Streets
The Oracle at DKRZ
DescriptionThis video is a visualization of the algorithm used to generate "prophecies" from machine code — that will form part of a sculptural installation to be exhibited at the German Climate Computing Centre (DKRZ).

The work situates climate modeling in the broader, non-scientific history of humanity's attempts to grapple with the future. By reinterpreting the binary of the ICON climate model into words, and searching for where those words combine into statements about the future, ICON is reimagined as a modern-day oracle. The algorithm's lexicon comes from English translations of classical Greek texts. In these fictions, prophecies are true, and are intertwined with the distinct tragedy of not being believed or acted upon — a startling parallel to humanity's lackluster response to the climate crisis.

Inspiration for the project came through conversations with scientists at DKRZ; about the computation and storage of data, as well as the Centre's role in scientific research and weather prediction. On the computational side, the ability to abstract almost anything into a string of zeros and ones highlights a wonderful symmetry: if anything can be binary, then binary can be anything. From this perspective, binary becomes an interface between seemingly disparate media and raises questions about how the systems we use to interpret data give rise to meaning.

The connection to a history of fortune telling was developed through understanding the role DKRZ plays within the scientific landscape. The vast array of resources spent in the construction and maintenance of its supercomputers is a testament to how far humanity will go to fulfill a specific need — to know what the future will be like. From this perspective, it represents an incredibly sophisticated approach to something humans have been doing throughout history and across civilizations. The rulers of city-states in Ancient Greece would climb the steps to the Oracle at Delphi seeking counsel. Now, various clients come to DKRZ, looking to use its computing power for projections on the weather and climate.
You Only Have Seven Seconds
DescriptionYou Only Have Seven Seconds is a poetic, human–AI collaborative documentary that unfolds as both a visual archive of an internationally exhibited installation and a cinematic experiment in memory preservation. Against the backdrop of rising Alzheimer’s cases and the emergence of machine-generated false memories, the film reimagines remembrance through the lens of artificial intelligence.

Inspired by her grandmother’s cognitive decline, the artist developed a custom AI system that transforms fragmented spoken recollections into synthetic visual sequences. Presented as an interactive AI art installation, the project ReCollection has traveled worldwide, welcoming thousands of visitors to whisper their fading memories — each within seven seconds — into the artwork and generate visual memories in real time. These memories form the foundation of an evolving archive, constructed through speech recognition, text auto-completion, and text-to-image generation.

Drawing from this archive, the film incorporates emerging speech-to-video technology to weave a collective, culturally diverse montage of love and loss. The participatory datasets are curated to build dialogical relationships, forming patterns, counterpoints, and resonances that evoke a poetics of relation. Initially conceived as a personal reflection, the work has evolved into a living, breathing, shared world-building experience that reassembles the ephemeral past into a dynamic portrait of collective human selfhood.
A Study of 4D Julia Sets: Iterations of Z = Z2 + K in the Quaternions
DescriptionCreated in 2005, this work is an exploration of quaternion Julia sets. Quaternions are a four-dimensional number system.

Real numbers: 1 dimension — ( a )
Complex numbers: 2 dimensions — a + bia + bia + bi
Quaternions: 4 dimensions — a + bi + cj + dka + bi + cj + dka + bi + cj + dk

A quaternion Julia set is the set of starting points ( (a, b, c, d) ) whose iterates remain bounded (they do not escape to infinity). Complex Julia sets typically appear as curves or fractal lines in the plane. Quaternion Julia sets live in four dimensions; the slices we can see often appear as evolving 3D solids. This animation explores those solids as the parameters that generate the set are changed. Motion through the 4D parameter space is created with Hermite splines connecting successive 4D target values. For much of the work, new targets are set every four seconds, producing a slow largo pace of about 60 beats per minute.

Credits

Animation: Dan Sandin
Algorithms: John Hart, Yumei Dang
Programming: Dan Sandin, Shalini Venkataraman
Visionary Leadership: Tom DeFanti
Mathematical Leadership: Louis Kauffman
Music Composition and Performance: Stephan Vankov

Produced at the Electronic Visualization Laboratory, UIC, and Calit2, UCSD
INSTRUMENT | One Antarctic Night
DescriptionINSTRUMENT | One Antarctic Night (IOAN) is a multi-player VR experience that brings the rhythms of the cosmos to life in an endless remix instrument. Created from 758,457,209 magnitude readings for 817‚373 astronomical objects captured by the AST3 robotic telescopes in Antarctica, the experience transports players inside of a field of objects at the heart of the Large Magellanic Cloud. Within a multiplayer VR arena, and floating inside a luminous field between the Earth and the Large Magellanic Cloud, multiple players explore and collaboratively create new visual and sound remixes to perform the AST3 dataset as a soundscape for external visitors to the VR arena. The collaborative experience is inspired by communal percussion and multiplayer instruments. Real-time database queries, selections, and filtering operations enable multiple players in VR to collaboratively interact with the objects in the field to create data remixes from astronomical data. Visitors to the arena see and hear the virtual world in correct spatial relation to their real-world positions through spatialized 4K portals and spatialized ambisonic audio that align the physical space of the arena installation with the inner space of the multiplayer virtual environment.