Papers for

hardware accelerator developers

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.

Magnetic tape storage boosted by advanced reed solomon decoding method

Anchored Iterative Decoding of Reed-Solomon Product Codes for High-Rate Magnetic Tape Storage

Abstract: We present a decoding algorithm for a Reed--Solomon product code targeted at the demanding reliability requirements of modern magnetic tape storage. For a code $RS(256, 224)\times RS(175, 173)$ in a BSC we achieve post-decoding bit error rate (BER) of $10^{-20}$ at $\approx 5.3\times 10^{-3}$ raw BER while maintaining the common requirement to detect and correct 4 out of 32 dead tracks. We resolve two common problems of miscorrections and stall patterns that arise under such a high raw BER via simplified versions of anchor decoding and binary image analysis. The highest efficiency is achieved by performing an unlimited iterative decoder, which performs decoding iterations until no changes are made. We give an empirical analysis of the average number of iterations: below the raw BER of $5\times 10^{-3}$, four half-iterations are performed on average while improving substantially over a decoder that always performs 4 half-iterations. We provide a CPU implementation achieving 100-200 megabytes/s single-core throughput on a regular laptop and a design of a potential hybrid FPGA-CPU implementation of our decoder.

Fri 6 NovInformation Theory
The gist
Magnetic tape storage needs very reliable data correction to keep information safe. The authors present a new way to decode data using a special kind of Reed-Solomon error correction code that can fix many errors even when the raw error rate is quite high. They improve how the decoder handles tricky cases where errors could cause confusion or get stuck. Their method keeps running decoding steps until no more changes happen, which reduces errors significantly while working efficiently on normal laptops and has designs for faster hardware use.
Open → 2611.09366v1

Llm inference speed improves with flexible hardware operator sharing

HELIX: HEterogeneous LLM Inference with FleXible and Fine-Grained Partitioning

Abstract: LLM inference is inherently heterogeneous, with performance bottlenecks shifting throughout inference phases down to individual operators. This has motivated heterogeneous serving systems that disaggregate execution across specialized accelerators, typically through fixed partitions such as prefill/decode or attention/FFN. However, these approaches commit to a partitioning strategy in advance, limiting their ability to adapt to different workloads and model architectures while forcing emerging accelerators into predefined roles. We present HELIX, a vLLM-based software stack that discovers, compiles and dispatches workload-aware partitions across heterogeneous accelerators at the operator granularity. At engine initialization, HELIX automatically determines hardware-specific operator placements that minimize execution latency, accounting for profiled execution costs, communication overheads, device capabilities, and memory constraints. It combines dynamic programming, piecewise compilation, and heterogeneous subgraph dispatch, enabling accelerators with partial operator coverage to participate in LLM inference without predefined model partitions. HELIX provides an open-source unified framework for exploring, evaluating, and integrating heterogeneous accelerators for LLM inference, lowering the barrier to emerging hardware by exposing them as subgraph executors. In systems combining H100 and B200 GPUs with emerging accelerators, HELIX resolves LLM partitions that multi-query decoding latency by up to 3$\times$ for dense and sparse transformer models and up to 3.5$\times$ for hybrid state-space models, relative to standard attention-FFN disaggregation.

Wed 4 NovSoftware Engineering
The gist
Running large language models (LLMs) on computers often involves different hardware parts working together, but traditionally these parts stick to fixed roles which can slow things down. The authors introduce HELIX, a software system that figures out the best way to split up the work across different hardware pieces during runtime, adapting to the model and workload. HELIX breaks down the tasks into smaller pieces to send to the right accelerator for faster results. This flexible approach lets newer, specialized hardware join in without being locked into preset roles, speeding up LLM response times significantly.
Open → 2611.06513v1

FourSight improves RL model accuracy with stable low-bit deployment

FourSight: Stable FP4 RL Post-Training via Sequence Filtering and Sparse Channel Compensation

