Papers for

high-performance computing teams

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

WaferTetris boosts chip use and speeds AI tasks on wafer-scale hardware

WaferTetris: Efficient Freeform Mapping on Wafer-Scale Accelerators

Abstract: Wafer-scale accelerators offer massive compute capacity through hundreds of thousands of processing elements (PEs) interconnected across a single wafer, but realizing this potential requires efficient application mapping. Their scale makes programming these systems and mapping applications onto them challenging. Existing approaches rely on template-based mappings to maintain productivity, but these templates restrict the mapping design space. In particular, they impose fixed geometric layouts over the PE grid, often leaving compute and memory resources underutilized. In this work, we present WaferTetris, a system that removes these geometric restrictions through freeform mapping. Its Tetris-like strategy flexibly packs computation across the wafer, improving PE utilization and usable memory capacity while preserving PE-task code. We develop a recurrence-based throughput model that captures branch-and-join dependencies to guide spatial parallelism, and an architecture model with per-color gates that enable existing FPGA place-and-route algorithms to enforce WSE routing constraints. We evaluate WaferTetris on Cerebras WSE-3 using LLM decoding and scientific stencil benchmarks. For LLM decoding, it achieves up to $4.42\times$ the system throughput of a template-based automatic mapping baseline on the same fabric size. Compared with the manually optimized WaferLLM, WaferTetris supports $1.8\times$ the context length for LLaMA3.1-8B (80k versus 44k), while delivering equal or higher per-user throughput at matched context lengths, up to $1.10\times$.

Fri 13 NovHardware ArchitectureComputation and Language
The gist
Wafer-scale computer chips have thousands of tiny processors that work together, but putting tasks onto these chips efficiently is tough. Most ways to organize these tasks force fixed shapes and layouts, which wastes power and memory. The authors created WaferTetris, a method that fits tasks like Tetris pieces onto the chip more flexibly. This better use of space helps run big AI models and scientific calculations faster and with more memory. Their tests show WaferTetris can increase speed and support longer AI model contexts than other methods.
Open → 2611.18527v1

Parallel algorithm speeds up approximate maximum-product matching in bipartite graphs

Dual-Slack Frontier Matching: Parallel Approximate Maximum-Product Matching

Abstract: Maximum-product bipartite matching supports scaling and static pivot selection in sparse matrix preprocessing. We present Dual-Slack Frontier Matching (DSFM), a deterministic, shared-memory parallel algorithm for approximate maximum-product matching. Motivated by heavy matchings on small candidate supports, DSFM searches progressively exposed subgraphs ordered by fixed dual slack. Slack-ordered certified completion guarantees a perfect matching whenever one exists, or a maximum-cardinality matching with a Hall certificate otherwise. Every returned perfect matching carries an a posteriori geometric-mean quality bound; accumulated Hall obstructions can tighten this bound and improve the returned scaling. We compare DSFM with Heavy-Weight Perfect Matching (HWPM) and exact MC64 assignment on 598 nonsingular matrices. DSFM attains higher matching quality than HWPM over most quality thresholds. On a set of large instances consisting of 37 matrices, DSFM achieves a $3.53\times$ geometric-mean speedup over MC64, compared to $2.29\times$ for HWPM.

Thu 12 NovData Structures and Algorithms
The gist
Finding the best way to pair items from two groups, like matching workers to jobs, is a key problem in computer science. This paper presents a new algorithm called Dual-Slack Frontier Matching (DSFM) that quickly finds nearly optimal pairings using multiple processors at once. The authors show that their method is often faster and produces better matches than previous approaches when tested on many matrices. The algorithm also provides guarantees about the quality of the matches it finds.
Open → 2611.17502v1

Multi-gpu system boosts quantum error-correction simulation speed

Scaling Pêlagos: Multi-GPU Orchestration for Relay Belief-Propagation Decoding

Abstract: Fault-tolerant quantum computing requires quantum error-correction (QEC) decoders that achieve low logical error rates under real-time operating constraints. These constraints motivate heuristic decoding algorithms whose error-correction performance must be evaluated through large-scale simulation. High-throughput decoding accelerates this evaluation and the exploration of decoder parameters. Using multiple graphics processing units (GPUs) is a natural way to scale these simulations, but naively distributing syndrome batches introduces host-side preprocessing and output-collection overheads that limit scaling. To address these limitations, we extend the Pêlagos relay belief-propagation (Relay-BP) decoder with process-isolated orchestration, parallel host preprocessing, and shared-memory output. We evaluate both one-gross ($[[144,12,12]]$) and two-gross ($[[288,12,18]]$) codes in a multi-GPU environment. Specifically, for the one-gross circuit at $R=50$, eight AMD Instinct MI300X GPUs and eight AMD Instinct MI355X GPUs achieve optimized end-to-end speedups of $5.68\times$ and $6.23\times$, respectively. For the two-gross circuit, the corresponding speedups are $6.92\times$ and $7.01\times$. When throughput is calculated using GPU decoding time, the corresponding two-gross speedups are $7.58\times$ and $7.45\times$, indicating near-linear GPU scaling. We deploy Pêlagos on Lux, Oak Ridge National Laboratory's AMD Instinct MI355X-based supercomputer, as a pathfinding application for high-throughput QEC simulation. This deployment provides a concrete quantum-computing use case for the AI + HPC infrastructure supporting the Genesis Mission's scientific-discovery goals. These end-to-end measurements demonstrate a practical path to accelerating large-scale QEC simulation through efficient multi-GPU decoding.

Thu 12 NovEmerging Technologies
The gist
Running simulations to improve quantum computers involves decoding complex errors quickly. The authors improved a method called Pêlagos by using multiple graphics cards (GPUs) working together more efficiently, reducing delays and speeding up the process. Their tests showed that using up to eight GPUs nearly multiplied the speed by seven times compared to one GPU. This helps researchers test and develop quantum error correction faster, which is important for building reliable quantum computers.
Open → 2611.16285v1

Bit-sparsity aware hardware speeds up generic matrix multiplication

Bit-Sparsity Aware Acceleration with Compact CSD Code on Generic Matrix Multiplication

Abstract: The ever-increasing demand for matrix multiplication in artificial intelligence (AI) and generic computing emphasizes the necessity of efficient computing power accommodating both floating-point (FP) and quantized integer (QINT). While state-of-the-art bit-sparsity-aware acceleration techniques have demonstrated impressive performance and efficiency in neural networks through software-driven methods such as pruning and quantization, these approaches are not always feasible in typical generic computing scenarios. In this paper, we propose Bit-Cigma, a hardware-centric architecture that leverages bit-sparsity to accelerate generic matrix multiplication. Bit-Cigma features (1) CCSD encoding, an optimized on-chip sparsification technique based on canonical signed digit (CSD) representation; (2) segmented dot product, a multi-stage exponent matching technique for long FP vectors; and (3) the versatility to efficiently process both FP and QINT data types. CCSD encoding halves the cost of CSD encoding while achieving optimal bit-sparsity, and segmented dot product improves both accuracy and throughput. Bit-Cigma cores are implemented using 65 nm technology at 1 GHz, demonstrating substantial gains in performance and efficiency for both FP and QINT configurations. Compared to state-of-the-art Bitlet, Bit-Cigma achieves 3.2\texttimes{} performance, 6.1\texttimes{} area efficiency, and 15.3\texttimes{} energy efficiency when processing FP32 data while ensuring zero computing error.

