Skip to main content
archive Search
Submit Donate Log in

Press Enter to search · Advanced search

Hardware Architecture

  • New submissions
  • Cross-lists
  • Replacements

See recent articles

Showing new listings for Friday, 20 November 2026

Total of 37 entries
Showing up to 2000 entries per page: fewer | more | all

New submissions (showing 20 of 20 entries)

[1] arXiv:2611.24962 [pdf, html, other]
Title: Vector Field Transforms: Structured Hyperdimensional Memory for Spatio-Temporal Reasoning
William Youngwoo Chung, Andrew Ding, Hansen Jin Lillemark, Mohsen Imani
Comments: 9 pages, accepted at IEEE/ACM International Conference on Computer-Aided Design (ICCAD 2026)
Subjects: Hardware Architecture (cs.AR)

Vector Symbolic Architectures (VSAs) are attractive for edge intelligence because their fixed-width distributed representations and simple algebraic operations map naturally to low-power vector hardware. However, conventional VSA memory superposes information, such as object, position, and time, into a single global vector causing interference to grow with scene complexity and trajectory length. We propose Vector Field Transforms (VFT), a symbolic spatio-temporal memory that replaces the flat global superposition with a spatially indexed field of local VSA memories. On a local clutter experiment, VFT achieves 100.0\% top-1 accuracy compared with 20.3\% for MAP-VSA and 37.3\% for FHRR-VSA. For a temporal recall benchmark, VFT achieves 74.8\% accuracy while flat temporal VSA reaches only 5.8\% and 10.6\%. Additionally, we map VFT's transport, write, and query kernels to a proposed programmable RVV processor. A DMA-assisted field-shift engine reduces VFT step latency by 1.40--1.45$\times$, including a reduction from 55.1~$\mu$s to 38.6~$\mu$s on the egomotion configuration. These results establish VFT as a practical symbolic memory architecture for spatio-temporal edge workloads and a strong match for programmable vector processors.

[2] arXiv:2611.24992 [pdf, html, other]
Title: Compressing Page-Table Leaves in Shared Caches
Samarth Narang, Aamer Jaleel, Brandon Reagen
Subjects: Hardware Architecture (cs.AR)

Hardware page-table walkers fetch descriptors through the cache hierarchy, so page-table walks compete with application data for shared-cache capacity. Retaining leaf page-table lines on chip avoids costly DRAM reads during address translation, yet as a workload's mapped footprint grows, these lines displace application data and slow cache-sensitive co-runners.
We introduce LeafPack, a shared-cache organization that resolves this trade-off by compressing architectural page-table leaf lines in place within standard cache ways. By exploiting regularity in the physical frame numbers and attributes of neighboring descriptors, LeafPack packs up to sixteen 64-byte leaf lines into a single 80-byte slot including metadata. It packs leaf lines incrementally as walks fetch them and reconstructs individual lines on demand while leaving irregular lines uncompressed, preserving both the in-memory page-table format and the hardware walk algorithm as long as walkers tag leaf requests. A runtime set-dueling controller adapts page-table occupancy by choosing between compressed and uncompressed way ceilings to balance translation coverage against application-data capacity. We evaluate LeafPack in full-system Arm gem5 simulations across a small and a server-class out-of-order core on workloads spanning one to eight cores. Across nine translation-heavy workloads, LeafPack improves geometric-mean harmonic speedup on the small and server cores by 28.7% and 28.4% over our baseline shared cache, and by 18.7% and 17.7% over an SRRIP baseline. Across twenty unseen held-out mixes evaluated after freezing the controller, LeafPack speeds up every mix with geometric-mean gains of 21.4% and 18.5%.

[3] arXiv:2611.25141 [pdf, html, other]
Title: CAIMS: Scalable Cross-Array In-Memory Search
Yi-Chun Liao, Liu Liu, Ruiyang Qin, Yiran Chen, X. Sharon Hu
Subjects: Hardware Architecture (cs.AR); Emerging Technologies (cs.ET); Machine Learning (cs.LG)

Search, especially top-k similarity search, plays a vital role in many applications, but its performance can be severely limited by memory access overhead. In-memory search (IMS), an alternative to CPU/GPU-based approaches, exploits massive parallelism within a content-addressable memory (CAM) array to perform search in situ and provides both low latency and high energy efficiency. However, the capacity of a single CAM array is often insufficient for modern workloads, requiring data to be distributed across multiple arrays. Deploying scalable top-k similarity search across multiple CAM arrays poses a fundamental problem that existing designs fail to address: how to accurately and efficiently reduce local binary match results to global top-k results. This work introduces CAIMS, a cross-array IMS framework that is agnostic to memory technologies and applications, enabling scalable and efficient top-k similarity search while preserving accuracy. To enable accurate top-k result reduction, CAIMS leverages the existing threshold match functionality with a combined offline and online parameter selection approach to transform local binary match results that lack globally comparable similarity information into global coarse-grained similarity scores. To further improve efficiency, CAIMS conducts hierarchical reduction and transfers only the selection results and necessary control signals with lightweight local peripherals. Implemented on a 3D NAND Flash model and demonstrated using the retrieval phase of retrieval-augmented generation, CAIMS improves throughput by up to $22.3\times/10.1\times$ and energy efficiency by $426.6\times/23.7\times$ compared to the server-class CPU baseline and prior 3D NAND Flash accelerators, respectively, while maintaining comparable accuracy.

[4] arXiv:2611.25281 [pdf, html, other]
Title: Native FPGA Hard-Block Implementation from High-Level Synthesis
Mohamed Bouaziz, Mahmoud A. Elshenawy, Krishnan B. Iyer, Abdurauf Abdurakhmanov, Ammar M. Seliaman, Suhaib A. Fahmy
Subjects: Hardware Architecture (cs.AR)

High-level synthesis (HLS) maps computations to FPGA hard blocks, yet often leaves their arithmetic modes, internal registers, and cascade links idle and recreates them in the fabric, costing area and timing. We present a C++ template library that reaches native hard-block implementations without modifying the HLS compiler. Templates fix source patterns, and an automatic flow picks scheduling settings and verified RTL patches. On AMD Versal, our matrix multiplication uses 2.4--4.5x fewer lookup tables (LUTs) than AutoSA systolic arrays at equal or higher estimated throughput. Our INT8 matrix--vector units reach the three multiply--accumulates per DSP of hand-written FINN RTL, versus at most 1.29 for HLS libraries. In hls4ml, Allo, and Stream-HLS, the templates cut LUTs by up to 2.7x and DSPs by up to 2x.

[5] arXiv:2611.25293 [pdf, html, other]
Title: Bottom-Up FPGA Reconfigurable Accelerator Overlay Generation
Mohamed Bouaziz, Suhaib A. Fahmy
Subjects: Hardware Architecture (cs.AR)

Programmable FPGA overlays run new workloads without re-synthesis, yet they pay twice. An overlay adds a second layer of programmability on top of the FPGA's own overhead. Moreover, overlay generators usually start from a regular template, so they spend logic on switches and links that the workloads never use, and they close timing at low clocks. We present a flow that instead grows an overlay bottom-up from the dataflow graphs of the workloads it must run. The flow clusters workloads by structural similarity, ranks shared slots with spectral descriptors of each operation's surroundings, and adds only the units and links a workload lacks. It builds every unit on native hard blocks, with their internal pipeline registers, dual-ported memories and double-pumped DSPs, and it uses fixed-function engines where wider data types exceed the overlay's 16-bit lanes. Workloads then switch by configuration alone. On an AMD VCK5000, across 17 workloads from three suites and against OverGen rebuilt for the same board, our images run at 250-400 MHz instead of 35-50 MHz. As a result, they are 9.52-10.33x faster in geometric mean, and up to 36.97x, while using 19.4-22.1x less of the FPGA and 9.67-10.51x less estimated board energy.