Abstract: Reinforcement learning (RL) post-training increasingly targets low-bit deployment, with NVFP4 weight-and activation quantization (W4A4) becoming the state-of-the-practice format. However, integrating NVFP4 into RL degrades rollout quality and amplifies cross-engine training-inference mismatch (TIM), destabilizing training. We show that these failures are concentrated rather than uniform - severely mismatched tail tokens concentrate in a few outlier sequences, while policy weights remain largely intact and quantization error concentrates in a few high-variance activation channels. Guided by this, we present FourSight, an algorithm-system co-design with two targeted solutions: TIM-aware sequence filtering that excludes drifted trajectories from policy updates, and sparse precision compensation that keeps only top-variance channels in BF16 while retaining native NVFP4 elsewhere. We further design a fused SpliceGEMM kernel with specialized prefill and decode datapaths to minimize overhead. FourSight sustains near-BF16 accuracy and strong FP4 deployment quality across models and engines, while improving step-to-accuracy by 1.76-2.60x and staying within 2.3% of FP4 step time up to 120B-scale models.

Tue 3 NovArtificial IntelligenceMachine Learning
The gist
Reinforcement learning models often lose performance when their computations are simplified to use very small numbers to save space and speed. The authors found that most errors come from a few unusual sequences and a limited number of channels rather than being spread evenly. They created FourSight, which filters out these problematic sequences during training and uses more precise numbers only in important channels. This approach helps models run faster with low-bit numbers while keeping their quality almost as good as more precise formats.
Open → 2611.04887v1

ReWY speeds up gradient computation for delta-rule attention models

ReWY: Faster Gradient Computation for Delta-Rule Attention Family

Abstract: Delta-rule linear attention underlies language models such as Kimi Linear and Qwen3-Next. Chunkwise implementations expose matrix parallelism, but their backward passes compute unnecessary auxiliary adjoints. We present ReWY, an algebraic reformulation that reduces this work before optimizing accelerator execution. Differentiating the chunk correction as one triangular residual system eliminates the inverse adjoint and reduces seven local WY matrix products to three. Two complementary transformations expose further reuse: centered matrix contractions replace pairwise vector-gate processing, and scalar-gate reductions reuse key-gradient products instead of forming a key Gram matrix. These identities simplify backward computation for DeltaNet, GDN, KDA, and GDN2 while preserving the recurrence and gradients in exact arithmetic, without changing the architecture or training objective. We implement the reduced graph on GPUs and Ascend NPUs. Under matched recomputation and full-saving policies, precision-qualified six-shape comparisons with frozen FLA references yield 1.15-1.81$\times$ geometric-mean complete low-level backward speedups on NVIDIA GPUs. All four operators achieve 1.18-1.70$\times$ on H100 and H200 while retaining original FP32 working matrices. A separate public-autograd evaluation on Ascend 950DT, including gradient conversions, yields 1.09-2.89$\times$ under available matched policies. Paired ablations establish further ReWY gains after optimizing the complementary contractions. Complete-gradient checks validate the recorded operator cases; supplementary full-model backward measurements assess integration into community FLA models and a GDN2 layer port. Code and reproduction materials: https://github.com/flashserve/ReWY.

Sun 1 NovMachine LearningDistributed, Parallel, and Cluster Computing
The gist
Some language models use a technique called delta-rule attention that needs a lot of calculations to learn. The authors created a new way called ReWY to simplify part of these calculations, making the process faster without changing how the models learn or their results. They tested this on different GPUs and hardware accelerators, showing ReWY can speed up the backward pass computations by about 1.1 to nearly 3 times. This improvement helps run models that use delta-rule attention more efficiently on existing hardware.
Open → 2611.01940v1

ReLU network depth limits proven with computable error examples

A Witnessing Duality for ReLU Network Depth

