ECE1756_lecture9_part1_2026_logic_blocks
Overview
Vaughn Betz explains how Altera and Xilinx balance LUT size, fracturability, cluster routing, and registers, then shows why FPGA arithmetic benefits from dedicated carry chains embedded in logic blocks. The lecture compares Altera's 8-input ALM and 10-ALM clusters with Xilinx's Versal architecture, and derives how carry-chain adders reduce LUT use and can support 32-bit addition above 500 MHz; it also previews Assignment 3, a RAM-mapping CAD tool due December 3.
Key takeaways
- Altera's eight-input ALM gave synthesis more opportunities to pack small LUTs: the Stratix II results reported 15% lower delay and 3% lower implemented-design area than the earlier four-LUT architecture.
- A fast dedicated connection improves timing only if it accelerates the actual critical path; speeding up one input of a multi-input LUT often leaves another input as the bottleneck.
- Larger logic clusters need more input connections and wider routing channels, so reducing logic-block count does not eliminate the routing cost of increased cluster size.
- A 32-bit ripple adder built from four-LUTs uses about 64 LUTs and can have a roughly 16-nanosecond path at 500 picoseconds per LUT-plus-routing hop.
- Embedding a dedicated carry chain inside each logic cluster reuses existing LUT ports and avoids the routing overhead of standalone adder blocks, enabling 32-bit addition above 500 MHz.
- FPGA architecture should prioritize functions that are both common and inefficient in soft logic; addition and subtraction often account for 10% to 30% of design operations.
Chapters
- Assignment 3 is worth about 21% of the final mark and is planned to be due December 3, nearly three weeks after release.
- The tool will map requested RAMs onto the physical RAM resources in a target FPGA, combining blocks or using logic when needed.
- Because RAM mapping resembles computationally hard bin packing, start with a simple working algorithm, validate it with the provided legality checker, then optimize.
- Keep architecture parameters configurable for the assignment's second phase, which uses the tool to explore alternative FPGA RAM architectures.
- Earlier results favored four-input LUTs for area and six-input LUTs for speed, motivating Altera's attempt to gain both benefits.
- A six-LUT can be viewed as two five-LUT truth tables followed by a multiplexer.
- A minimal fracturable design adds a second output, allowing two five-LUT functions but requiring them to share all five inputs.
- The same structure can pack smaller functions, such as a three-LUT and a two-LUT, with less restrictive input sharing.
- Altera's ALM exposes eight inputs, compared with the six inputs needed for a conventional six-LUT.
- The extra input flexibility allows combinations such as a five-LUT with a three-LUT or two four-LUTs, provided the functions fit within eight distinct inputs.
- This is more flexible than the lower-cost Xilinx-style fracturable LUT, where two five-LUTs need to share substantially more inputs.
- Altera briefly supported a special two-six-LUT mode with four shared inputs and matching functions, but removed it from newer devices such as Agilex.
- Altera's Stratix II paper reported that about 80% of mapped LUTs had five or fewer inputs, creating opportunities to pack small functions together.
- Adding two inputs to a six-LUT structure enabled more dual-LUT packing while retaining a six-LUT mode for speed.
- The resulting architecture delivered a reported 15% delay reduction and 3% implemented-design area reduction compared with the earlier four-LUT architecture.
- Quartus can tune synthesis for speed or area: speed-oriented mapping uses more six-LUTs, while area-oriented mapping favors smaller LUTs.
- Altera's experiments found a cluster of about 10 ALMs gave a strong area result, with larger clusters offering some additional speed at an area cost.
- The Stratix II generation used eight ALMs per cluster; later generations moved to 10 and retained that size.
- Larger clusters need more inputs because they contain more logic, which raises the average number of used inputs, lambda.
- With similar placement locality, increasing lambda increases routing-channel width, even though fewer logic blocks may be needed overall.
- Altera added a second register to the fracturable LUT structure so both five-LUT outputs could be registered in dual mode.
- Small two-to-one muxes let registers take data from routing inputs or feed their outputs back into LUT inputs.
- These paths help fit pipeline and valid-bit registers into otherwise underused ALMs without adding expensive routing ports.
- Betz reported that the register-mux change improved area by about 9% in the evaluated designs.
- A dedicated LUT-to-register connection is faster than routing through the cluster and can reduce delay on a path ending at that register.
- A dedicated register-to-LUT input path did not improve overall benchmark speed, despite seeming like a useful shortcut.
- The reason is that a useful LUT usually has multiple inputs; speeding up only one input leaves another input as the timing bottleneck.
- Betz noted that a critical-path improvement matters only when it speeds the longest path, and a single fast input cannot consistently do that.
- Newer process technologies make thin, lower-level metal wires more resistive, increasing delay even across a logic block.
- Agilex, used in Assignments 1 and 2, retains long local interconnect but adds shorter wires that reach only a subset of ALMs.
- The shorter connections provide faster feedback among nearby ALMs; signals that need to cross the full block use slower, longer local routing.
- This extra routing hierarchy improves speed but makes placement and routing CAD more complex.
- Xilinx's earlier fracturable six-LUTs minimized extra input hardware, making two five-LUT functions harder to pack than in Altera's eight-input ALM.
- Versal changed the structure so dual five-LUT mode can use six inputs, reducing the required sharing from five inputs to four.
- Xilinx uses two registers per fracturable LUT and provides a dedicated routing port that can feed registers directly but cannot feed LUTs.
- That dedicated port can make it easier for designers using Vivado to move registers during manual placement refinement.
- Xilinx increased its logic cluster from eight fracturable LUTs in earlier architectures to 32 in Versal.
- The Versal paper reported that internal cluster connections rose from capturing about 2% of design connections to about 15%.
- Xilinx made local routing more flexible to keep more signals inside the cluster, adopting some characteristics associated with Altera's approach.
- The larger block trades additional internal complexity for fewer connections that must use global FPGA routing.
- Using four-input LUTs, Betz constructs each adder bit with one LUT for the sum and one for the carry.
- A 32-bit ripple-carry adder therefore uses about 64 LUTs, with each carry LUT feeding the next bit.
- The carry chain creates a critical path through roughly 32 LUT stages, unlike the parallel sum outputs.
- At an illustrative 500 picoseconds per LUT-plus-routing hop, the path takes about 16 nanoseconds, limiting the clock to roughly 62.5 MHz.
- A 32-bit bitwise AND needs 32 LUTs, one per output bit, but each LUT has only two active inputs.
- Independent AND outputs have a one-LUT critical path, so the example can tolerate additional logic without a long serial dependency.
- Unused LUT inputs can often absorb extra functions, such as combining two AND terms with an OR.
- Addition is slower because each high-order output depends on a sequence of carry calculations from lower bits.
- Addition and subtraction account for roughly 10% to 30% of operations in a typical FPGA design, and often more in signal processing or deep learning.
- Ripple carry implemented with LUTs is both area-inefficient, at about two LUTs per bit, and slow because of its serial carry dependency.
- Carry-lookahead, carry-select, and carry-skip adders can improve speed in programmable logic, but generally require more area.
- Because arithmetic is common and inefficient in soft logic, FPGA architects add hardened arithmetic circuitry.
- A standalone five-bit adder block can use compact gates and a fast dedicated carry path, with carry-in and carry-out links for chaining.
- Its apparent logic simplicity hides the cost of bringing in five A bits, five B bits, and carry-in through programmable routing.
- Routing ports are expensive, so a larger adder block can approach the size of a logic block once its input and output connections are included.
- Separate arithmetic columns also complicate placement and can stretch connections between ordinary logic and the adder blocks.
- The more efficient approach places hardened carry circuitry inside each logic cluster, reusing existing routing ports instead of creating a separate block.
- A four-LUT contains two three-LUT subfunctions whose outputs can feed a small adder directly.
- The LUT subfunctions can pass through A and B, while the embedded adder computes the sum and passes carry to the next bit.
- This architecture reuses existing LUTs and cluster connections, adding only a small adder and a two-to-one output mux.
- A logic block with 10 four-LUTs can chain 10 embedded adders before sending carry out of the block.
- The design reuses LUT input and output ports, avoiding the extra programmable-routing inputs that made standalone adder blocks costly.
- The added hardware is a small adder and output-selection mux per bit, while the LUT resources already exist in the cluster.
- Compared with a LUT ripple adder, the embedded chain can cut LUT use roughly in half and replace long programmable-routing delays with short wires and gate delays.
- For A + B, two internal three-LUT functions can pass A and B into the fixed adder.
- For A - B, the LUTs pass A and the complement of B, and the carry-in is set to logic 1, implementing A + not-B + 1.
- The dedicated carry path is estimated at about 10 to 50 picoseconds per bit, depending on process technology and area choices.
- Even across 32 bits, the chain can exceed 500 MHz, while using about half as many LUTs as a soft ripple-carry implementation.
Transcript excerpt
0:00 Welcome, everybody. Sorry I'm a few minutes late. Uh, so let's let's get right to it. Okay, so uh, assignment two, you handed in. Hopefully it all went well. Assignment three is coming out tonight or tomorrow. Um, it's worth Actually, this is wrong. It's like 21% of your final mark now. So it's been reduced slightly. Uh, and yeah, my plan is to make it due December 3rd, so almost three weeks. This one's a bit different. Uh, it is uh, it's a software tool. So you're developing um by the end of this lecture we should get to information that will help you with this assignment. But basically you're going to develop a RAM mapping CAD tool. So we haven't done RAM mapping yet, but should
0:46 be doing it towards the end of this lecture. Um, so basically you you'll see this in the handout and in today's lecture. The way an FPGA designer normally asks for RAM is you you just write I want a RAM this big, and you don't worry about what's on the chip. Uh, and so there's a phase of the FPGA CAD flow that does what's called RAM mapping. Says takes the RAMs that you asked for and figures out how can I implement them on this chip with the resources that actually exist, which will generally be RAMs that are not the size you asked for. So we got to build uh look at the RAMs that physically exist, figure out how we could combine them with some logic or other things and make the RAMs that you actually asked for. Um, this is related to bin packing, and bin packing is already a computationally hard
1:35 problem. Um, meaning there are no perfect solutions that run in sort of guaranteed fast time.
This is the start of the transcript. Save this video free for the whole transcript, searchable and time-coded.
In this course
Related notes
Summary, takeaways, and chapters were generated by AI from the video's transcript and may contain errors. The video belongs to its creator, Vaughn Betz.