[6] arXiv:2611.25326 [pdf, html, other]
Title: RE-CAM: Readout-Enhanced Content-Addressable Memory for Quantitative Similarity Search
Yi-Chun Liao, Dongyoung Lee, Jiazheng Chen, Tergel Molom-Ochir, Tomohisa Kawakami, Tania Roy, Ik-Joon Chang, X. Sharon Hu, Hai "Helen" Li, Yiran Chen
Subjects: Hardware Architecture (cs.AR); Emerging Technologies (cs.ET); Machine Learning (cs.LG)

Similarity search is essential to many applications but incurs massive data movement when executed on conventional architectures. Content-addressable memory (CAM) is a promising hardware substrate, as it allows similarity search directly in the CAM array, minimizing data movement and offering both low latency and high energy efficiency. However, conventional CAM array readout produces only binary match results, discarding quantitative similarity information that could be further exploited. Extracting this information requires interpreting the CAM array output voltage that evolves during a CAM search, making the sensing timestamp a crucial design variable alongside the reference voltage and decoding parameter. In this work, we propose RE-CAM, a readout enhancement framework for CAM that is agnostic to memory technology and application, enabling CAM array readout to approximate linear and nonlinear functions with one CAM search. By reusing the comparators to sense the time-varying output voltage multiple times, jointly optimizing the three design variables under system constraints and hardware nonidealities, and co-designing the optimization algorithm and reconfigurable hardware, RE-CAM achieves accurate approximation with low energy and area overhead without introducing a readout throughput bottleneck. Across linear, piecewise-linear, sigmoid, and exponential functions, RE-CAM reduces normalized root mean square error by 10.89% to 24.34% for general approximation and 29.43% to 46.73% when exploiting dataset distribution, compared to a shared uniform-reference ADC baseline with the same comparison budget. Relative to the same baseline, RE-CAM also achieves $8\times$ higher search throughput while reducing energy per search and area by 47% and 39%, respectively.

[7] arXiv:2611.25328 [pdf, html, other]
Title: ReLay: Bidirectional Layout-Code Translation and Library Evolution for Reusable and Process-Portable Analog Design
Minxing Chu, Quan Cheng, Anhang Li, Martins Atilla, Junyi Luo, Xinting Jiang, Ruichen Qi, Mehdi Saligane
Comments: 4 figures, 2 tables. Preprint. Under review
Subjects: Hardware Architecture (cs.AR); Artificial Intelligence (cs.AI)

Analog layout generators provide a programmable interface for design reuse and process migration, but their coverage is limited by handcrafted libraries. The designer knowledge embedded in complete layouts remains implicit in their geometry, making it difficult to capture in reusable generator libraries. We present ReLay, a bidirectional layout-code framework that recovers generator programs from existing layouts, enabling cross-PDK portability and parametric resizing of existing designs. Constructions that recur across recovered programs are promoted to library functions, so the library evolves as layouts accumulate. We also introduce the first layout-code benchmark: 1,050 hand-drawn layouts from 27 circuit families across three open-source PDKs, ranging from primitive cells to full chips. Learned functions account for 53-66% of layout-building calls in held-out layouts, demonstrating reuse beyond the learning corpus. Frontier LLM agents use ReLay to produce new layouts at 64-77% lower API cost per completed task than direct geometry generation, with comparable completion rates and electrical quality.

[8] arXiv:2611.25351 [pdf, html, other]
Title: FPGA-GEN: Target-Aware RTL Generation via HLS
Luke Ztz Hu, Zhihan Xiao, Zhe Zhao, John Imoleayo Adebisi, Han Gao, Linxiao Yan, Songping Mai
Subjects: Hardware Architecture (cs.AR); Artificial Intelligence (cs.AI)

Successful C/C++ compilation does not guarantee correct or efficient FPGA hardware after high-level synthesis (HLS). FPGA-GEN is an agentic HLS-C generation workflow that encodes specification, readiness, selection, repair, and admission rules in explicit task contracts and bounded tool-feedback loops for candidate-level decisions. On HLS-Eval, five shared-context outputs per task yield 407/425 (95.8%) public-testbench passes. In a cumulative conversion campaign, FPGA-GEN admits 104/107 (97.2%) HLS-LeVeri designs under held-out co-simulation, Vivado synthesis/fit, and same-RTL evidence. In focused TensorCore screening, selected candidate 3 reports 73.7% fewer CSynth cycles and 14.6% fewer LUTs than generated/composed C0, with 26.7% more DSPs, and passes development CoSim.

[9] arXiv:2611.25410 [pdf, html, other]
Title: SGLayout: Schema-Guided Closed-Loop Refinement for LLM-Driven Parameterized Layout Generation
Siyang Chen, Yuan Pu, Yuhan Qin, Zhaotan Lin, Siyuan Liang, Zhuolun He, Lining Zhang, Bei Yu
Comments: Accepted at ICCAD 2026. 9 pages
Subjects: Hardware Architecture (cs.AR); Artificial Intelligence (cs.AI)

Large Language Models (LLMs) have shown strong potential in parameterized layout generation via tool-augmented code synthesis. However, LLMs lack spatial awareness, making one-shot generation unreliable. While layout quality can be evaluated with established techniques, a critical gap remains: geometric-domain evaluation outcomes cannot be directly translated into actionable code-level fixes, trapping iterative refinement in blind refactoring. We propose SGLayout, a self-refining framework that closes this gap via a schema-guided mechanism. Upon code execution, a structured schema captures the correspondence between each code-level instance and its geometric attributes, establishing a bidirectional link between code space and geometry space. Emulating engineer review practices, SGLayout evaluates layouts along two complementary dimensions: intent compliance through quantitative structural checking and qualitative vision-language assessment, and rule compliance through DRC. All identified violations are then back-projected through the schema onto precise code targets, enabling surgical repair. This closed-loop process iterates until layout convergence. On a curated benchmark of 112 parameterized layout generation tasks using GDSFactory, SGLayout achieves a 76.79% pass rate, compared with 50.89% for the strongest baseline.

[10] arXiv:2611.25438 [pdf, html, other]
Title: BOOMerang: Autonomous Translation from RTL to Microarchitectural Simulators and Back
Ferran Hermida-Rivera, Jack Toubes, Angela Cui, Chengyi Lux Zhang, Sagar Karandikar
Subjects: Hardware Architecture (cs.AR)

High-level simulators like gem5 are often used to test and demonstrate novel architectural techniques. While these simulators provide high research productivity, they generally lack the means to provide detailed feedback on the realizability of a hardware design. Furthermore, these simulators can frequently fall out-of-sync with the detailed performance characteristics of real hardware designs, which is usually the responsibility of dedicated engineers/teams in industry. While RTL implementation can address these challenges, it can be even more difficult to translate simulator code to high-quality RTL by hand without a large team.
In this work, we architect and evaluate agentic loops that automate both parts of the RTL vs. high-level simulator workflow that is critical to high-quality architecture research. Our loops (1) automatically generate accurate high-level models of RTL implementations of CPU designs (BOOM) in a battle-tested microarchitecture simulation framework (gem5) and (2) automatically translate new microarchitectural features implemented in the high-level simulator back to RTL faithfully.
Targeting the first loop at autonomously building a gem5 model for the Berkeley Out-of-Order Machine (BOOM) core, we generate a simulator with IPC within 3% of the RTL, meeting targets pursued for simulators in industry, in only 2 days. We use our second loop to automatically translate 72 features from this aligned gem5 simulator into RTL in the BOOM core, while maintaining its low IPC error. Combining translated optimizations together yields a 25% performance improvement for the BOOM core RTL implementation in SPECint 2017, demonstrating that having these loops for moving between high-level simulation and RTL enables actual improvement of processor performance. The agentic loops we developed and the simulators and RTL we generated will be available in open-source.