Wed 11 NovHardware Architecture
The gist
Matrix multiplication is central to many computer tasks, especially in AI, but it can be slow and energy-hungry. The authors designed a new hardware architecture called Bit-Cigma that uses a special number encoding and processing techniques to speed up calculations for both floating-point and integer data. Their design reduces the computing work by focusing on the important bits, leading to faster and more energy-efficient operations. This improvement works on general computing tasks beyond just neural networks.
Open → 2611.15136v1

Low latency key value cache offloading boosts long context llm serving

FlashOffloading: Low-Latency KV Cache Offloading for Long-Context LLM Serving

Abstract: In large language model (LLM) serving systems, the key-value (KV) cache grows linearly with sequence length and concurrency, so long-context inference easily hits the high-bandwidth memory (HBM) capacity wall and results in low concurrency. Offloading the KV cache to host dynamic random-access memory (DRAM) frees HBM space and raises concurrency, but the additional cache management and host-to-device (H2D) load overhead inflates inference latency, higher concurrency fails to translate into effective throughput. We present FlashOffloading, a host-DRAM-centric inference architecture that fully offloads the KV cache in both the prefill and decode phases. FlashOffloading builds rolling HBM cache for prefill, a hot cache for decode, a reverse sparse index with zero extra miss-lookup overhead, and a compute--load overlapped kernel, optimizing KV offloading latency across the entire pipeline and delivering throughput gains under a time-per-output-token (TPOT) service-level objective (SLO). In experiments deploying GLM-5.2 with multi-token prediction (MTP3) speculative decoding on an Ascend910C prefill--decode (PD)-disaggregated platform, FlashOffloading improves prefill throughput by up to 1.38\(\times\) and decode throughput by up to 1.91\(\times\) under a 30 ms TPOT constraint. FlashOffloading is integrated into an open-source serving framework: https://github.com/vllm-project/vllm-ascend/tree/releases/v0.30.0.

Thu 5 NovArtificial Intelligence
The gist
Large language models need to store lots of data during conversations, which can overload fast memory and slow down responses. The authors present FlashOffloading, a method that moves this data to slower but more plentiful memory without causing delays. They designed special caches and techniques to keep things running smoothly and faster. Their tests show it can speed up different parts of the language model’s work significantly while meeting strict timing goals.
Open → 2611.07542v1

VExpert improves load balancing for distributed AI models by virtualizing storage

vExpert: Virtualizing Expert Storage for Adaptive Load Balancing in Distributed MoE Inference

Abstract: Mixture-of-Experts (MoE) models have become prevailing, yet their distributed deployment suffers from severe dynamic load imbalance due to the conflict between static expert placement and inherent routing dynamism. While host DRAM offers capacity to avoid static device storage for load balancing, we identify existing offloading works fundamentally fail in distributed inference due to two overlooked challenges: (1) coupled performance impacts of runtime Host-to-Device transfers due to load dynamism and shared PCIe topology; (2) system-level memory overhead incurred by DRAM usage at scale. In this paper, we propose vExpert that shifts DRAM offloading paradigm from partial residency to full redundancy through virtualized expert storage. We pioneer the first systematic performance model that jointly captures H2D latency, PCIe contention, and load imbalance, building a lightweight allocator to dynamically map physical experts to virtual slots runtime. A novel disaggregated manager is designed to reduce memory overhead in multi-process environments. Evaluated on DeepSeek-V3.1 within an 8-node H100 cluster, vExpert improves load balance ratio by up to 55% and achieves 1.2$\times$ end-to-end speedup.

Wed 4 NovDistributed, Parallel, and Cluster Computing
The gist
Large AI models called Mixture-of-Experts (MoE) divide tasks among different special parts called experts. The problem is these experts are fixed in one place, but the work they get changes a lot, causing some experts to be overloaded while others sit idle. The authors created vExpert, a method that makes a flexible copy of these experts in memory and quickly switches between them to keep workloads balanced. This approach uses a model to predict delays and manage memory better, leading to faster overall performance in experiments.
Open → 2611.06057v1

Gpu data scheduling speeds up large language model training

Scheduling Data to Compute: Hierarchical Data Pipelining for LLM Training on AMD GPUs

Abstract: Large language models (LLM) have been the key focus of recent machine learning breakthroughs. As the model size grows exponentially, the computation needed for training is astronomical. A GPU can do a huge amount of arithmetic. However, the data its compute units need is not always available when they are ready. This data may still be in slow memory or on another GPU. While the chip waits, expensive compute sits idle, and at scale even a small drop in utilization translates into substantial cost. In this paper, we treat this waiting time as the primary bottleneck. We focus on hardware features designed for explicit data movement. These features load data from off-chip memory onto the chip, rearrange it into the layout the computation requires as it is loaded, and transfer it between GPUs. By orchestrating them, we keep a steady pipeline of data flowing to the compute units so that they remain busy. We present kernel and framework implementations that address this bottleneck using three key data-movement instructions and hardware features. The Tensor Data Mover (TDM) moves tensor data from high-bandwidth memory (HBM) into on-chip memory. Transpose-load instructions transpose tensor data into the layout that LLM computations require as it is loaded on-chip. Finally, System DMA (SDMA) and Remote DMA (RDMA) move data between GPUs over the scale-up and scale-out networks, respectively. Our results show that TDM and transpose-load provide on average 1.88x and 1.19x speedup at the kernel level, respectively. The SDMA and RDMA lead to on average 1.16x and 1.33x speedup for computation overlapped with communication. This is the first AMD LLM training system to utilize all the GPU data pipelining features. Our implementation has been integrated into open source framework and library for AMD GPUs. https://github.com/AMD-AGI/Primus-Turbo https://github.com/AMD-AGI/Primus

Tue 3 NovHardware ArchitectureArtificial Intelligence
The gist
Training large language models needs a lot of computing power, but GPUs often wait for data, causing slowdowns. The paper looks at using AMD GPU features that move data efficiently: from memory, rearranging its layout, and transferring it between GPUs. By carefully coordinating these moves, the GPUs spend less time waiting and more time computing. The authors show their approach speeds up training kernels and data transfers significantly on AMD GPUs.
Open → 2611.05751v1

Spectral embedding reshaped to improve hypergraph partitioning cuts

RESHPart: Feedback-Reshaped Spectral Embedding for Hypergraph Partitioning

