What Is an FPGA? — Brief ☧
Deep version → | Next: Registers & Clocks → | Back to Module 3 →
Q: When God called Bezalel to build the Tabernacle, He filled him
"with the spirit of God, in wisdom, in understanding, and in knowledge,
and in all manner of workmanship" (Exodus 35:31). Bezalel did not buy
the Tabernacle pre-built. He configured raw materials into sacred
structure. What is the silicon equivalent?
A: Think of a box of LEGO bricks. The box itself is not a castle
or a bridge — it is raw potential. You snap the pieces together to make
whatever you need. An FPGA (Field-Programmable Gate Array) works the
same way: it is a chip that arrives as blank fabric, and you configure
it into any digital circuit you want. Bezalel shaped gold and acacia
wood; we shape tiny building blocks called LUTs and flip-flops.
Q: Okay, but what actually is a LUT? You said it is a building block.
A: Picture a small lookup chart with 64 rows. You give it 6
yes-or-no inputs (like 6 boolean switches), and it instantly
tells you the answer from its chart. Because you can fill the chart
with any pattern, a single LUT can compute any logical function of
those 6 inputs — AND, OR, XOR, or something exotic you invented.
The FPGA contains hundreds of thousands of these tiny lookup charts.
They are the "gold ingots" of our Tabernacle.
Q: And you mentioned flip-flops. Are those like memory?
A: Exactly. A flip-flop is the simplest possible memory: it stores
just one boolean value — a single 0 or 1. But it does something
clever: it only updates its stored value at a specific moment, when
the clock signal ticks (we will cover clocks in the next topic). So
LUTs compute and flip-flops remember. Together they can build any
digital system.
Q: Why not just use a regular CPU? My laptop has one of those.
A: A CPU is like one very talented craftsman working through a long
list of instructions one at a time (or a few at once, with
pipelining). An FPGA is like a workshop full of craftsmen, each
doing their own task simultaneously. For our bitmask
intersections, we run 8 lanes in parallel — each lane is its own
independent circuit crunching data at the same time as every other
lane. A CPU would have to process them one after another.
The Three Primitives
Everything on an FPGA is built from just three kinds of building blocks.
Understanding these three is like understanding that all matter is made
of atoms -- once you grasp the primitives, you can understand any design.
| Primitive | What it does | Analogy |
|---|---|---|
| LUT | Any boolean function of 6 inputs | A craftsman's tool — flexible |
| Flip-flop | Stores 1 bit, updates on clock edge | A jar that holds one measure |
| Routing | Wires connecting LUTs and FFs | The roads between workshops |
The LUT is where computation happens -- it can implement any logical
function of its 6 inputs, because it is really just a small lookup table
(hence the name) that you pre-load with whatever truth table you need.
The flip-flop is where memory lives -- it holds a single bit of state
and only updates on the clock tick, giving the design its rhythm. And
routing is the connective tissue that lets LUTs talk to flip-flops and
to each other. Together, these three primitives can build any digital
circuit -- from a simple counter to our 8-lane constraint intersection
engine.
Our FPGA (AWS F2, Virtex UltraScale+ HBM) has roughly:
- ~1.1 million LUTs
- ~2.2 million flip-flops
- ~2,000 BRAM blocks (36 Kbit each)
- 8 GB HBM2 with ~460 GB/s bandwidth
Each of our 8 compute lanes uses approximately 50,000 LUTs. That means
our entire 8-lane design consumes about 400,000 LUTs out of 1.1 million
available -- roughly 36% of the chip. This leaves plenty of room for
the scheduler, memory interfaces, and future expansion.
Soli Deo Gloria