[11] arXiv:2611.25580 [pdf, html, other]
Title: FlashX: Scaling Robotic Experience Reuse for Embodied Agents with CBA-Based NAND Flash
Yuseon Choi, Sanghyeon Park, Eunjong Lee, Hanseo Lee, Sangjin Kim
Subjects: Hardware Architecture (cs.AR); Artificial Intelligence (cs.AI); Robotics (cs.RO)

Embodied agents are emerging as a promising paradigm for complex robotic tasks, leveraging Vision-Language-Action (VLA) and World Action Models (WAMs) to generate actions through Diffusion Transformer (DiT)-based iterative denoising. However, existing models often struggle to generalize to out-of-distribution (OOD) environments. We observe that retrieving successful experiences and using them to warm-start denoising enables agents to better adapt to unfamiliar situations while reducing computational overhead. This creates a new opportunity to improve task accuracy and inference efficiency simultaneously, in contrast to conventional acceleration techniques that trade accuracy for computation. However, realizing this opportunity requires scaling experience banks, introducing substantial storage and search overhead that challenges the capacity, bandwidth, and power constraints of edge systems.
We propose FlashX, a CMOS Directly Bonded to Array (CBA)-based NAND flash architecture for scalable experience reuse in embodied agents. FlashX exploits CBA's high internal bandwidth for parallel pSLC key search, employing interleaved Compute-in-Flash (CIF) engines to sustain sensing throughput while retaining dense TLC latent storage. Proprioception-aware clustering further reduces search overhead and enables incremental experience acquisition without global reclustering. Evaluations across VLA and WAM workloads demonstrate up to 12.24\%p and 7.43\%p improvements in task success under dense and compute-efficient configurations, respectively. FlashX achieves 2.57$\times$ higher search throughput than the strongest prior NAND search architecture under pSLC sensing, with a further 9.7$\times$ search reduction through clustering. This delivers 1.29--3.95$\times$ end-to-end speedup and 1.12--2.34$\times$ energy efficiency improvement over SSD-based retrieval.

[12] arXiv:2611.25617 [pdf, html, other]
Title: Splice-Core: Low-Order-Bit-Splicing GEMM for Highly Energy-Efficient AI Inference Accelerators
Prabhu Vellaisamy, Hsien-Fu Hung, Andrew Kim, Shawn Blanton, John Paul Shen
Comments: 7 pages
Subjects: Hardware Architecture (cs.AR); Artificial Intelligence (cs.AI)

Splice-Core is a temporal-unary/binary (tub) hybrid general matrix multiplication (GEMM) unit that minimizes low-order accumulation latency, while retaining value-dependent execution for high-order activation bits. We present two novel processing element (PE) variants: (i) Splice-BP utilizing bit planes, and (ii) Splice-LUT, which selects a shared weight multiple in a single cycle. Compared to a binary systolic array, Splice-BP/Splice-LUT achieve 77.4%/76.4% geometric-mean tile energy reductions, respectively, across 26 INT4 convolutional neural network (CNN) and large language model (LLM) workloads in 45nm. Splice-LUT further increases geometric-mean tile throughput by 44.4% and reduces geometric-mean energy-delay product (EDP) by 6.13x across the 26 configurations. Across the evaluated W8A8 convolution and expert-projection workloads, Splice-BP and Splice-LUT reduce tile energy by 77.3-88.1%. Post-place-and-route INT4 yields 14%/9% smaller area for Splice-BP/Splice-LUT, compared to the systolic array.

[13] arXiv:2611.25661 [pdf, html, other]
Title: GRODE-RTL: Source-Mapped Dependency Views for LLM-Based RTL Repair
Jingyi Zhou, Yi Liu, Bin Sun, Hongji Zhang, Dongsheng Zuo, Qiang Xu
Subjects: Hardware Architecture (cs.AR); Artificial Intelligence (cs.AI); Multiagent Systems (cs.MA)

Large Language Models show great potential for automated Register-Transfer Level repair, yet they struggle with non-local faults where root causes and failing outputs reside far apart in source code. Treating RTL as a flat token sequence obscures hardware dataflows, whereas exposing complete synthesized graphs overwhelms the model with fine-grained metadata. To resolve this representation dilemma, we propose GRODE-RTL, an anchor-centric representation that extracts the single-clock-stage fan-in cone of a suspect register from the netlist, maps netlist nodes back to editable source lines, and organizes them into a compact hop-partitioned dependency view. By prioritizing direct drivers and folding distant hops, GRODE-RTL guides standard tool-using agents without exposing ground-truth hints or oracle feedback. We evaluate GRODE-RTL across 30 formally validated non-local faults using three LLMs (DeepSeek-V4-Flash, GLM-5.2, and MiniMax-M3) alongside a controlled six-configuration ablation study. GRODE-RTL improves pass@1 over source-level exploration by 16.7% on DeepSeek, by 26.7% on GLM-5.2, and by 20.0% on MiniMax-M3, with consistent gains on the hard-to-retrieve far-distance and indirect-anchor subsets of all three models. Our controls isolate structural relevance from generic context expansion, proving that selective dependency organization rather than full graph exposure is key to effective RTL repair.

[14] arXiv:2611.25714 [pdf, html, other]
Title: Mitigating Row Buffer Contention Through Multiple Row Buffer (MRB) DRAM
K Chitra, Arjun Dey, Aryabartta Sahu, Minesh Patel
Subjects: Hardware Architecture (cs.AR)

DRAM chips contain multiple banks to handle sev- eral memory requests in parallel. However, requests to different rows of the same bank (e.g., from different cores or workload access patterns) interfere with each other by contending for a single shared row buffer. This introduces row buffer conflicts, which incur performance and energy overheads. In this work, we reduce row buffer conflicts caused by interference by introducing multiple row buffers in each bank. We propose multiple row buffer (MRB) DRAM, which employs a primary global row buffer along with multiple secondary SRAM row buffers in the DRAM chip. These secondary SRAM row buffers act as a cache that enables each bank to serve requests to multiple rows in parallel, thereby improving performance and reducing row buffer conflicts. Our evaluation shows that MRB-DRAM with four SRBs per bank improves performance by an average of 29.7%, 24% in singlecore, multicore systems, respectively, compared to a conventional DDR4 baseline with a modest area overhead of 2%.

[15] arXiv:2611.25908 [pdf, html, other]
Title: CRAFT: Analog Circuit Design by Reasoning LLM Agents from Pre-Computed Lookup Tables
Hyunjun Park, Seungyub Han, Jason Jaesung Lee, Kahyun Kim, Soohyun Kim, Inwoo Nam, Sunmin Kim, Wooyoung Choi, Junhyung Kim
Comments: 7 pages, 9 figures, 2 tables
Subjects: Hardware Architecture (cs.AR)

Automated analog circuit sizing methods, from black-box optimizers to recent large language model (LLM) agents, typically search the design space with a SPICE simulator in the loop, whereas an experienced designer works out a design by hand analysis. This paper presents CRAFT, a flow in which an LLM agent designs a given topology by calculation, as a designer does, and without an initial sizing. The agent works only through DeX, a service that uses pre-computed lookup tables to provide device characteristics and to solve the whole netlist for its operating point and small-signal response. It thus designs without SPICE, and every final design is verified independently in HSPICE. We test CRAFT on four circuits in a commercial 28 nm process; the largest is a 37-transistor three-stage amplifier with 53 design variables, 20 specifications and 74 saturation constraints. With Claude Opus 5.5, CRAFT meets every specification and constraint in all 20 runs, five per circuit. On that amplifier, with DeX in place of HSPICE and an identical request for both, the same agent passes in 10 of 10 runs instead of 6 of 10 within an hour and is 2.0x faster at the median.