Abstract: With scalable Laplacian solvers now available, the next frontier is to exploit them more effectively for high-quality hypergraph partitioning. In this work, we revisit spectral hypergraph partitioning from the perspective of spectral embedding geometry. Through a systematic analysis of circuit hypergraphs and controlled synthetic (hyper)graphs, we identify a ray-like embedding structure that helps explain the effectiveness of projection-based partitioning. We further show that the geometry of spectral embeddings can be systematically influenced through Laplacian design and hyperedge reweighting. Guided by these insights, we propose FRESHPart, a feedback-reshaped spectral partitioning framework that refines the spectral embedding through Geometry Feedback and Search Feedback, producing embeddings that are better aligned with projection-based partitioning. On the Titan23 benchmark, FRESHPart achieves average cut reductions over hMETIS of 13.09% at $ε=2\%$ and 25.21% at $ε=20\%$, surpassing the strongest previously reported results (12.16% and 22.53%, respectively), while completing every benchmark in under 120 s on a single GPU.

Tue 3 NovMachine LearningDistributed, Parallel, and Cluster Computing
The gist
Splitting complex networks called hypergraphs into smaller parts is important but challenging. The authors found that changing the way these networks are mathematically represented can make this splitting clearer and more accurate. They created a method that adjusts these representations using feedback, which leads to fewer cutting connections between parts. Their approach works better than existing methods and finishes quickly using a single GPU.
Open → 2611.05729v1

Cμ priority rule optimizes large language model memory use and speed

Asymptotic Optimality of $cμ$-Rule for LLM Inference Scheduling under Memory Constraint

Abstract: Large language model (LLM) inference, the process by which a pre-trained model receives an input prompt and generates output tokens sequentially, has become increasingly important with the widespread deployment of LLM-based applications. As inference workloads continue to scale, GPU memory has emerged as a critical bottleneck: the long input prompts and generation sequences common in agentic and reasoning workloads lead to substantial key-value (KV) cache usage. In this paper, we study the resulting online scheduling problem from a queueing perspective. Requests arrive stochastically with heterogeneous prompt and output lengths, undergo prefill and autoregressive decode, and compete for a finite KV-cache capacity. Unlike classical queueing models, the duration of a processing step depends on both prefill computation and KV-cache I/O, so service capacity is jointly determined by computation, memory access, and memory occupancy. We develop a fluid model that reduces the system to a multiclass single-server queue with effective service rates capturing computation, memory access, and memory capacity. This fluid analysis yields a $cμ$ priority rule, where the effective service rate $μ$ is jointly determined by computational speed, memory bandwidth, and memory capacity. We prove that this rule minimizes cumulative holding cost in the fluid model and, for a finite workload, also minimizes completion time and maximizes full-run output-token throughput. We then construct a feasible scheduling policy for the original finite system and prove that its scaled dynamics converge to the optimal fluid policy. Finally, experiments on a real LLM serving engine using an NVIDIA H800 show that practical implementations of the proposed priority rule substantially reduce average latency while maintaining high throughput relative to existing scheduling policies.

Tue 3 NovArtificial Intelligence
The gist
Large language models produce text by processing inputs and generating outputs step-by-step, but this process can be slowed by limited GPU memory used to store intermediate data. The authors look at managing multiple requests competing for this limited memory as a queuing problem and develop a new model that considers both computation and memory limits. They propose a scheduling rule, called the cμ-rule, that decides which requests to prioritize to minimize waiting time and improve throughput. Their approach is proven mathematically optimal in a fluid model and shown experimentally to reduce latency on real hardware.
Open → 2611.04807v1

Memory saving method speeds up deep learning training with careful state tracking

State-Aware Activation Recomputation with Replay Contracts and Selective Preservation

Abstract: Activation recomputation saves accelerator memory by replaying forward segments during the backward pass, but replay is only correct if it sees the state the original forward pass saw. Mutable buffers, aliased bytes and random-generator state can change in between, so re-executing unchanged code can differentiate a different computation. We make this state explicit. A versioned replay contract specifies what replay must restore, and a joint planner chooses, per segment, between activation retention, whole-buffer snapshots and selective-region preservation, charging each option its measured memory and recovery cost. Independent derivative and byte-level checks validate the contract, and a Torch/JAX cohort retains all 5,900 execution records, including matches, rejections and divergences. On frozen sparse-write H100 workloads, each measured over fifty fresh processes, joint planning reduces paired step time by 18.16% against a correctly costed eager/whole planner at a 44 GiB budget (approximate 97.5% ratio interval $[.8172,.8195]$). At 32 GiB, where the eager/whole planner has no feasible static policy, joint planning is 4.98% faster than fixed regions at 29.94 rather than 26.20 GiB. A complete CIFAR-100 dense-queue application runs seven methods for 100 encoder and 25 probe epochs at six training seeds, with byte-identical test scores within each seed. There, joint planning uses 22.41% more allocated memory than whole snapshots, with a process-time geometric-mean ratio of 1.0080 (seed range $[.9845,1.0191]$). Together, the results map where selective preservation pays off: sparse writes with large activations benefit, while in the dense-queue workload whole snapshots use less allocated memory.

Sat 31 OctArtificial Intelligence
The gist
Training deep learning models requires saving lots of information, which takes a lot of computer memory. The authors show that when you save less by recomputing parts of the training, you have to be careful to keep the computer’s state the same, or else the results can change. They design a system that tracks and restores just the needed parts of the computer’s memory during retraining, choosing the best way to save memory and speed up training. Their method works well on different workloads, especially when the model writes sparsely to large memory areas.
Open → 2611.00590v1

Speculative decoding speeds up sparse MoE models more than predicted at low batches

Why Speculative Decoding Works Better Than Predicted on Sparse MoE Models

Abstract: Speculative decoding (SD) accelerates autoregressive inference by leveraging the memory bound nature of decoding, verifying multiple draft tokens in a single forward pass. For mixture-of-experts (MoE) models, prior work predicts a concave speedup-batch size relationship, with gains peaking at intermediate batch sizes due to expert saturation. We evaluate this across 10 sparse MoE models (30B--1T parameters, 8--512 experts) and find recent fine-grained models break this trend, showing higher speedup at low batch size. We find verification cost is governed not only by activated-expert bytes, but also by temporal overlap across draft tokens and GPU execution dynamics. At low batch size, MoE layers in fine-grained models account for a much smaller share of runtime than of weights; on H100, kernel profiling attributes this mainly to higher bandwidth utilization of MoE kernels relative to attention, with L2 absorbing repeated reads of co-routed experts. Across draft tokens, routing overlap further reduces the unique experts activated during verification relative to independence assumptions. We model this effect using a maximum-entropy Iterative Proportional Fitting (IPF) framework that predicts unique expert counts from routing-overlap statistics with less than 4\% error, and substantially narrows the gap to real-model curves and captures the qualitative low-batch trend from synthetic routing.

Wed 28 OctMachine LearningArtificial Intelligence
The gist
Decoding is how computers generate text step-by-step, but it can be slow. Speculative decoding tries to speed this up by guessing multiple steps at once and checking them together. The authors found that for certain large AI models called sparse mixture-of-expert (MoE) models, this guessing-and-checking works even better than people thought, especially when dealing with small amounts of data at a time. They discovered this is because these fine-grained MoE models reuse parts of their computations, reducing the workload. The paper also introduces a new mathematical way to predict this improvement accurately.
Open → 2610.38981v1

