Papers for

fpga design teams

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

Technique detects faults effectively in cluster-based FPGA chips

Detection of Single Stuck-at and Bridging Faults in Cluster-based FPGA Architectures

Abstract: This paper presents a new technique for detecting single stuck-at and bridging faults in cluster-based FPGA architectures, using same set of test vectors generated by a test pattern generator circuitry. This technique is based on configuration of logic elements using test logic structure and the outputs of two separated logic elements are compared to detect a fault. To do this, block under test, TPG and output response analysis circuitry are generated in FPGAs. The configurations of test pattern generation, block under test and output response analysis are also discussed in this paper. The novelty lies in the fact that the same set of test vectors can detect all the stuck-at as well as bridging faults if the test vectors are applied in a particular sequence and analyzing the output results. We presented a detail analysis of results to detect faults as well.

Mon 26 OctHardware Architecture
The gist
Detecting faults in FPGAs, which are chips that can be programmed for different tasks, is important to make sure they work correctly. This paper shows a method to find two types of common faults using the same set of test inputs in a clever way. The authors use special logic setups inside the FPGA to compare outputs and identify errors without needing different tests. Their approach helps find faults by analyzing outputs after applying test sequences, making testing simpler and more efficient.
Open → 2610.35026v1

LUT-aware transformer speeds up FPGA real-time processing

LEAF: LUT-aware Efficient Attention on FPGAs

Abstract: We introduce Lookup-table (LUT)-aware Efficient Attention on FPGAs (LEAF). LEAF is the first nanosecond-scale LUT-aware transformer for FPGAs. Deploying transformers that are large enough to perform well, small enough to fit on an FPGA, and fast enough to meet the sub-microsecond timescales required by real-time systems such as those at CERN remains difficult, since the same attention mechanism that gives these models their high expressivity also makes them costly to implement in hardware. LEAF converts the query, key, and value projections and the final output feed-forward layer into FPGA-native layers with LUT-aware training, creating the first LUT-aware transformer and linformer layers built for ultra-low-latency inference. Attention resists LUT-aware training because it multiplies two activations where the method needs a constant weight to tabulate; LEAF tabulates the attention block's constant matrix-vector multiplications and leaves the rest in arithmetic form. On a standard jet tagging benchmark this improves accuracy by 1.8 percentage points while using 2.9 times fewer LUTs than the previous state-of-the-art sub-microsecond transformer at the same input size. Our most efficient LEAF-based linformer with 64 input particles reaches 80.4% classification accuracy at 28k LUTs and 35ns.

Mon 19 OctMachine Learning
The gist
Making machine learning models called transformers run very fast on special computer chips called FPGAs is hard because the math inside transformers is complicated. The authors created a new method called LEAF that changes parts of the transformer to fit the way FPGAs work best. This method makes the model use fewer hardware resources and run much faster while keeping good accuracy. Their approach is especially useful for tasks that need results in just nanoseconds, like certain physics experiments.
Open → 2610.27078v1

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