[16] arXiv:2611.25971 [pdf, html, other]
Title: Kameleo: In-Situ Activation-Precision Selection for Bit-Serial LLM Accelerators
Robin Geens, Thomas Debelle, Marian Verhelst, Chao Fang
Subjects: Hardware Architecture (cs.AR)

Weight-only quantization keeps the activations of large language models (LLMs) in a higher-precision format, pushing the on-chip inference cost to the activation arithmetic. Bit-serial, variable-length accelerators offer a promising path to reduce this cost by lowering activation precision while preserving model quality. They process only the mantissa bits that each layer needs. The length has to be chosen per layer and operator, and today it is chosen by offline calibration: a search driven by the perplexity of the full model on a representative dataset. The search is repeated for every model and workload, and its result degrades silently on other data. This paper presents Kameleo, an accelerator that selects the activation precision at runtime, on the accelerator, from the data it is processing. Kameleo replaces the global perplexity by a local proxy that compares the output of each GEMM at reduced and at full precision. It exploits the fact that a bit-serial datapath produces this comparison almost for free, because the reduced-precision result is an intermediate state of the full-precision computation. Two passes over the first tokens of a workload set the precision of every GEMM. On four LLMs and seven datasets, Kameleo stays within a 1% perplexity budget at a 2.11-2.34x reduction of prefill cycles on the matrix multiplication unit (MXU), close to the reduction of configurations calibrated offline on the evaluation data itself. Calibrated configurations transferred to other data, in contrast, often violate the budget. The selection hardware adds only 3.7% to the accelerator area. Kameleo thereby makes variable-length mantissas feasible in real deployments, where offline calibration for every model and workload is not.

[17] arXiv:2611.26307 [pdf, html, other]
Title: Scalable fault vulnerability analysis for ReRAM-based process-in-memory CNN accelerators
Aniseh Dorostkar, Hamed Farbeh, Hamid R. Zarandi, Meysam Sharifzadeh
Journal-ref: J Supercomput 82, 720 (2026)
Subjects: Hardware Architecture (cs.AR); Machine Learning (cs.LG)

Resistive random-access memory (ReRAM)-based processing-in-memory (PIM) accelerators offer a highly efficient platform for parallel matrix-vector multiplications (VMM) in neural networks, leveraging analog computation, high density, low leakage, and non-volatility. However, their susceptibility to permanent faults, such as stuck-at-high (\textit{SaH}) and stuck-at-low (\textit{SaL}) resistance states, permanently corrupts the convolutional neural networks (CNNs) weights mapped onto ReRAM cell conductance values, thereby degrading inference accuracy and leading to system unreliability in safety-critical applications. Fault injection is a commonly used technique to assess the vulnerability of neural networks by systematically injecting faults into individual parameters and measuring the resulting accuracy degradation. Although this method is accurate, it is prohibitively time-consuming and computationally expensive, especially for large-scale CNNs. In this paper, we propose a fast, scalable, and analytical framework to quantify the fault vulnerability of convolutional neural networks deployed on ReRAM-based PIM accelerators. This method quantifies vulnerability at different granularities, including weights, kernels, and layers, without the need for exhaustive simulation, enabling the design of fault-tolerant accelerators for edge and safety-critical applications. The comparison between the results of the proposed vulnerability score (VS) metrics with performance metric of CNNs captured with fault injection simulations confirms the effectiveness of our proposed method. Unlike exhaustive fault injection, which requires days or weeks, whereas the proposed approach achieves a speedup of about $10^4\times-10^5\times$, enabling fast and accurate vulnerability analysis for large-scale CNNs within only a few minutes or hours.

[18] arXiv:2611.26432 [pdf, html, other]
Title: MaskPE: One Mask, Two Roles: Weight Placement and MAC Gating in Systolic Arrays
Shu-Lin Shih, Chandra Sekhar Mummidi, Aamir Gujral Elhaissouni, Sandip Kundu
Comments: 7 pages, 11 figures
Subjects: Hardware Architecture (cs.AR)

Unstructured pruning reduces weight storage but does not inherently reduce execution cost in conventional weight-stationary systolic arrays. Packed nonzero weights must be restored to fixed processing-element positions, while zero-weight positions must preserve data forwarding. This paper presents MaskPE, a mask-directed systolic architecture that uses positional masks to steer nonzero weights during preload and clock-gate arithmetic registers in zero-weight processing elements during execution, reducing dynamic power while preserving systolic dataflow. At 50% sparsity, MaskPE reduces compressed weight storage by 34.9%, including metadata overhead. RTL validation confirms exact execution with no additional steady-state tile stalls, while gate-level simulations demonstrate 12.5--14.4% lower execution energy across samples of seven LLM projections.

[19] arXiv:2611.26472 [pdf, html, other]
Title: FoldSim: Scaling Cycle-Exact RTL Simulation with Hierarchical Folding and Static Scheduling
Chengxuan Wang, Nikhil Rout, Yang-gon Kim, Jacob Leigh, Yufan Du, Blaise Tine
Subjects: Hardware Architecture (cs.AR)

RTL simulation is essential for hardware design and verification, yet its execution time grows rapidly with design scale and complexity. CPU- and GPU-based simulators exploit parallelism to accelerate RTL evaluation, but achieving high simulation throughput for large designs remains challenging. FPGA-based simulators offer higher throughput by mapping RTL computations directly onto hardware, but their scalability is constrained by FPGA resource capacity.
We present FoldSim, an automated framework that enables cycle-exact simulation of large RTL designs on a single FPGA through hierarchical folding. FoldSim maps instances across the design hierarchy onto shared logic while maintaining their independent state. Given foldable module classes, its compiler constructs a static schedule that coordinates their execution, reducing dynamic synchronization overhead and making state accesses predictable. FoldSim backs state that exceeds on-chip capacity with external memory and brings it to the shared circuits as needed. A configurable DRAM model separates target-memory timing from host delays. The compiler explores replica allocations and state placement to balance resource savings against simulation time.
On one AMD Alveo V80, FoldSim runs an 8-SM GPU and a 1,024-node Rocket datacenter with 4,096 processor cores. The unfolded implementations require approximately 16x and 200x as many LUTs as FoldSim's, respectively. The datacenter keeps about 1.9 GB of state in HBM, while a 4-SM GPU completes a 1024x1024 GEMM in 4.24 seconds, versus 26 hours in software RTL simulation.

[20] arXiv:2611.26517 [pdf, html, other]
Title: From Seed to BLOOM: Autonomously Growing a Better Out-of-Order Core
Angela Cui, Ferran Hermida-Rivera, Jack Toubes, Jim Fang, Chengyi Lux Zhang, Borivoje Nikolić, Christopher W. Fletcher, Sagar Karandikar
Subjects: Hardware Architecture (cs.AR)