Sharper asynchronous optimization method improves deep learning training

Rennala NSGD: Asynchronous Stochastic Optimization Beyond Euclidean Geometry

Abstract: The empirical success of matrix-aware optimizers, such as Muon (Jordan et al., 2024) and Shampoo (arXiv:1802.09568), highlights the potential of non-Euclidean geometry for deep learning, including large language model (LLM) training. Despite this progress, the theoretical understanding of stochastic optimization in general normed spaces remains limited, particularly in distributed settings. We analyze minibatch stochastic gradient descent (SGD) for smooth nonconvex optimization with respect to an arbitrary norm on a finite-dimensional space. Using the framework of $κ$-regular normed spaces (arXiv:0809.0813), we derive high-probability oracle complexity bounds under a light-tail condition stated directly in the dual norm induced by the update norm. The bounds make the dependence on geometry explicit through the regularity constant $κ$ of the dual space. In the Euclidean case, our bound recovers the standard minibatch SGD rate up to logarithmic factors. For some non-Euclidean geometries and noise models, it is sharper than bounds obtained by converting a Euclidean noise assumption, reducing a linear dimension dependence to a logarithmic one. Building on this framework, we introduce Rennala NSGD, a semi-asynchronous distributed algorithm, and establish wall-clock time complexity guarantees under fixed, heterogeneous worker computation times. In the Euclidean case ($κ=1$), our bound matches the parameter dependence of classical Rennala SGD up to logarithmic factors.

Wed 28 OctMachine LearningDistributed, Parallel, and Cluster Computing
The gist
Training large neural networks like language models involves adjusting millions of numbers efficiently, which often requires clever ways to handle the mathematical space they live in. This paper studies how an optimization technique called stochastic gradient descent works when it uses different types of geometry beyond the usual flat (Euclidean) space. The authors provide new mathematical guarantees for such methods, especially when computations happen across multiple computers working at different speeds. They also introduce Rennala NSGD, a new algorithm that speeds up training while ensuring reliable results under these distributed and non-standard geometric settings.
Open → 2610.38773v1

ArcTN cuts quantum simulation costs with faster contraction planning

ArcTN: Efficient Tensor-Network Contraction Planning for Quantum Circuit Simulation

Abstract: Tensor-network simulation of quantum circuits depends on contraction orders with low computational cost and small intermediate tensors, found without excessive planning time. We present ArcTN, a contraction-order optimization framework with two search presets. Light keeps planning overhead low, and Heavy spends more effort on refinement. Both combine randomized-greedy construction, subtree reconfiguration, and parallel tempering with stage-specific stopping rules. ArcTN also provides Fixed and Dynamic slicing to meet tensor-size limits and executes the returned orders. On the 30 QC32 quantum-circuit networks completed by all eight compared configurations, Light reduces FLOPs by 61.32% and plans 1.62$\times$ faster than Cotengra Auto/CMA-ES, and Heavy reduces FLOPs by 43.83% and plans 7.21$\times$ faster than Cotengra AutoHQ/Optuna. Heavy also needs 11.85% fewer FLOPs than OMECO TreeSA-8 and plans 1.33$\times$ faster. Dynamic slicing meets the size limits in all 90 runs on 18 scalar-output networks and reduces total sliced FLOPs by 31.99% relative to Fixed slicing, at the cost of longer planning. With a common NumPy executor, Heavy has the lowest combined planning and execution time among five configurations on the runs that all of them completed. On 672 networks built from 320 MQT Bench circuits, Heavy obtains the lowest geometric-mean FLOPs on the 142 large networks while planning 3.1$\times$ and 31$\times$ faster than Cotengra AutoHQ and Hyper128.

Thu 22 OctMathematical Software
The gist
Simulating quantum circuits on classical computers requires combining many complex parts in an efficient way. The authors introduce ArcTN, a new approach that finds a faster and less resource-heavy process to do this combining, called contraction planning. ArcTN offers two methods: one that plans quickly with good results, and one that takes more time but finds even better combinations. Their tests show ArcTN uses less computing power and runs faster than several existing methods, making quantum circuit simulations more efficient.
Open → 2610.31554v1

New faster method multiplies 3 by 3 matrices using fewer additions

A 55-Addition Rank-23 Scheme for $3\times3$ Matrix Multiplication via Exact Two-Sided Minimization

Abstract: We give a scheme that multiplies two $3\times3$ matrices with 23 multiplications and 55 additions over any ring, one addition below the previous record of 56 (Sun, 2026) and the first below 56 for exact non-commutative $3\times3$ multiplication without a change of basis. The scheme forms 13 signed combinations of the entries of A and 14 of B, takes 23 products, and recombines them with 28 further additions; its correctness is machine-checked in Lean 4. The previous records, from 60 down to 56, were obtained by greedy common-subexpression elimination, which only bounds each side of a scheme from above. We minimize both input sides exactly by chain covering, and the output side exactly through the transposition principle: the 9-by-23 output map costs its transpose plus 14, and the transpose is a 9-input map that the input-side minimizer solves exactly. Applied to Perminov's cn122 scheme (class i19w225c4efh, published at 58 additions) this gives 55 = 13 + 14 + 28, where greedy elimination reaches only 29 on the output side. The same method shows that Sun's representative is output-optimal at 56, and an exact orbit-wide computation over the Heule-Kauers-Seidl database shows that the record class is the only database class attaining 55.

Tue 20 OctMathematical SoftwareComputational ComplexityData Structures and Algorithms
The gist
Multiplying two 3×3 matrices usually takes many steps. The authors found a way to do it with one less addition operation than the previous best method, making the process slightly more efficient. Their approach uses exact math techniques and even verified the method using a computer proof checker. This means computers can multiply matrices a bit faster without changing how the data is arranged.
Open → 2610.27451v1

Tomos format cuts matrix storage without slowing mixed-precision math

TOMOS: Eliminating Data Duplication in Mixed-Precision Matrix Computations

Abstract: Mixed-precision algorithms exploit reduced-precision hardware, however computing with the same matrix at distinct precisions typically requires duplicate storage, repeated conversions, or operation-emulation. We introduce TOMOS, a composite-precision matrix format that provides implicit 32-bit and 16-bit access from a single representation. Each FP32 entry is split into a 16-bit primary word for low-precision computation and a complementary word that enables exact FP32 reconstruction. The encoding scheme improves numerical quality of the low-precision view through subnormal representations, and allows exact recovery of high-precision inputs. TOMOS uses FP32-sized storage, with data movement scaling with compute precision. Optimized GEMM and GEMV kernels achieve throughput comparable to vendor libraries on NVIDIA A100 GPUs, while a mixed-precision least-squares solver achieves up to 1.6x speedup over FP32 without redundant matrix allocations.

Tue 13 OctMathematical Software
The gist
Working with numbers in different precisions often means storing the same data twice, which takes up extra space and time. The authors created TOMOS, a new way to store matrix numbers that merges low and high precision versions into one without losing detail. This lets computers do fast, low-precision calculations and still get exact high-precision results when needed. Their experiments show speed improvements and efficient storage on NVIDIA GPUs without needing duplicate data.
Open → 2610.19047v1