Abstract: A depth lower bound for ReLU networks asserts that every shallower network errs on some input; we ask when a weak theory can prove such a bound so that an error can be computed. For the exact computation of $\max(x_1,\ldots,x_n)$, recent work shows two hidden layers suffice with unrestricted rational weights. By contrast, Haase, Hertrich and Loho (ICLR 2023) proved that integer weights require depth logarithmic in $n$, and Averkov, Hojny and Merkert (ICLR 2025) extended the bound to nonbias weights whose denominators are powers of a fixed integer not divisible by a prime $q$. With integer weights the bound is sharp: the classical balanced construction has depth $\lceil\log_2 n\rceil$. For each fixed $q$ and depth cap $K$, we prove this known bound in $\mathbf{VTC}^0$, the bounded-arithmetic theory of uniform constant-depth threshold computation, together with a refuter that is itself such a computation and whose correctness the theory proves. Given a network with at most $K$ hidden layers, nonbias weights whose reduced denominators avoid $q$, arbitrary rational biases and $n>q^K$ inputs, the refuter returns a rational input of polynomial length on which the network errs. The proof makes the obstruction finite: an iterated intersection product of piecewise-linear functions is divisible by $q$ for the network but not for the maximum, so one of finitely many test points exposes the error. By witnessing, provable refutation corresponds to a provably correct refuter, and provable existence of a certified network to a provably correct constructor. On the construction side, we introduce certificates that label each maximum gadget by the inputs it aggregates; with them the theory verifies the balanced construction, which meets the refuter at the sharp threshold $n\le2^K$, and a rational family of polynomial description length and depth $O(\log n/\log\log n)$ built from known depth-two blocks.

Wed 28 OctComputational ComplexityMachine LearningLogic in Computer Science
The gist
Some types of neural networks with limited depth cannot perfectly compute the maximum of many numbers. The authors study when simple logical theories can prove these depth limits and produce explicit examples where shallow networks fail. They show that for networks with certain restricted weights, if the network is too shallow, one can actually find specific inputs that make it give the wrong answer. Their work links proving such limits with having efficient ways to find these errors, clarifying the boundary where shallow networks stop working well.
Open → 2610.38281v1

LLM-guided framework improves post-route FPGA timing closure

LATCH: LLM-Assisted Timing Closure Harness for Post-Route FPGA Optimisation

Abstract: Post-route FPGA timing closure remains expert-dependent and computationally expensive. We present LATCH (LLM-Assisted Timing Closure Harness), a two-layer framework that separates large language model (LLM) orchestration from deterministic FPGA implementation and evaluation. Across sixteen designs and seven LLMs, a single-iteration study compares three agent control granularities - expert-written recipes, direct EDA operations and LLM-constructed procedures - to ask how much control an agent needs per attempt. Functional-pass rates are 98.2%, 71.4% and 17.9%, respectively; yet direct operations give slightly larger 3.4% median Fmax gains when passing, versus 3.2% for recipes. This exposes a trade-off between execution reliability and timing improvement. Informed by this trade-off, a multi-iteration study fixes the action tier at expert recipes to ask how repeated attempts are best organised, comparing a fitted deterministic heuristic with sequential LLM reasoning, branching exploration and knowledge base-guided exploration within 12 checkpoints per run. Branching raises mean maximum-frequency improvement from 10.5% (sequential) to 16.0%, and the knowledge base to 20.3%, improving 15 of 16 designs. Characterisation across 2,421 recipe attempts profiled their gain and validation rates, showing hard-block re-placement gives the largest cumulative mean gain at 41.4MHz.

Mon 12 OctArtificial Intelligence
The gist
Making field-programmable gate arrays (FPGAs) run faster after design is tricky and usually needs expert help. The authors created LATCH, a two-part system that uses large language models (LLMs) to guide timing improvements while relying on reliable, rule-based FPGA tools for implementation. They found a balance between how much control the AI has and how reliable or effective the timing fixes are. Using multiple rounds and smart exploration methods improved the speed of many designs. One key technique that helped was moving hard blocks in the designs.
Open → 2610.16625v1

TPCS speeds up cycle-level RTL simulation with accurate design generation

TPCS: A Cycle-Level Simulation Paradigm with Native Execution Semantics for RTL Modeling and Generation