Improving microprocessor performance while meeting ASIC implementation constraints like area and frequency is a complex and labor-intensive task that requires expertise across computer architecture, hardware design, and performance analysis and profiling. While large teams in industry can afford the engineering resources to target this problem across performance modeling, RTL design, and ASIC implementations, small teams of researchers and engineers cannot take on this huge engineering burden while keeping up with the pace of advancement in processor microarchitecture. Recent advancements in large language model (LLM) agents present a promising substrate to accelerate this traditionally human-intensive process.
In this work, we build and evaluate MiracleGro, an agentic AI-based system that, without human intervention, analyzes cycle-level RTL behavior and synthesis results, identifies performance bottlenecks, and translates architectural ideas into RTL implementation in a leading open-source out-of-order superscalar application core, the Berkeley Out-of-Order Machine (BOOM). Taking into account cycle-exact performance, area, and critical path, MiracleGro automatically produces improved BOOM designs that drastically increase the human-optimized BOOM's performance on substantial workload suites such as SPEC CPU2017 with full reference inputs.
MiracleGro achieves an 85% IPC speedup and a frequency improvement of 27% in SkyWater 130nm, resulting in a 2.34x wall-clock time speedup on the full SPEC CPU2017 intspeed benchmarks (30 trillion instructions). This result demonstrates the enormous opportunity to harness frontier models to improve state-of-the-art RTL-driven platforms for implementation-grounded microarchitecture research across hardware designs.

Cross submissions (showing 11 of 11 entries)

[21] arXiv:2611.25066 (cross-list from cs.SE) [pdf, html, other]
Title: DVBench: End-to-End Benchmark for Real-World UVM Design Verification Agents
Jiaru Qian, Jiawei Li, Xiaolong Hu, Zheng Shen, LiMing Zhao, Xin Zhang, Siyuan Jiang, Yongqiang Wei, Dong Liu, Jianyang Li, Yihua Chen, Yangxu Liao, Yuxin Wu, Jing Liang, Bin Wen, Junjie Zhang, Yongsheng Han, Yihong Dong, Ge Li
Subjects: Software Engineering (cs.SE); Artificial Intelligence (cs.AI); Hardware Architecture (cs.AR)

Design verification (DV) remains a major bottleneck in hardware development, with large-scale verification using the Universal Verification Methodology (UVM) being highly labor-intensive. Recent advances in large language models (LLMs) and agentic systems offer new opportunities for DV automation. However, existing benchmarks primarily construct mutually decoupled subtasks, which deviates from the real-world workflow. In this paper, we present DVBench, the first end-to-end benchmark for Real-World UVM design verification agents. DVBench comprises 95 tasks across 9 functional domains and 5 difficulty levels, covering diverse verification scenarios and design scales. Each task requires agents to independently complete the full verification workflow. DVBench evaluates final testbenches via compilation, coverage, and bug detection, while assessing intermediate artifacts including feature lists, test plans, and reference models. We evaluate frontier LLMs (e.g. Claude Opus 5.5, GPT-6 Astra) and agent frameworks (e.g. Claude Code, Codex, OpenCode). Experimental results show that the best LLM-based agent (Codex \& GPT-6 Astra) can only achieve an overall success rate of 21.05\%, revealing substantial room for improvement in complex verification tasks.

[22] arXiv:2611.25112 (cross-list from cs.DC) [pdf, html, other]
Title: TripleKV: Predict, Prefetch, Protect -- KV Cache Management for AI Agents
Shashwat Jaiswal, Chloe Alverti, Mengmei Ye, Chen Wang, Hubertus Franke, Fan Lai, Tianyin Xu, Josep Torrellas
Comments: 13 pages, 23 figures
Subjects: Distributed, Parallel, and Cluster Computing (cs.DC); Hardware Architecture (cs.AR); Operating Systems (cs.OS)

LLM agents alternate between inference and tool execution, repeatedly reusing their growing context across calls. Under high concurrency, their combined key-value (KV) cache working set can reach hundreds of GiB, far exceeding GPU memory capacity. As idle KV cache blocks are evicted to slower storage tiers, returning agents incur expensive retrievals that stall inference.
To address this problem, we present \emph{TripleKV}, a three-tier KV cache management system that hides the delays of these retrievals. %exploits tool execution to hide these delays. In agentic workloads, the KV blocks needed by the next inference request are known in advance; only the time of their reuse is uncertain. TripleKV uses a tool-aware latency predictor to estimate when each tool call will complete and prefetches the required KV blocks from SSD into host DRAM ahead of time. Unlike GPU prefetching, this avoids reserving scarce GPU memory and interfering with concurrent inference requests. To further improve DRAM utilization, TripleKV eliminates duplication of GPU-resident blocks in DRAM, and introduces a victim-cache mechanism that refills blocks from SSD upon their eviction from GPU memory.
Across data, web, and coding agents, TripleKV reduces the fraction of requests requiring critical-path SSD reads from 45--76\% to under 10\%. It also reduces P95 time to first token (TTFT) by up to 49\% compared with vLLM extended with DRAM and SSD KV-cache tiers, and achieves 1.5-7$\times$ lower P95 TTFT than recent agent-aware systems.

[23] arXiv:2611.25324 (cross-list from cs.CR) [pdf, html, other]
Title: Verified Netlist-to-RTL Recovery with LLM Agents
Ahmet Efe, Recep Bugra Uludag, Ulya R. Karpuzcu
Comments: 7 pages, 5 figures, 5 tables
Subjects: Cryptography and Security (cs.CR); Hardware Architecture (cs.AR)

Gate-level netlists circulate among IP integrators and foundries and can be extracted from chips. Reverse engineering them into readable register-transfer-level (RTL) code would help an adversary understand and modify a design, but remains difficult because word-level operations are scattered across many gates. Large language models (LLMs) can write and optimize RTL, but often fail to recover it from a whole netlist. We propose LOCA (LOgic Cone Attack), an LLM-based attack that divides an anonymized netlist into logic cones, has parallel agents rewrite them, and assembles compact RTL. Each cone contains the complete next-state logic of a group of related registers, giving an agent a small, meaningful task. Of five partitioning methods tested, only grouped cones lead to recovery. LOCA keeps only RTL proven equivalent to the netlist and measures its quality by compression. Function-preserving obfuscation does not stop LOCA on the tested designs, whereas unknown keys or hidden cell functions prevent it from proving recovery of the original design. Across 21 model-design pairs, LOCA recovers 17, versus 6 with whole-netlist prompting. Per-run recovery across models rises from 5% to 74%, at a median cost below one dollar with a low-cost model.

[24] arXiv:2611.25339 (cross-list from cs.CR) [pdf, html, other]
Title: From FIPS to FPGA with LLM Agents: Measuring What Tests and Reviews Miss in Post-Quantum Cryptographic Hardware
Jungmin Park, Eunha Kim, Wooseop Kim, Seongjoon Cho, Byungho Cha
Subjects: Cryptography and Security (cs.CR); Artificial Intelligence (cs.AI); Hardware Architecture (cs.AR)

As LLM agents increasingly generate RTL alongside the tests and reviews that validate it, self-generated evidence is a weak foundation for trustworthy hardware. We present our seven-stage verification-gated workflow, evolved during a post-quantum design port, in which a gate counts only if shown able to fail on negative controls and fault mutants, and reviewer agents audit work before commit. We then audit this evidence with tool-selected netlist mutants, flaw replays, and formal checks. The flow ported an ML-KEM-768/ML-DSA-65 accelerator to a 300 MHz Zynq UltraScale+ key-custody card: all six operations are byte-exact on the board, and it passes all 85 interface-applicable NIST ACVP cases (of 285) and 484 ML-DSA known answers. However, passing module tests overstate the verification strength. Across three RTL modules, existing simulation gates kill only 76% of 399 tool-selected netlist mutants; specification-derived tests guided by the survivors raise the fresh-draw decapsulation kill rate from 48% to 74%. In pre-registered single-model replays on flaws invisible to known-answer tests, undirected whole-design review catches two verifier flaws in only 3/6 and 1/6 sessions, whereas module-scoped review catches every known flaw in all 54 sessions. Even scoped review detects planted key-custody flaws in only 3/20 sessions, whereas formal checks (one added for the replay) flag every one. In this study, trustworthy agentic hardware needed author-independent mutants for test gates, module-level scoping for LLM review, and formal checks for custody invariants.