StageBreaker speeds up training for video reinforcement learning models

StageBreaker: Shifting Video RL Post-Training Scheduling from Stages down to Data Dependencies

Abstract: Reinforcement learning (RL) post-training has emerged as the key paradigm for improving autoregressive video models. Emerging vision-language reward models further strengthen post-training with accurate rewards, but their long chain-of-thought inference substantially raises the associated costs, while the pursuit of long videos prolongs policy training. Despite these rising costs, existing video RL systems still adopt coarse-grained stage-centric execution, which stalls policy training until all reward evaluation finishes, replays every trajectory twice due to a further barrier within policy training, and induces load imbalance across GPUs. To address the challenges, we propose StageBreaker, a fine-grained data-dependency-driven scheduling framework, which schedules the true dataflow of an RL step rather than its stages. Specifically, StageBreaker overlaps policy training with reward evaluation by exploiting reward-separable policy training, and merges the two trajectory replays into one by leveraging loss-independent back-propagation. It further balances GPU load by scheduling computation at the finer granularity. Our evaluation results show that StageBreaker achieves a speedup of up to 1.41$\times$ over stage-centric execution.

Mon 12 OctDistributed, Parallel, and Cluster Computing
The gist
Training video models using reinforcement learning can take a long time because of how tasks are scheduled and how GPUs are used. The authors propose a new way called StageBreaker that looks at the fine details of data flows instead of broad stages, allowing different parts of the training to run at the same time. This approach reduces waiting times, avoids doing some steps twice, and balances the work across GPUs better. Their method made training up to 41% faster compared to traditional scheduling.
Open → 2610.16691v1

Allreduce method cuts communication time on torus networks

SP-Allreduce: Symmetric Tree Schedules for Tori and Beyond

Abstract: Allreduce is a fundamental communication primitive in large-scale distributed training, and torus interconnects remain widely deployed in high-performance systems. We introduce SP-allreduce, a new allreduce algorithm for $d$-dimensional tori that exploits the symmetry of the topology and routes only along shortest paths. We call an allreduce algorithm \emph{fully bandwidth-optimal} if it incurs no bandwidth overhead, no multihop-induced traffic inflation, and achieves perfect per-round load balance. SP-allreduce is based on a family of carefully symmetrized shortest-path trees that guarantees full bandwidth optimality in the $α$--$β$ model. We prove that it uses the minimum possible number of rounds among all fully bandwidth-optimal allreduce algorithms on $d$-dimensional tori, and therefore the minimum running time in this class. In this sense, SP-allreduce refines Bucket allreduce: it preserves Bucket's key strengths while reducing the number of rounds by a factor of two. We further extend our approach to broader symmetric topologies and to communication trees of prescribed depths. Experimentally, the resulting algorithms improve over the best compared state-of-the-art algorithms for tori by up to $1.19\times$ on square tori and $1.65\times$ on rectangular tori across the tested configurations. On HyperX and spine-leaf networks, we demonstrate gains of up to $14.82\times$ and $1.72\times$, respectively, over the best evaluated baselines.

Mon 12 OctDistributed, Parallel, and Cluster Computing
The gist
Large computer systems often need to quickly combine data from many parts, and the way their connections are arranged affects the speed of this process. The authors created a new method called SP-allreduce that uses the symmetrical structure of torus networks more efficiently. Their approach reduces the number of communication steps needed, making data combination faster, and they also extended it to other network shapes. They tested their method on different networks and found it performs better than existing methods by a noticeable margin.
Open → 2610.16387v1

Tensor memory emulation missing key term slows fp64 performance

The Missing Fourth Term for the Emulation Tensor Memory Equilibrium (TME) Model: The Residue Deconstruction Cost

Abstract: The Tensor-Memory Equilibrium (TME) model of "FP8 is All You Need (Part 1)" calculates the execution time of Ozaki Scheme II emulation of fp64 as the maximum of a tensor-core term and a High-Bandwidth Memory (HBM) traffic term, plus a per-output reconstruction term. However, it omits the per-input deconstruction cost: every streamed fp64 operand must be scaled, rounded, and reduced modulo each of the $r$ moduli on SIMT pipes before any matrix multiply can issue. In this note we add this fourth term, calibrate its constant from the cuBLAS emulation path, and derive a closed-form operational-intensity threshold $\mathrm{OI}^{*} = c_q r P_{\mathrm{fp64}}/(8P_{\mathrm{int}})$ below which emulation cannot match native fp64 regardless of tensor-core throughput. On the NVIDIA B300 GPU the threshold is $\mathrm{OI}^{*}\approx 0.56$ FLOP/B. As a result, GEMV, SpMV, and low-batch GEMV, which are the memory-bound kernels the original paper claims to accelerate, are limited to 0.3-0.9x of native performance, and the 7-point stencil to 1.8x rather than the claimed 3.1x. Dense GEMM is unaffected as expected. We also show that precomputing and storing the residues moves the same cost into the bandwidth term, and we state the instruction count that an implementation would have to achieve to invalidate the bound.

Wed 7 OctHardware ArchitectureArtificial IntelligencePerformance
The gist
The Tensor-Memory Equilibrium model estimates how fast a certain math operation runs using special GPU hardware, but it forgot to include an important step. The authors discovered that preparing the input numbers for processing takes extra time and adds a bottleneck. Including this step shows some memory-heavy operations run slower than originally thought, while dense matrix multiplication speed remains unaffected. This new understanding helps set realistic expectations for these GPU emulation methods.
Open → 2610.10924v1

Limits on speeding up parallel diffusion sampling algorithms

Lower Bounds for Parallel Diffusion Sampling

Abstract: Standard diffusion samplers generate samples through repeated evaluations of a learned score function. Parallel sampling methods seek to accelerate generation by trading additional evaluations for fewer sequential rounds. This raises the question of how much sequential dependence is unavoidable, even when many score queries can be made simultaneously. We establish the first polynomial parallel-round lower bounds for diffusion sampling with approximate scores. Specifically, we prove (1) a $\widetildeΩ(d^{1/3})$-round lower bound for sampling smooth, near-isotropic Gaussian mixtures in $R^d$, and (2) an $Ω(d)$-round lower bound for uniform sampling from anisotropic axis-aligned boxes contained in the unit ball. Both bounds hold for arbitrary randomized algorithms making polynomially many queries per round at arbitrary locations and noise levels, with inverse-polynomial score error and constant total variation accuracy. The linear bound is tight for our box family. Our constructions use fixed approximate score oracles that enforce sequential access to hidden information while satisfying the accuracy guarantee at every noise level.

Tue 6 OctData Structures and AlgorithmsArtificial IntelligenceComputational Complexity
The gist
Diffusion sampling is a way to generate data samples by asking a computer repeatedly for hints about where the data lies. Trying to speed this up by asking many questions at once still requires several rounds in sequence, according to the authors. They mathematically prove that no matter how many questions you ask simultaneously, some minimum number of sequential steps is necessary for certain kinds of data shapes. This result sets a fundamental limit on how fast these sampling methods can run in parallel.
Open → 2610.09166v1