Abstract: The growing diversity of domain-specific architectures and microarchitectural designs demands fast and accurate evaluation methods during early design stages. However, existing approaches suffer from a fundamental trade-off: high-level simulators offer speed but lack fidelity, while RTL-based tools provide accuracy at the cost of significant simulation overhead. This gap limits efficient pre-RTL microarchitecture exploration. Therefore, we propose Transaction-Pruned Cycle Simulation (TPCS), a novel modeling and simulation framework. It serves as a unified intermediate abstraction spanning microarchitecture modeling, cycle-accurate simulation, and synthesizable RTL implementation. TPCS organizes combinational logic as transaction-based function invocations and leverages host CPU control flow to naturally prune inactive logic, eliminating the need for explicit event scheduling or signal tracking. This enables cycle-accurate simulation with significantly improved performance. TPCS preserves structural correspondence with RTL and supports automatic generation of synthesizable designs. TPCS achieves 36$\times$-42$\times$ speedups over parallel Verilator on SMP systems and 3.4$\times$-7.2$\times$ over single-threaded Verilator on accelerators, with cycle-level waveform agreement on the evaluated traces. The generated RTL demonstrates comparable timing and area to handcrafted implementations, with relative changes of -4.7\% to +2.6\% in clock period and -3.3\% to +4.0\% in standard-cell area. By bridging the abstraction gap between high-level modeling and RTL design, TPCS enables a unified and agile pre-RTL workflow, allowing efficient microarchitecture exploration with both high performance and implementation fidelity.

Fri 9 OctHardware Architecture
The gist
Designers need fast and precise computer models to test new microchips before building them. The authors introduce TPCS, a new method that simulates chip designs cycle by cycle much faster than existing tools, while keeping results very accurate. It does this by only running important parts of the design each cycle and making it easy to turn these models into real hardware. Their tests showed significant speed improvements without losing detail, helping chip creators explore designs more quickly.
Open → 2610.13067v1

CentriQ improves diffusion transformer quantization without calibration

CentriQ: Calibration-Free Quantization of Diffusion Transformers via Exact Mean Centering

Abstract: Diffusion transformers (DiTs) achieve state-of-the-art image generation, but their sampling cost limits deployment. Quantizing both weights and activations to 4 bits reduces this cost, yet existing methods fall short in one of two ways. Calibration-based methods are tied to a specific checkpoint and prompt distribution, whereas data-free Hadamard rotation, effective for LLMs, loses quality on DiTs. We show that this loss has a structural cause. Adaptive layer-norm conditioning adds a per-token mean to the activations, and at the widths of the evaluated DiTs, the Hadamard rotations used by data-free methods cannot spread this mean uniformly across coordinates. A single dominant direction therefore survives the rotation and sets the quantization range. We introduce CentriQ, a calibration-free quantizer that centers each token before rotation and restores the mean exactly through a rank-1 full-precision branch, so that per-token scales follow in closed form without data. Weights are fitted under a robust $\ell_p$ objective that tracks the dense mode of each group and discounts heavy tails. Across three DiTs, CentriQ matches the quality of calibrated SVDQuant at 4 bits, whereas calibration-free weight quantizers with plain per-token activation quantization collapse or degrade substantially. CentriQ outperforms the strongest calibration-free method reported to date at 2-bit weights. It is also the first calibration-free method to retain usable image quality at 2-bit activations.

Mon 5 OctComputer Vision and Pattern RecognitionArtificial IntelligenceRobotics
The gist
Diffusion transformers make high-quality images but require a lot of computing power. The authors found that existing ways to make these models smaller and faster either need lots of example data or lose quality. They discovered that a technical cause involving how the model's activations behave during a common step called Hadamard rotation limits current methods. Their new method, CentriQ, fixes this by carefully adjusting activations to keep important information before quantizing, all without needing calibration data. This results in smaller, faster models that keep image quality even at very low bit sizes.
Open → 2610.06260v1