[25] arXiv:2611.25352 (cross-list from cs.ET) [pdf, html, other]
Title: Compiling Constraints into Neuromorphic Ising Machines
Faiek Ahsan, Shantanu Chakrabartty
Comments: 41 pages, 6 figures, with Supplementary Information (46 pages)
Subjects: Emerging Technologies (cs.ET); Disordered Systems and Neural Networks (cond-mat.dis-nn); Hardware Architecture (cs.AR); Neural and Evolutionary Computing (cs.NE); Quantum Physics (quant-ph)

Most practical combinatorial optimization problems involve constraints, and an Ising machine that flips one spin at a time can respect them only through energy penalties that raise barriers between feasible solutions. Here we show that a higher-order neuromorphic Ising machine can enforce constraints through programmable transitions rather than penalties. In an autoencoder-like architecture, each inner-layer neuron represents a move, a family of multi-spin transitions that maps every feasible state to another feasible state, receives the energy change of its move through connections that outer-layer neurons multiplicatively switch on or off, and updates the state through the same connections. A compiler turns constraints into this wiring with a number of auxiliary clauses that grows only polynomially for parity, cardinality, one-hot, partition and permutation constraints. Restricting the search to feasible states reduces constraint handling to move design, and we show that the fastest-annealing moves are not those that mix fastest but those that lower the deepest energy barriers, and that moves chosen from the objective lower them further than random ones. On third-order graph matching, the machine needs orders of magnitude fewer iterations than penalty-based neuromorphic machines. Configured as a sampler on a field-programmable gate array, it decodes the surface code with maximum-likelihood accuracy up to code distance 15 within 52 $\mu$s per shot and, under noisy syndrome measurements, decodes in real time for millisecond measurement rounds up to distance 9 with fewer logical errors than belief-propagation decoders.

[26] arXiv:2611.25470 (cross-list from cs.CR) [pdf, html, other]
Title: ToolPulse: Side-Channel Eavesdropping on Tool-Using LLM Agents
Zihao Dan, Jinyu Zhang, Jinzhao Lian, Yun Chen, Shinan Liu
Subjects: Cryptography and Security (cs.CR); Hardware Architecture (cs.AR)

Large language models (LLMs) are increasingly deployed as agents that translate user requests into sequences of local tool invocations. While prior cache-based side-channel attacks target the locally deployed models, they typically require the adversary to share model-related components or hardware resources with the victim's inference process. These assumptions do not apply to the predominant agentic settings, in which commercial LLMs execute on vendor-controlled infrastructure. We show that agentic execution exposes a more practical attack surface: although inference remains remote, tools are executed on the user's machine and commonly rely on shared system libraries. In this paper, we first systematically evaluate Flush+Reload and Prime+Probe for monitoring agentic tool invocations. Our evaluation across three hardware platforms shows that Flush+Reload enables accurate, real-time tool monitoring, whereas Prime+Probe, despite supporting cross-VM attacks, incurs prohibitive monitoring overhead and suffers from cache-set aliasing. We present ToolPulse, a cache-based side-channel eavesdropping framework against tool-using agents. We first design the Tool Recovery Attack to reconstruct an agent's tool-execution workflow. We evaluate the Tool Recovery Attack on 11 LLMs across Codex and Claude Code. It consistently reconstructs tool workflows, with the lowest F1 score exceeding 93%. We further demonstrate two attack scenarios enabled by the recovered traces. Task Profiling Attack infers user intent across two Terminal-Bench task categories and the Trigger Localization Attack identifies sensitive tool calls in encryption/decryption and model training/inference workloads. Even under substantial system noise on a server shared by approximately 20 users, both Task Profiling Attack and Trigger Localization Attack maintain high accuracy.

[27] arXiv:2611.25891 (cross-list from cs.AI) [pdf, html, other]
Title: Meta-RTL: Evolving Agent Harnesses for RTL Optimization
Xinzhuang Xiong, Yonghao Wang, Shengyao Sun, Chengxi Li, Evangeline Young
Comments: 7 pages, 5 figures
Subjects: Artificial Intelligence (cs.AI); Hardware Architecture (cs.AR)

Large language models enable agents to optimize RTL using EDA feedback, yet their executable search procedures remain largely hand- engineered. We present Meta-RTL, an EDA-grounded framework that evolves RTL optimization harnesses from a minimal loop while keeping the optimization model, EDA flow, and per-design budgets fixed. Compared with Dr. RTL, Meta-RTL* reduces aggregate WNS/TNS violations by 7.8%/11.0% across 20 development designs, with area reductions on 70% of them. Without further evolution, Meta-RTL* transfers to 10 unseen IC-RTL designs, reducing aggregate WNS/TNS violations by 20.5%/14.0% and total synthesized area by 12.6%. We further characterize three search mechanisms in the evolved harness and assess their contributions through ablations and a case study.

[28] arXiv:2611.25947 (cross-list from cs.DC) [pdf, other]
Title: Matching Architecture to Workload: Comparing RISC-V Parallel Accelerators for Energy-Efficient Embedded Computing
Luca Colombo, Luigi Ghionda, Amirhossein Kiamarzi, Yvan Tortorella, Riccardo Giunti, Niccolò Giuliani, Samuele Colmi, Angelo Garofalo, Giuseppe Tagliavini, Davide Rossi
Comments: Preprint submitted to the Journal of Parallel and Distributed Computing
Subjects: Distributed, Parallel, and Cluster Computing (cs.DC); Hardware Architecture (cs.AR)

Embedded computing demands high performance and energy efficiency across workloads with widely different computational characteristics. Choosing the most suitable execution model therefore requires a quantitative understanding of how each model maps to different workload classes. In this paper, we compare three execution models for energy-efficient embedded computing: scalar multicore, stream ing multicore, and vector processing. We use three open-source RISC-V accelerators as representative implementations: the PULP Cluster, the Snitch Cluster, and Spatz, respectively. Their open-source hardware and software stacks enable a controlled comparison based on implementations in the same 12 nm technology and a common benchmark suite. Our results reveal that no single execution model performs best across all workload classes. Spatz delivers the greatest benefits for regular and highly vectorizable compute-intensive applications, achieving up to 4.29x higher performance and 5.17x greater energy efficiency than the other architectures. However, its effectiveness strongly depends on the availability of data-level parallelism and regular computation and memory-access patterns, making it the most sensitive to workload characteristics. The Snitch Cluster performs particularly well on applications with limited parallelism and streamable memory-access patterns, providing up to 5.53x higher performance and 1.45x greater energy efficiency. Conversely, the PULP Cluster is most effective on irregular and control-dominated applications, achieving improvements of up to 5.66x in performance and 2.80x in energy efficiency. Compared with Spatz, however, the greater flexibility offered by PULP and Snitch comes at a non-negligible cost in terms of both area and power.

[29] arXiv:2611.26435 (cross-list from cs.DC) [pdf, html, other]
Title: Aggron: Aggressive Compression of Agentic KV Caches during Head-of-Line Stalls in the Request Queue
Rishabh Ravi, Tony Hong, Chen Wang, Yue Zhu, Mengmei Ye, Hubertus Franke, Fan Lai, Josep Torrellas
Subjects: Distributed, Parallel, and Cluster Computing (cs.DC); Hardware Architecture (cs.AR)