NCCL M2N speeds up tensor reshaping for large GPU clusters

NCCL M2N: A Layout- and Topology-Aware Collective for Distributed Tensor Resharding

Abstract: Distributed training and rollout generation often use different tensor layouts, requiring model weights to be resharded across distinct process groups. This M-to-N redistribution is not directly expressed by standard collectives. Flat direct sends duplicate traffic across destination replicas, while gather-then-broadcast concentrates network injection at one root and transfers data that destinations do not need. For DeepSeek-V3 on 256 GPUs, legacy all-gather plus broadcast accounts for 29.4% of the reported reinforcement-learning step time. We present NCCL M2N, a layout- and topology-aware collective primitive for distributed tensor resharding. Given source and destination meshes and placements, it derives the required transfer regions and a global communication schedule. Its hierarchical route balances source contributions across eligible destination ranks, forwards one copy between destination NVLink domains, and completes local replication over NVLink. Network transfer and local replication overlap, avoiding replica-multiplied source egress. An aggregate data-movement model captures the limits of both stages. We evaluate NCCL M2N on up to 256 GB200 GPUs in an NVL72 cluster with NDR InfiniBand. A single FFN-MoE layer transfer achieves up to 7.9x speedup over flat direct sends (9.8 ms versus 77.3 ms). In a separate 256-GPU DeepSeek-V3 NeMo-RL experiment, NCCL M2N reduces reported weight-sync time from 5.78 s to 2.77 s, a 2.09x speedup over legacy all-gather plus broadcast, and reduces step time by 12.7%.

Mon 5 OctDistributed, Parallel, and Cluster Computing
The gist
When computers train large AI models, they often need to rearrange pieces of data across many GPUs, which can be slow and inefficient. The authors designed NCCL M2N, a smarter way to shuffle data by understanding the layout of data and the network connections between GPUs. This new approach shares data more evenly and overlaps communication steps to save time. As a result, it can transfer data much faster and reduces the time taken in a real AI training task by over 12%.
Open → 2610.07516v1

Spiking neural network simulation speeds up brain modeling over 20 times

OACM: Optimistic Asynchronous Communication Model for Large-Scale SNN Simulation

Abstract: Spiking Neural Network (SNN) simulation serves as a crucial tool for understanding brain dynamics and advancing neuromorphic computing, but faces significant scalability challenges in large-scale distributed implementations. The primary bottlenecks arise from frequent synchronization overhead in time-driven simulators and extensive secondary rollbacks in optimistic PDES approaches, compounded by inefficient communication patterns that underutilize network bandwidth. In this paper, we propose OACM, an Optimistic Asynchronous Communication Model that addresses these challenges through three key innovations. First, we design Optimistic Hybrid SNN Simulation that combines the implementation simplicity of time-driven approaches with reduced synchronization frequency through strategic rollback mechanisms within synchronization windows. Second, we implement asynchronous one-sided communication using the UNR library, eliminating handshake latency and achieving complete computation-communication overlap. Third, we develop adaptive message aggregation and routing strategies within a 2D-HyperX virtual topology to optimize bandwidth utilization for small message traffic. Experimental evaluation on a high-performance computing cluster demonstrates that OACM achieves up to 1.4x speedup over the original CORTEX simulator and over 22.6x speedup compared to NEST when simulating a multi-area marmoset brain model at scales of up to 174 compute nodes.

Sat 3 OctDistributed, Parallel, and Cluster Computing
The gist
Simulating how brain cells communicate is important but can be very slow and hard to do on large computers. The authors propose a new way called OACM that mixes different simulation styles to reduce waiting times and uses smarter communication techniques to fully use network capacity. Their method runs simulations much faster, especially for large models like a marmoset brain, using many computers working together efficiently. This could help scientists run bigger brain experiments on supercomputers more quickly.
Open → 2610.04236v1

FlashSinkhorn 2 solves massive entropic optimal transport problems fast

FlashSinkhorn 2: Block-Sparse Entropic Optimal Transport

Abstract: Streaming GPU solvers for entropic optimal transport (EOT), such as FlashSinkhorn, avoid storing the dense kernel but still evaluate all $n\times m$ point pairs in every Sinkhorn iteration. We present \textbf{FlashSinkhorn~2} (FS2), a solver for squared-Euclidean cost on low-dimensional point clouds that solves large discrete EOT problems to a prescribed marginal residual on a single GPU by coupling two stages. A coarse stage solves on cell centroids, lifts the potentials to every point and, when a sampled marginal check rejects the lift, continues on the centroids, replacing most point-level updates. A block-sparse fine stage then removes the centroid error that coarse updates cannot. Its Morton-ordered blocks support screening and fused tensor-core execution, and a threshold set by the block masses bounds each omitted tile's contribution to every row and column. On synthetic benchmarks, FS2 reaches the target residual on all 32 problems and GeomLoss multiscale on 10. On one A100, FS2 solves discrete EOT between two $1.34\times10^8$-particle measures from a cosmological $N$-body simulation, at an entropic blur equal to the mean interparticle distance, to an all-particle marginal residual below 0.01 in under 2.5 hours. To our knowledge, it is the largest discrete EOT problem solved to this accuracy within hours. For reproducibility, we release an open-source implementation at https://github.com/ot-triton-lab/flash-sinkhorn

Thu 1 OctArtificial Intelligence
The gist
Calculating how to best match two huge sets of points is usually very slow and requires a lot of memory. The authors present a new method called FlashSinkhorn 2 that breaks the problem into two parts: first it works on a smaller summary version, then fine-tunes only important blocks of points. This approach speeds up calculations and uses less memory, allowing computations on extremely large datasets with billions of point pairs on one GPU. Their method achieves a high accuracy and completed a huge cosmological physics problem in under 2.5 hours. They also share the software openly for others to use.
Open → 2610.02395v1

Gpu-initiated communication dissected for faster network operations

GPU-Initiated Communication: Dissecting Down to the Bone

Abstract: GPU-initiated communication lets GPU threads post RDMA operations directly to the NIC. It underpins NVSHMEM, NCCL GIN, and DeepEP, which serve the fine-grained, latency-critical communication of Mixture-of-Experts (MoE) models, yet its performance characteristics and optimizations remain scarcely documented beyond source code, and library comparisons fail to separate the costs of the hardware mechanism from those of the library around it. This paper dissects GPU-initiated communication at the GPU-NIC boundary. We first detail the GPU-side network path: queue placement, work-request construction, doorbell ordering, and completion semantics. We then introduce mini-gda and mini-proxy, minimal transports for the GPU and CPU-proxy submission paths, and measure them alongside NVSHMEM IBGDA, NCCL GIN, DeepEP, UCCL-EP, MSCCL++, and fabric-lib on NVIDIA H100, H200, B200, and GB200 platforms. A minimal GPU path issues an operation in 0.7 $μ$s and completes in 4.0 $μ$s; libraries add up to 4.6 $μ$s of issue time through queue management, memory ordering, and completion scope, and issue time scales with the SM clock. A tuned CPU proxy matches or beats the GPU path at idle, at the cost of a dedicated core whose operating state sets its latency and throughput. On either path, sharing a queue with bulk traffic raises latency by one to three orders of magnitude. Reaching the 260 M msg/s ceiling of our InfiniBand platform requires doorbell batching and queue parallelism, and both have resource costs: communication code can reduce GPU block residency even when unused, and all-to-all traffic loses 59% of its NIC message rate at about 3,000 active connections. The submission path alone therefore does not predict communication performance. Our experiment code and results are available at https://github.com/ParCoreLab/Dissecting-GPU-Communication-Experiments.