Spiking speech classifier shows hidden moments of weakness in predictions

Aggregate accuracy conceals concentrated temporal vulnerability in a spiking speech classifier

Abstract: Aggregate accuracy cannot reveal which utterances are locally vulnerable or how internal activity changes when labels remain stable. We retain every prediction for 725,070 adjacent-bin, one-count changes around 100 validation utterances of a frozen SpikeSCR-based classifier. The canonical native-horizon GPU singleton path reaches 86.0836% validation accuracy. Equal-source expected accuracy under a uniformly chosen neighbor rises from 84.00% to 84.54%, although 13 of 84 initially correct sources admit adverse neighbors. Five sources carry 93.21% of adverse moves. Margin-guided and surrogate-gradient searches miss sparse cases at fixed query budgets; a post hoc gradient prefix finds all 13 at 73.45% of the census of initially correct sources. Source-matched traces and clean-state interventions distinguish internal change from harmful direction and recoverability. Two count-readout replicas have similar validation accuracies but a 5.21-fold class-change gap concentrated in four sources. Controlled query/key source isolation eliminates 531 batch-order label changes and restores bitwise order invariance across all 9,981 validation score vectors. Isolated batch predictions reproduce padding-matched singleton labels on 9,980 of 9,981 inputs. Paired CPU/GPU replay of all 25,820 class-changing neighbors gives 99.8993% label agreement and preserves all 13 vulnerable sources and their fixed witnesses. Complete source-conditioned maps distinguish vulnerability incidence, concentration, internal change, and execution dependence that aggregate accuracy leaves unresolved.

Fri 2 OctNeural and Evolutionary Computing
The gist
Sometimes, a speech recognition system can seem accurate overall but still makes mistakes on certain tricky parts of spoken input. The authors studied these small, local weaknesses in a specialized spiking neural network for speech, showing that a few specific instances cause most errors. They also developed ways to track internal changes in the system’s activity that lead to these mistakes, revealing details that overall accuracy alone can’t show. Their work helps explain when and why the system’s predictions change unexpectedly.
Open → 2610.03155v1

CGRAs get faster by linking loops and pipelining better

CONFERM: Recurrence-Aware Temporal Mapping for Multi-Cycle Multi-Context CGRAs

Abstract: Throughput in DSP and machine learning workloads is often limited by two temporal structures, i.e., loop-carried recurrences and long-latency, multi-cycle compute nodes. On spatio-temporal coarse-grained reconfigurable arrays (CGRAs), both bottlenecks can be addressed by overlapping iterations across the multi-context modulo configurations. Yet, existing CGRA mappers schedule a fixed dataflow graph (DFG) that treats recurrence-aware scheduling and operator-level pipelining separately, limiting inter-iteration overlap and inflating routing pressure. To tackle this, we present CONFERM, a recurrence-aware temporal mapper that uses the dominant temporal con-straint to guide the DFG representation and expose opportunities for loop-carried pipelining. CONFERM identifies and prioritizes bottleneck regions during scheduling. The regular loop-carried offsets across interleaved iterations allow the emitted control sequence to repeat at a shorter cadence than the original initiation interval, thus delivering higher throughput with lower CGRA configuration overhead. Across ten benchmark kernels, CONFERM improves throughput by 2.18x over state-of-the-art mappers. Its uniform iteration offsets shorten the emitted initiation interval by 46%. CONFERM's mapper pass also converges faster by 5.07x on average with the same heuristic mapper backend.

Thu 1 OctHardware Architecture
The gist
Some computer chips called CGRAs process tasks that include loops and slow operations, which can limit their speed. The authors introduce CONFERM, a method that coordinates how loops and slow operations are scheduled together, allowing the chip to do several parts of a loop at once more efficiently. This method shortens the time between starting tasks and reduces the resources needed, leading to more than double the speed on tested examples. CONFERM also finds these schedules faster than previous methods.
Open → 2610.01975v1

Efficient method improves analog computing accuracy for AI models

