FPGA Architecture
FPGA & Programmable Logic · Hardware Foundations track
9 min read
In this module
The Fabric of Reconfigurable Hardware
A single CLB can hold a small Boolean function and a few bits of state — useful, but on its own you can't build much. A network packet parser, a cryptographic engine, an entire soft-core processor: each demands thousands of CLBs wired together. The programmable routing fabric is what makes that possible, and it eats up most of an FPGA's silicon area.
To grasp the full architecture you need more than logic blocks. The routing network, the hardened IP blocks, the memory subsystem, the clock distribution, the I/O ring — together they decide what a given FPGA can do and how fast.
Programmable Routing Fabric
The routing fabric is a grid of pre-fabricated wire segments and programmable switches. Every connection in your design — every wire from a LUT output to a flip-flop input, every bus between an adder and a register — gets implemented by flipping on the right combination of switches.
Switch Boxes and Connection Boxes
The routing architecture has two key components:
Connection boxes sit at the interface between CLBs and the routing channels. Inside each are programmable switches that hook CLB pins (LUT inputs, flip-flop outputs) up to the wire segments running through the horizontal and vertical routing channels. Each CLB pin reaches a subset of the available segments.
Switch boxes sit at the intersections of horizontal and vertical routing channels. They hold programmable switches that connect wire segments from different channels, letting signals turn corners and traverse the chip.
Here's one net routed across three tiles, from a LUT output in CLB A to a LUT input in CLB C. Each labelled edge is one programmable switch whose configuration bit the bitstream sets to 1. Every other switch it passes, including the ones into CLB B, stays at 0. Track and pin names are illustrative.
Each switch is a pass transistor (or buffered multiplexer) gated by an SRAM configuration bit. Bit set to 1, switch closed, wire segments connected. Bit at 0, isolated.
Wire Segment Lengths
Modern FPGAs provide wire segments of different lengths:
- Single-length wires: Span one CLB tile. Used for local connections between adjacent CLBs.
- Double-length wires: Span two tiles. Reduce the number of switch boxes a signal must pass through.
- Quad-length wires: Span four tiles.
- Long lines: Span an entire row or column. Used for global signals like resets and clock enables.
Longer wires cut delay across distant connections, but they're a scarce resource. Place-and-route picks wire lengths to keep total delay down.
In a typical FPGA design, 60-70% of the total path delay comes from routing, not from the LUT logic itself. A LUT lookup takes roughly 100-200 picoseconds; the routing delay through multiple switch boxes and wire segments can be several nanoseconds. This is why place-and-route quality is critical for FPGA performance - the same logical design can run at very different clock frequencies depending on how well the tools place and route it.
Block RAM (BRAM)
You can build memory from LUTs, but it's wasteful. One 6-LUT holds 64 bits of SRAM, so a 1 KB buffer would burn through 128 LUTs. FPGAs sidestep that with Block RAM (BRAM): dedicated columns of hardened SRAM blocks scattered across the fabric.
BRAM Characteristics
A typical BRAM block (Xilinx 7-series, UltraScale):
- Size: 36 Kb per block (can be split into two independent 18 Kb blocks)
- Ports: True dual-port (two independent read/write ports with separate clocks)
- Width: Configurable from 1 bit wide x 32K deep to 72 bits wide x 512 deep. The block holds 36 Kb in total, but the extra 4 Kb are parity bits that only the 9-bit-and-wider shapes can use
- Modes: Single-port RAM, true dual-port RAM, simple dual-port RAM, ROM, FIFO
- Access time: Single clock cycle read latency
You'll see BRAMs holding FIFOs, register files, small caches, coefficient tables, anything on-chip that would be ruinous to build from LUTs. A mid-range FPGA might pack several hundred BRAM blocks, totalling a few megabits of on-chip storage.
LUTs can also be configured as small distributed RAM (typically 64-bit or 256-bit). Distributed RAM is useful for very small memories (like a 32-entry register file) because it has zero routing delay to nearby logic. BRAM is used for larger memories. The synthesis tool automatically chooses between distributed and block RAM based on the memory size and access pattern in the HDL code.
DSP Slices
Digital signal processing lives or dies on fast multiply-accumulate (MAC) operations. You can build multipliers from LUTs, but they devour logic. FPGAs sidestep this with hardened DSP slices: dedicated multiply-accumulate units in custom silicon, not programmable fabric.
A typical DSP slice (Xilinx DSP48E2) provides:
- A 27x18-bit signed multiplier
- A 48-bit accumulator with pre-adder
- Pattern detection logic for convergent rounding and overflow detection
- Cascade ports to chain DSP slices for wider operations
DSP slices run at the full FPGA clock and sip a fraction of the power LUT-built equivalents would. They're indispensable for signal processing, ML inference, and any cryptographic work leaning on modular arithmetic.
Clock Management
Digital circuits live on clean, stable clock signals spread across the entire die with negligible skew. FPGAs use dedicated Clock Management Tiles (CMTs) to deliver them.
PLLs and MMCMs
Each CMT contains one or more Phase-Locked Loops (PLLs) or Mixed-Mode Clock Managers (MMCMs) that can:
- Multiply the input clock frequency (e.g., 100 MHz input to 300 MHz output)
- Divide the input clock frequency (e.g., 100 MHz to 25 MHz)
- Phase-shift the output clock relative to the input
- Generate multiple output clocks at different frequencies from a single input
- De-jitter an external clock by locking to its average frequency
Clock Distribution Networks
FPGAs run dedicated global clock networks: low-skew, high-fanout routing resources kept separate from the general fabric. These networks keep the clock edge arriving at every flip-flop within a tight window — typically tens of picoseconds of skew across the entire die.
Modern FPGAs also provide regional clock networks that serve a subset of the chip, keeping power consumption down when a clock domain doesn't span the whole device.
I/O Blocks
The I/O blocks form a ring around the FPGA die and interface the internal logic with external signals. Each I/O block contains:
- Input and output buffers supporting multiple voltage standards (LVCMOS 1.8V/2.5V/3.3V, LVDS, HSTL, SSTL)
- Programmable drive strength and slew rate control
- Input delay elements (IDELAY) for fine-grained timing adjustment
- SerDes (serialiser/deserialiser) in high-speed I/O banks for multi-gigabit serial interfaces
I/O blocks group into banks, each fed by its own voltage supply. So one FPGA can talk to devices at different voltage levels — say, 1.2V DDR4 memory on one bank and a 3.3V UART on the next.
Low-Voltage Differential Signalling (LVDS) uses a pair of pins carrying complementary signals. The receiver detects the voltage difference between the pair rather than the absolute voltage, providing excellent noise immunity. LVDS is commonly used for high-speed inter-chip communication, ADC links, and display interfaces, and camera interfaces such as MIPI use closely related low-swing differential signalling. Modern FPGA I/O banks that support LVDS commonly run it at around 1 to 1.6 Gbps per pair, depending on the family and speed grade.
Modern FPGA Features
Today's high-end FPGAs go far beyond basic logic, memory, and I/O. They integrate substantial hard IP blocks:
Hard Processor Cores
Xilinx/AMD Zynq and Zynq UltraScale+ devices drop ARM Cortex-A cores (plus Cortex-R cores) onto the same die as the FPGA fabric. The processor runs Linux or a bare-metal app; the FPGA fabric handles the hardware acceleration. They talk over high-bandwidth AXI interconnect.
The processor-plus-fabric arrangement is the System on Chip (SoC) FPGA. Altera offers an equivalent family (Agilex, Stratix 10 SoC) with ARM cores.
High-Speed Transceivers
Modern FPGAs include GTH/GTY transceivers (Xilinx/AMD) or HSSI transceivers (Altera) that support serial links at 10-58 Gbps per lane. These are used for:
- PCIe Gen3/Gen4/Gen5 interfaces
- 10/25/100 Gigabit Ethernet
- JESD204B/C high-speed ADC/DAC interfaces
- Custom serial protocols
Hardened Protocol Blocks
To avoid consuming FPGA fabric for common protocols, modern devices include hardened blocks for:
- PCIe: Full PCIe endpoint/root-port controllers
- Ethernet MAC: 10G/25G/100G Ethernet
- DDR memory controllers: Hardened DDR4/DDR5 memory interfaces
- Interlaken: High-speed chip-to-chip interconnect
AMD's Versal adaptive SoCs push this furthest: alongside the fabric and Arm cores they add arrays of AI Engines (small VLIW vector processors for signal processing and machine learning) and a hardened network-on-chip that links everything without spending fabric routing on it.
You don't need a vendor licence to get hands-on with any of this architecture. The open-source Yosys (synthesis) and nextpnr (place and route) toolchain fully supports Lattice iCE40 and ECP5 parts, which sit on boards costing tens of pounds, and you can inspect exactly how your design maps onto LUTs and routing.
FPGA Fabric Summary
A complete FPGA is a heterogeneous mix of resources. Programmable logic (CLBs) gives you flexibility to implement any digital circuit. Hard IP blocks (BRAM, DSP, transceivers, processor cores) deliver the area and power efficiency of custom silicon for common functions. The routing fabric ties it all together. Your job is to describe the desired circuit in a hardware description language and let the tools map it onto these resources, which is where the next lesson picks up.