LLM agents run long, multi-turn programs whose contexts grow at every step, and serving them is limited by KV cache capacity. To alleviate this limitation, systems use context compression techniques, which typically wait until the KV cache crosses a large threshold and then summarize large spans of history at once, either in the background while the agent progresses or on the critical path. These summarizations can be done using the same model running on the same engine, or using the same or a different model running on extra hardware. When running on the same engine, summarization competes with the requests being served for both compute and memory capacity.
To maximize the cost-effectiveness of summarization, this paper presents a new serving system called {\em Aggron}. Aggron summarizes agentic requests at every turn and selectively summarizes only certain parts of the KV cache. As a result, Aggron retains accuracy and keeps summarization requests lightweight. Moreover, Aggron launches summarization requests from a separate {\em Summarization Queue} while the corresponding agentic request whose KV cache we want to compress is stalled in the main request queue due to head-of-line stalls. The Summarization queue utilizes compute and memory capacity left over by the head-of-line stalls in the main queue. Further, to maximize efficiency, the server issues summarizations only when it predicts that they can complete before the corresponding agentic request will finally execute. In our evaluation, we compare Aggron to state-of-the-art asynchronous summarization. At high load, Aggron reduces P99 program latency by $27$--$31\%$, and raises throughput by $1.34$--$1.40\times$.

[30] arXiv:2611.26447 (cross-list from quant-ph) [pdf, html, other]
Title: Scaling classical hardware for accurate real-time quantum error correction
Chenyang Jin, Susanne F. Yelin, Andi Gu
Comments: 13 pages, 5 figures, 4 Extended Data figures, 1 Extended Data table
Subjects: Quantum Physics (quant-ph); Hardware Architecture (cs.AR); Machine Learning (cs.LG)

Fault-tolerant quantum computation requires a classical decoder fast enough to process syndrome measurements at the rate at which they are generated, and to return its decisions with low latency. This is most demanding for superconducting processors, whose fast syndrome cycles force a trade-off between decoding speed and accuracy. Decoders fast enough to keep up sacrifice accuracy, which must be compensated for with larger codes and thus additional physical qubits. Here we introduce Rapids, a streaming neural decoder that is both fast and accurate. We achieve this by co-designing the decoder with a field-programmable gate array (FPGA): the network is built from operations that map cheaply onto the device and trained in its integer arithmetic. For the distance-19 surface code, Rapids decodes each round of syndromes in under a microsecond on a single FPGA, fast enough for superconducting processors, and returns its decisions with the low latency that fault-tolerant algorithms require. Its logical error rate is 240 times lower than that of existing real-time hardware decoders. The same design extends to the color code and the [[144,12,12]] bivariate-bicycle code, on which our decoder is 16 times more accurate than the real-time Relay decoder. We further show that the decoder scales: spread over several FPGAs or hardened into custom silicon, it becomes faster, more accurate, or able to decode larger codes. Classical hardware thus becomes a further resource, alongside qubits, that can be scaled to improve fault-tolerant quantum computers.

[31] arXiv:2611.26588 (cross-list from cs.SE) [pdf, html, other]
Title: Verify the Verifier: Specification-Grounded LLM Cross-Checking for Bugs That Escape UVM Scoreboards
Ana E. Sanchez Villalobos, Michael D. Quinn, Aakash Tyagi, Minh D. Luu, David Kebo Houngninou
Subjects: Software Engineering (cs.SE); Artificial Intelligence (cs.AI); Hardware Architecture (cs.AR)

A passing UVM regression shows the design agrees with the reference model on what the scoreboard checks, not that it meets the specification. Bugs that pass every test yet violate the specification, termed scoreboard escapes, survive mature testbenches. We present Verify the Verifier, to our knowledge the first framework whose LLM-based Anomaly Cross-Checker examines a passing regression's traces against the specification. Of 564 bugs inserted into four OpenTitan IPs, 68 are candidate scoreboard escapes: non-equivalent, exercised by the tests, yet passing. The framework confirmed 41 as scoreboard escapes with assertions failing on the buggy design and proven on the original.

Replacement submissions (showing 6 of 6 entries)

[32] arXiv:2602.18140 (replaced) [pdf, html, other]
Title: Flex-Plorer: A Precision-Aware Hardware-Software Co-Design Framework for an Edge SNN Accelerator
Mohammad Farahani, Mohammad Rasoul Roshanshah, Saeed Safari
Subjects: Hardware Architecture (cs.AR); Neural and Evolutionary Computing (cs.NE)

Neuromorphic accelerators promise high energy efficiency and computational density for spiking neural networks (SNNs), especially in wearable devices and neural prosthetics where power constraints are stringent. However, most existing platforms exhibit rigid architectures with limited configurability, which restricts their adaptability to heterogeneous signals and diverse design objectives. To address this gap, we present Flex-Plorer, a precision-aware hardware-software co-design framework using heuristic search over weight and decay precisions for a fixed architecture. It couples hardware-aware fixed-point simulation with synthesis-trained LUT/FF estimators and analytical BRAM estimation to guide user-defined accuracy-resource trade-offs without per-candidate synthesis. The best-found configuration generates specialized RTL, drivers, and deployment data. Its substrate, Flexi-NeurA, supports multiple neuron models and topologies through event-driven, time-multiplexed cores with shared neuron datapaths and address-event communication. Design-time component selection and automatic memory sizing specialize the implementation without manual RTL modification. Comprehensive evaluations demonstrate the versatility of the proposed flow across three application domains: (i) auditory processing, achieving 75% accuracy with an energy consumption of 1.48mJ per inference; (ii) dynamic vision sensor gesture recognition, achieving 93% accuracy at 0.55mJ; and (iii) standard vision classification, achieving 97% accuracy at 0.12mJ. Together, Flex-Plorer and Flexi-NeurA form an application-adaptive, energy-efficient co-design flow for deploying SNNs across heterogeneous edge-AI workloads.

[33] arXiv:2610.02502 (replaced) [pdf, html, other]
Title: BROAD: Bit-Parallel Row-Oriented Arithmetic in DRAM
William C. Tegge, João Paulo Cardoso de Lima, Shouzhi Fang, Jeronimo Castrillon, Alex K. Jones
Subjects: Hardware Architecture (cs.AR)

Processing-using-memory (PUM) architectures perform computation directly within DRAM to reduce costly data movement between memory and processors. Because charge-sharing operations are confined to individual bitlines, existing DRAM-PUM architectures reorganize data into column-oriented, bit-serial representations. This organization is fundamentally incompatible with the row-oriented, word-parallel layouts used by conventional processors and accelerators, requiring expensive data-layout transformations whenever computation transitions between PUM and conventional execution. In this paper, we present BROAD, or Bit-Parallel Row-Oriented Arithmetic in DRAM. BROAD augments the DRAM subarray with two lightweight extensions: migration cells that enable localized horizontal data movement between neighboring bitlines and inversion cells that provide efficient in-array logical inversion. These primitives enable BROAD to operate directly on row-parallel, bit-parallel data, preserving CPU-compatible layouts while exploiting the massive parallelism of the DRAM subarray. In particular, BROAD demonstrates that localized horizontal communication is sufficient to realize shallow arithmetic networks and efficient parallel reduction for multiplication, reducing arithmetic latency while preserving throughput and eliminating costly data-layout transformations, all while maintaining the conventional DRAM array organization. We demonstrate the feasibility and overhead of augmenting DRAM subarrays with migration and inversion cells through detailed transistor-level layout and SPICE-validated circuit simulations. Using the BROAD compiler it is possible to evaluate the performance and data reorganization tradeoffs to ensure the best execution across combined CPU and PUM. Evaluating BROAD on 19 MLPerf benchmarks, there is a 5.9x higher end-to-end performance compared to SIMDRAM for DDR4 PUM execution.

[34] arXiv:2611.23878 (replaced) [pdf, html, other]
Title: HETEROVLM: Edge Multi-Request Vision-Language Model Serving on a Heterogeneous Versal SoC with AI Engines and Programmable Logic
Zhiheng Chen, Yu-An Chou, Yifan Zhang, Ye Qiao, Saptarshi Mitra, Sitao Huang
Subjects: Hardware Architecture (cs.AR)