IMC-CLINIC: Coupled Loss-Informed Newton Iterations for Clipping in Analog In-Memory Computing

Abstract: Analog in-memory computing (IMC) offers a promising path toward energy-efficient large language model (LLM) inference by executing matrix multiplications (MatMul) directly within memory arrays in the analog domain. Its efficiency, however, comes with an additional source of error: limited-precision analog-to-digital converters (ADCs) quantize accumulated analog partial sums, introducing output-side error distinct from conventional activation and weight quantization at the MatMul inputs. Clipping can mitigate both operand and ADC quantization errors, but the optimal clipping factors must jointly balance activation rounding and clipping, weight rounding and clipping, and ADC quantization. Existing clipping methods, designed for digital quantization, do not explicitly optimize these coupled sources of IMC error and often rely on costly search-based calibration. We introduce IMC-CLINIC (Coupled Loss-Informed Newton Iterations for Clipping), a clipping calibration framework based on an analytical surrogate for IMC MatMul output error. The surrogate jointly models operand quantization, accumulated clipping-induced bias, and ADC quantization, enabling efficient evaluation of its gradient and approximate curvature from a small calibration set. IMC-CLINIC jointly optimizes activation and weight clipping factors using a safeguarded Newton-type method. Across multiple models and datasets, it improves average zero-shot accuracy by 6.5-11.5 percentage points over the grid search baseline while reducing calibration time by factors of 10.0-12.1. Its analytical surrogate closely tracks empirical IMC output error, and its optimizer is certified within 1% of the global optimum under the loss objective across all projections on two representative models.

Mon 28 SeptArtificial Intelligence
The gist
Analog in-memory computing lets computers do big calculations quickly and using less energy by working in an analog way inside memory chips. But this method introduces special rounding errors because of how numbers are converted back into digital form. The authors created a new way called IMC-CLINIC that smartly adjusts how numbers are clipped and rounded to reduce these errors. Their approach works faster and more accurately than older trial-and-error methods, making AI computations more reliable.
Open → 2609.35586v1

Kv cache compression improves large language model efficiency

D-Quant: Driftable Entropy Coding for KV Cache Quantization

Abstract: The KV cache has become a major bottleneck in deploying LLMs, as its memory footprint grows linearly with sequence length and batch size, imposing substantial pressure on both memory capacity and bandwidth. Among various KV cache compression techniques, quantization is particularly attractive due to its effectiveness and ease of deployment. However, most existing methods rely on fixed-width quantization, where a $b$ bit representation is inherently limited to $2^b$ quantization levels. As the bit width decreases, the number of available levels shrinks exponentially, leading to severe information loss and rapid performance degradation. We further observe that fixed-width quantization fails to exploit the highly non-uniform distribution of KV cache. After rotation and normalization, KV values approximately follow a normal distribution, with most values concentrated near the center and only a small fraction appearing in the tails. Nevertheless, fixed-width coding allocates the same number of bits to frequent and rare symbols. Entropy coding naturally exploits such non-uniformity by assigning shorter codewords to frequent symbols and longer ones to rare symbols, substantially reducing the average number of bits required for representation. However, its variable-length output is not suited to highly parallel attention kernels, where efficient dequantization and computation rely on regular memory layouts and fixed-stride accesses. To bridge this gap, we propose \textbf{D-Quant}, a flexible KV cache quantization framework that introduces a \textbf{drift} mechanism to convert entropy-coded representations of each token into fixed-size bitstreams, enabling regular memory access and parallel dequantization within attention kernels.

Thu 17 SeptComputation and Language
The gist
Large language models use a key-value (KV) cache to speed up processing, but this cache takes up a lot of memory, which slows things down. Most methods to reduce this cache's size use fixed-bit quantization, which doesn't work well because it treats frequent and rare data equally and loses important information. The authors developed D-Quant, a new way to compress the KV cache that uses entropy coding to save memory without slowing down processing, by converting variable-length codes into fixed-size pieces that computers can handle efficiently.
Open → 2609.19880v1