Thu 1 OctDistributed, Parallel, and Cluster ComputingNetworking and Internet ArchitecturePerformance
The gist
Sending data directly from a graphics card (GPU) to a network device can speed up communication in AI models but is not well understood. The authors studied how this communication happens at the hardware level and measured how quickly it operates on various GPUs and networks. They found that minimal communication can be very fast, but the surrounding software adds delays. The study also showed that sharing resources or many connections can slow things down a lot, so performance depends on more than just the GPU itself.
Open → 2610.01380v1

DScale improves large language model decoding speed by nearly half

DScale: Scaling Block-Diffusion Speculative Decoding with Adaptive Verification

Abstract: Growing large language model applications demand efficient inference. At high concurrency, block-diffusion speculative decoding suffers from verification padding, rejected candidates, and incompatibility between variable prefixes and fixed-shape graphs. Uniform truncation sacrifices acceptable tokens. We present DScale, preserving drafter architecture, weights, and full draft length. A separate 112K-parameter predictor requires neither confidence calibration nor hardware speed-curve preparation. Path-aware tiles reduce padding. Dynamic verify-length (DVL) allocation packs scored prefixes into half the native verification capacity. Fixed-address workspaces propagate changing boundaries through verification and acceptance while reusing captured graphs. On A100-40GB with tensor parallelism 1, Qwen3-8B and Qwen3-4B cover four datasets and concurrency 8-32, reusing each target's frozen predictor. Geometric-mean throughput gains across these configurations are respectively 43.9% and 48.8% over DFlash, 22.2% and 37.7% over DSpark, and 24.4% and 32.0% over Domino, with lower request latency. Cumulative ablations show that adding the three mechanisms successively increases geometric-mean throughput, while budget adjustment improves accepted-token retention. GPU profiling shows that complete decode-step time on GSM8K decreases by 30.8-52.5% relative to DFlash

Tue 29 SeptDistributed, Parallel, and Cluster ComputingArtificial Intelligence
The gist
Large language models need to generate words quickly, especially when many requests happen at once. The authors show that existing methods for speeding this up can waste time or miss good guesses. They created DScale, a technique that keeps all the original guessing steps but uses smarter checks and better packing of information to reduce wasted work. This results in faster responses with less delay on powerful GPUs.
Open → 2609.37532v1

Loome enables fast tile program scheduling without tuning on dataflow chips

Schedules Are Solvable Symbols: Tuning-Free Compilation of Tile Programs on Dataflow Architectures

Abstract: Modern AI and HPC accelerators increasingly expose dataflow features: software-visible mechanisms for data movement and overlap, such as inter-core communication through the on-chip network and intra-core asynchronous pipelining. These features shift scheduling responsibility from hardware to the compiler, and because placement, movement, and synchronization become software-visible, they also make the performance of static schedules predictable. Yet high performance on such hardware still relies on vendor-engineered kernel libraries or profile-based auto-tuning, whose embedded expert knowledge transfers poorly across architectures and algorithms. We present Loom, a tuning-free symbolic compiler framework for tile-based SPMD programs on spatial dataflow architectures. The central idea is to treat tile-based SPMD compilation as a hardware-explicit static optimization problem. Loom enumerates discrete spatial-mapping and communication candidates while keeping value parameters, such as tiling factors and pipeline knobs, symbolic within each candidate. From an explicit hardware description, it derives symbolic legality constraints and latency expressions, formulates one CP-SAT problem per schedule candidate, and jointly solves inter-core dataflow, intra-core asynchronous scheduling, and block sizes at compile time. On two Tenstorrent generations, Wormhole and Blackhole, Loom matches or exceeds the vendor-optimized TTNN library on GEMM, Flash Attention, and Flash Decode, out of the box and without per-shape profiling or profile-based platform-specific schedule tuning. These results suggest that hardware-derived symbolic compilation provides a retargetable alternative to profiling-based tuning for spatial dataflow architectures while remaining interpretable by keeping optimization decisions traceable to source-level symbols.

Thu 24 SeptProgramming Languages
The gist
Many specialized computer chips need careful planning to run programs fast, relying on expert-made libraries or slow testing to find the best settings. The authors introduce Loom, a new way to automatically create these plans by imagining all valid options and solving equations about timing and communication without trial runs. Loom works right away on advanced chips to run important tasks efficiently without extra tuning. This method can save time and adapt better to different hardware designs.
Open → 2609.29219v1

TileBench compares tile-based AI programming models for GPU speed

TileBench: A Controlled Benchmark for Performance Evaluation and Bottleneck Diagnosis of Tile-Based Programming Models

Abstract: Tile-based programming models, such as Triton and cuTile, aim to simplify high-performance kernel development, but their practical performance, tuning behavior, and usability remain difficult to compare systematically. We present TileBench, a controlled benchmark for evaluating Triton and cuTile on NVIDIA B200 GPUs under matched operator semantics and comparable implementation structures. TileBench contains 45 operators covering diverse AI-kernel patterns and memory/computation behaviors. Each task provides a PyTorch reference, verified Triton and cuTile implementations, standardized data-types (dtype) and input-size sweeps, default and autotuned configurations, roofline-based metrics, and profiling-guided diagnosis. Our evaluation shows that performance gaps are workload-dependent: cuTile excels on a small cluster of Tensor-Core/TMA-friendly kernels, while Triton is stronger on many irregular, streaming, and bandwidth-bound operators. We further evaluate LLM-generated cuTile and Triton kernels and find that Triton is consistently more token-efficient than cuTile under the same iterative refinement protocol. TileBench is publicly available at https://github.com/Deep-Learning-Profiling-Tools/Tilebench.

Thu 24 SeptPerformanceProgramming Languages
The gist
Building fast programs for GPUs is tricky because different programming models behave differently depending on the task. The authors created TileBench, a test set of 45 AI-related tasks with matching implementations in two popular tile-based programming models, Triton and cuTile. They measured how each model performed on NVIDIA B200 GPUs and found that cuTile works better for some specialized tasks, while Triton performs better on many others, especially those with irregular or bandwidth-heavy operations. They also tested kernels generated by language models and saw Triton was more efficient in refining code. TileBench offers a fair way to compare these models for anyone developing GPU programs.
Open → 2609.29067v1

Tetris improves scheduling for photonic switch networks in computing