Vision-language models (VLMs) play a pivotal role in enabling autonomous vehicles and robots to perceive and reason about the physical world. Edge computers in autonomous systems typically serve concurrent VLM inference requests with various deadlines, each mixing a compute-bound encoder and prefill stage with a memory-bound decode stage. GPU serving optimizes for high throughput in datacenters, with per-iteration host scheduling, which can cause an urgent request to wait for a long time, and small-batch decode costs much energy per token. Prior accelerators on Versal AI Engine (AIE) SoCs map one model onto a fixed AIE dataflow graph for one input stream, without decode or request scheduling, which limits their capability in serving multiple requests. We present HETEROVLM, which is optimized for multi-request VLM serving on a resource-constrained heterogeneous platform. It keeps the AIE graph static and makes it schedulable. The AIE array runs the encoder, prefill and attention, and the programmable logic (PL) implements GEMV engines for small decode steps and a scheduler that orders short work units by class and deadline. Concurrent requests share one decode step that reads the weights once. An urgent request preempts at a work-unit boundary, and the paused request resumes from its results in DDR memory. On an AMD Versal VC1902, text and camera questions get their first tokens in 140 and 303 ms. HETEROVLM decodes a single request 1.3x and 4.0x faster than NVIDIA Tesla T4 and Jetson Orin Nano Super GPUs, consuming only 61% and 73% of their energy per token, or 51% of the energy per token of an NVIDIA GeForce RTX 3090 Ti. A single bitstream runs multiple VLMs, switching between them at run time. A demo is available at this https URL heterovlm-EFM2/.

[35] arXiv:2609.39131 (replaced) [pdf, html, other]
Title: Characterizing High Bandwidth Flash for LLM Serving
Zack Yu, Chloe Wong, Coleman Hooper, Minjae Lee, Wonjun Kang, Youngjin Cho, Michael W. Mahoney, Yakun Sophia Shao, Kurt Keutzer, Amir Gholami
Comments: 7 pages, 2 figures, 7 tables. v3: updated results and revised text. Accepted to the RAISE-Arch workshop at MICRO 2026
Subjects: Machine Learning (cs.LG); Hardware Architecture (cs.AR); Distributed, Parallel, and Cluster Computing (cs.DC)

Large language model (LLM) serving requires substantial memory to store model weights and KV caches. Agentic workloads compound this pressure through repeated interactions over growing contexts, making it important to retain KV cache for reuse. High-bandwidth flash (HBF) offers a way to expand accelerator memory capacity for LLM serving, but its access costs and limited write endurance complicate its use. We evaluate HBF for high-throughput agentic serving across system design and scheduling choices to understand when additional capacity improves serving performance and energy efficiency. We introduce an HBM-HBF-host hierarchical storage system and buffered cache-aware scheduling, and use trace-driven simulations to analyze their effects on performance, energy consumption, and HBF write lifetime. Across the evaluated workloads, the fastest HBF-augmented systems reduce completion time by 21.1-86.9% relative to HBM-only systems. Modeled energy savings reach 62.4%, with benefits depending on the workload and weight placement. Buffered cache-aware scheduling extends estimated HBF write lifetime from 0.99 to 13.63 years in the evaluated configuration. These results demonstrate the importance of coordinating data placement and scheduling in serving LLM with HBF, positioning HBF as an actively utilized lower-level memory tier rather than passive storage.

[36] arXiv:2610.07593 (replaced) [pdf, html, other]
Title: TRANSIT: Transparent Scale-in for Multi-Node LLM Training
Hyungyo Kim, Nicholas Satchanov, Hrishi Shah, Gaohan Ye, Jiaqi Lou, Robert Walkup, Shweta Salaria, I-Hsin Chung, Hubertus Franke, Seetharami Seelam, Apoorve Mohan, Nam Sung Kim
Comments: 14 pages, 14 figures, 2 tables
Subjects: Distributed, Parallel, and Cluster Computing (cs.DC); Hardware Architecture (cs.AR)

The growing memory requirements of large language models (LLMs) increasingly force distributed training jobs to span multiple GPU nodes to accommodate their training state. This reduces per-GPU computational efficiency, increases network traffic, and exacerbates job queueing delays. To address these inefficiencies, we introduce TRANSIT, a system that transparently enables efficient distributed LLM training on fewer GPUs through memory oversubscription. TRANSIT optimizes CPU-GPU data movement during oversubscription by coordinating driver-managed page residency with execution-guided zero-copy access, exploiting recurring kernel execution patterns across training iterations.
We evaluate TRANSIT on dense and mixture-of-experts (MoE) models across different parallelization strategies using up to 64 NVIDIA H100-80GB GPUs interconnected over RDMA over Converged Ethernet (RoCE). Compared with the minimum GPU count required to accommodate the training state in GPU memory, TRANSIT enables training on up to 50% fewer GPUs while retaining over 90% of the baseline per-GPU computational throughput. In some configurations, training on 17-33% fewer GPUs even improves throughput due to reduced distributed communication overhead. When training on fewer GPUs, TRANSIT achieves up to 243% and 87% higher throughput than conventional driver-runtime-managed memory oversubscription and framework-managed CPU offloading, respectively, while reducing CPU memory consumption by up to 79% compared with the latter. Training on fewer GPUs with TRANSIT also reduces per-node network traffic by up to 33% and improves throughput by up to 44% under constrained network bandwidth. Production-trace-driven simulations further show 15-49% lower inter-rack network traffic and up to 2-95% shorter job queue times for different cluster capacities.

[37] arXiv:2611.17108 (replaced) [pdf, html, other]
Title: LazyWeights: Decode-on-Demand Edge LLMs
Arnab Sanyal, Gourav Datta, Sandeep P. Chinchali
Comments: 6 pages, 1 reference page, 5 figures, 6 tables
Subjects: Machine Learning (cs.LG); Hardware Architecture (cs.AR); Computation and Language (cs.CL); Information Theory (cs.IT)

Memory determines which large language models (LLMs) an edge device can run and how fast it runs them: capacity limits a 4 GB Jetson Nano, and bandwidth limits an 8 GB Jetson Orin Nano Super. Deployed weight formats (GPTQ, AWQ, and the GGUF K- and I-quants) spend the same number of bits on every integer code of a matrix, although the codes are far from uniform. We present LazyWeights, which keeps these formats, tunes GPTQ so the codes compress, Huffman-codes them losslessly in interleaved lanes, and decodes them on demand in a small unit between DRAM and L2, so GPU kernels run unchanged and DRAM moves only coded bytes. At 1% and 3.5% perplexity budgets, coded Phi-3-mini, Mistral-7B and SmolLM-1.7B are 5.7-31.4% smaller than the best GGUF format. A bit-exact 0.21 mm^2 ASIC decoder unit (1 GHz, 7 nm) cuts Orin latency and energy per token by up to 36% and 38% (54% and 44% with prompt-lookup speculation). On the Nano, LazyWeights needs 58-64% less time and 53-57% less energy per token than the GGUF runtime on the CPU, and runs a streamed Mistral-7B 6.6x faster at 3.89 bits per weight. A Huffman decoder beats an rANS decoder in rate and area at equal throughput, and the unit runs bit-exact on a Zynq UltraScale+ FPGA (AMD ZCU102).

Total of 37 entries
Showing up to 2000 entries per page: fewer | more | all
We gratefully acknowledge support from our major funders, member institutions, , and all contributors.
About · Help · Contact · Subscribe · Copyright · Privacy · Accessibility · Operational Status (opens in new tab)