Tetris: Circuit Scheduling for Rearrangeably Non-Blocking Photonic Interconnects

Abstract: Reconfigurable photonic interconnects are emerging as a promising communication architecture for next-generation distributed computing. Yet, most circuit schedulers are designed around an idealized view of the interconnect as either blocking or strictly non-blocking. Practical scalable designs are often rearrangeably non-blocking (RNB), with connections routed through networks of internal $2\times2$ switches. This changes the scheduling problem fundamentally: establishing a new connection can force existing connections to be rerouted, trigger state changes across multiple internal switches, and impose reconfiguration delay on otherwise unrelated traffic. We present Tetris, a circuit scheduling algorithm for RNB photonic interconnects. Tetris builds on two observations. First, All-to-All demands are often not doubly stochastic, leaving a small number of endpoints as communication bottlenecks. Second, reconfiguration delay can be large enough to change which connection should be scheduled next. Tetris prioritizes bottleneck endpoints using their remaining communication and reconfiguration work, while selecting and routing matchings to preserve ongoing connections whenever possible. Matchings ensure progress, but connections are scheduled independently, allowing completed connections to be replaced without matching-wide barriers and incurring delay only at switches whose states change. Our simulation and hardware-emulation results show that Tetris reduces All-to-All demand completion time by up to $6.6$x over Birkhoff--von Neumann-based scheduling and by $30$% over Sunflow. More broadly, RNB interconnects raise new questions in multi-tenant scheduling and routing for partial reconfiguration, which we discuss at the end of the paper.

Mon 21 SeptNetworking and Internet Architecture
The gist
Photonic interconnects use light to send data between computers, but managing connections is tricky because new connections can disrupt existing ones. The authors developed Tetris, a clever scheduling method that prioritizes busy parts of the network and tries to avoid unnecessary changes during data transfer. Their approach speeds up communication by up to 6.6 times compared to older methods, especially for all-to-all communication tasks. This work highlights new challenges and solutions for networks that can rearrange their connections dynamically.
Open → 2609.25434v1

Ai systems improve managing scientific computing workflows and reproducibility

AI-Driven Scientific Computing Workflows: A Systems Review of Orchestration, Execution, Reproducibility and Provenance

Abstract: Artificial intelligence (AI) is increasingly embedded within scientific computing workflows that combine simulation, data processing, optimisation, visualisation and experimental or observational components. Learned models may serve as explicit workflow components, retain persistent state and, in adaptive settings, influence subsequent computation. Existing work has characterised scientific workflow management systems, dynamic and steered workflows, AI--HPC coupling motifs and the machine-learning lifecycle, although these areas are often discussed separately. This review brings them together from a systems perspective. We distinguish conventional scientific workflows, machine-learning pipelines, AI-coupled high-performance computing (HPC) workflows and broader automated research workflows, and propose a continuum describing the depth of AI participation from a computational stage to co-adaptive workflow control. The associated systems requirements are organised around five concerns: control and orchestration; compute and execution; data and model state; reproducibility and provenance; and governance and assurance. Representative systems and applications include AI-steered molecular simulation, drug and materials discovery, simulation--surrogate coupling and distributed self-driving laboratories. Workflow-level evaluation is considered in terms of scientific progress, execution cost, data movement, resource use, resilience and decision traceability. We conclude by identifying open problems in dynamic workflow representation, state-aware recovery, heterogeneous scheduling, interoperable data planes, model-mediated decision provenance and reproducible adaptive execution.

Fri 18 SeptDistributed, Parallel, and Cluster Computing
The gist
Scientific computing combines many steps like simulations, data analysis, and experiments. The authors reviewed how artificial intelligence (AI) helps manage these complex workflows, making them more adaptive and efficient. They organized systems needs around control, execution, data handling, reproducibility, and trust. The paper highlights uses like drug discovery and automated labs, and points out future challenges in making AI-driven workflows more reliable and transparent.
Open → 2609.21162v1

Simd vectorization triples performance in generating permutations efficiently

Parallelizing the Factorial Space: 3x SIMD Acceleration of the Steinhaus-Johnson-Trotter Algorithm via Dual-Lane AVX2 Execution

Abstract: This paper presents a high-performance SIMD acceleration framework for the Steinhaus-Johnson-Trotter permutation generation algorithm, targeted at modern x86-64 architectures using the AVX2 instruction set. By exploiting a novel combinatorial space partitioning with pre-calculated index offsets combined with single-cycle vector byte shuffling (_mm256_shuffle_epi8), our dual-lane vectorized implementation processes two independent, concurrent permutation streams within a single 256-bit YMM register under a uniform execution mask. Empirical evaluations demonstrate a 3$x$ performance throughput increase over both Donald Knuth's Algorithm P (TAOCP Vol 4A), which we previously accelerated by 3$x$ in scalar code, and the recent Ring-Cascade algorithm by Yusheng Hu. The proposed software architecture maintains cross-compiler compliance, completely avoids store-forwarding memory stalls during hot loops, and is validated up to order $n=11$ with a benchmark performance of ~1.27 billion CPU cycles for $n=13$ on native hardware.

Mon 7 SeptData Structures and Algorithms
The gist
Generating all possible orders (permutations) of items is a common computing challenge that can be very slow for larger lists. The authors developed a new way to speed up a well-known algorithm by running two streams of computations in parallel using advanced CPU instructions called AVX2. This approach shuffles and manages data inside the processor's registers to process permutations much faster without slowing down memory access. Their method runs about three times faster than previous best-known techniques for sequences up to size 13 on typical modern processors.
Open → 2609.07862v1

Gpu acceleration cuts latency and energy for neuron core mapping

GPU-Accelerated Hypergraph Partitioning and Placement to Map SNNs on Neuromorphic Hardware

Abstract: SNNs running on neuromorphic hardware use spikes to achieve sparse and energy-efficient communication over a mesh of cores. In turn, system performance heavily depends on the assignment of neurons to cores: the mapping. Since hardware features inter-core multicast and intra-core replication of spikes, we model SNNs as hypergraphs to exploit both opportunities for reducing communication traffic. Mapping thus comprises two NP-hard problems: hypergraph partitioning and placement on the lattice of cores. High-quality solutions to both are critical, yet increasingly difficult as networks scale to millions of neurons. Therefore, we propose a GPU-accelerated pipeline for SNN mapping: a multi-level partitioning scheme is devised around hardware constraints, while placement is initialized through recursive bisection, followed by refinement pulling together strongly connected cores through repeated swaps. Model-based experiments show upwards of 16% lower latency and 42% lower energy for spike movements over existing sequential tools, while our parallel mapper is on average 18-280x faster.

Mon 7 SeptDistributed, Parallel, and Cluster Computing
The gist
Spiking neural networks use bursts of activity to communicate efficiently across many small processors. How these neurons are assigned to the processors affects how fast and energy-efficient the system runs. The authors created a way to speed up this assignment on graphics processors by breaking the problem into pieces and improving connections between processors. Their approach reduces the time data spends moving around and uses less energy compared to older methods, while running much faster.
Open → 2609.07577v1