Skip to main content
Dwarkesh Podcast

Reiner Pope – Chip design from the bottom up

80 min episode · 2 min read
·
Reiner Pope

Episode

80 min

Read time

2 min

Topics

Productivity, Investing, Startups

AI-Generated Summary

Key Takeaways

  • Quadratic precision scaling: Halving numeric precision (e.g., FP8 to FP4) reduces multiply-accumulate circuit area quadratically, not linearly. A 4-bit multiplier requires 4× fewer gates than an 8-bit one. This is why NVIDIA's B300 reports FP4 as 3× faster than FP8, though the true theoretical advantage is 4×. Lower precision delivers disproportionate efficiency gains for AI workloads.
  • Data movement dominates compute cost: In a standard CUDA core with an 8-entry register file, the MUX circuits selecting inputs consume roughly 24×p AND gates just to move data, versus only 4×p gates for the actual multiply-accumulate logic. Over 85% of circuit area serves data movement, not computation. This imbalance motivated the introduction of tensor cores and systolic arrays.
  • Systolic arrays amortize communication: Tensor cores and TPU matrix units store weight matrices locally inside the systolic array, reusing them across many input vectors. This reduces register file bandwidth requirements from O(x²) to O(x), matching compute scaling. Weights are loaded slowly via daisy-chain over many clock cycles, trading load latency for dramatically reduced wiring bandwidth.
  • Clock cycle optimization tradeoff: Inserting pipeline registers between logic stages doubles achievable clock frequency but consumes additional area. Pushing clock speed too high means most die area goes to synchronization registers rather than compute logic, reducing throughput despite higher frequency. Optimal chip design balances gates-per-cycle against cycles-per-second, analogous to batch size tradeoffs in inference serving.
  • FPGA versus ASIC economics: FPGAs implement any logic circuit via programmable lookup tables (truth tables with 16 entries for 4-bit inputs) and configurable MUX routing, but each lookup table consumes ~32 gates to implement what an ASIC does in 3 gates. This ~10× area penalty is the direct cost of reprogrammability. First ASIC tape-out costs ~$30M versus ~$10K for FPGA deployment.

What It Covers

Reiner Pope, CEO of Maddox AI chip company, explains chip architecture from logic gates through multiply-accumulate units, systolic arrays, register files, clock cycles, FPGAs, and GPU versus TPU design tradeoffs, revealing why data movement costs dominate compute costs at every level of the hardware stack.

Key Questions Answered

  • Quadratic precision scaling: Halving numeric precision (e.g., FP8 to FP4) reduces multiply-accumulate circuit area quadratically, not linearly. A 4-bit multiplier requires 4× fewer gates than an 8-bit one. This is why NVIDIA's B300 reports FP4 as 3× faster than FP8, though the true theoretical advantage is 4×. Lower precision delivers disproportionate efficiency gains for AI workloads.
  • Data movement dominates compute cost: In a standard CUDA core with an 8-entry register file, the MUX circuits selecting inputs consume roughly 24×p AND gates just to move data, versus only 4×p gates for the actual multiply-accumulate logic. Over 85% of circuit area serves data movement, not computation. This imbalance motivated the introduction of tensor cores and systolic arrays.
  • Systolic arrays amortize communication: Tensor cores and TPU matrix units store weight matrices locally inside the systolic array, reusing them across many input vectors. This reduces register file bandwidth requirements from O(x²) to O(x), matching compute scaling. Weights are loaded slowly via daisy-chain over many clock cycles, trading load latency for dramatically reduced wiring bandwidth.
  • Clock cycle optimization tradeoff: Inserting pipeline registers between logic stages doubles achievable clock frequency but consumes additional area. Pushing clock speed too high means most die area goes to synchronization registers rather than compute logic, reducing throughput despite higher frequency. Optimal chip design balances gates-per-cycle against cycles-per-second, analogous to batch size tradeoffs in inference serving.
  • FPGA versus ASIC economics: FPGAs implement any logic circuit via programmable lookup tables (truth tables with 16 entries for 4-bit inputs) and configurable MUX routing, but each lookup table consumes ~32 gates to implement what an ASIC does in 3 gates. This ~10× area penalty is the direct cost of reprogrammability. First ASIC tape-out costs ~$30M versus ~$10K for FPGA deployment.
  • Cache versus scratchpad memory architecture: CPUs use hardware-managed caches that automatically decide whether data comes from fast on-chip memory or slow DDR, introducing nondeterministic latency. TPUs instead use software-managed scratchpads with explicit separate instructions for on-chip versus HBM access. This design choice gives TPUs deterministic latency at the cost of requiring programmers to manage memory hierarchy manually.

Notable Moment

Pope reveals that GPU and TPU architectures are essentially the same systolic array concept at different scales — a GPU streaming multiprocessor is roughly a miniaturized TPU. The tradeoff is that GPUs gain higher vector-to-matrix bandwidth through parallelism, while TPUs achieve better register file amortization through larger unified matrix units.

Know someone who'd find this useful?

Episode Transcript

I'm back with Reiner Pope, who is the CEO of Maddox, which is a new AI chip company. Last time we were talking about what happens inside a data center. Now I understand what happens inside an AI chip. How does a chip actually work? Full disclosure, by the way, I am an angel investor in Maddox. So hopefully you have designed a good chip. Okay. Also, if you're listening to this on an audio platform, it's much preferable to watch this Blackboard lecture on a platform where you can see what's happening. So switch over to YouTube, or Spotify. So I'll start with, sort of the very smallest fundamental unit of of of chip design, then we'll sort of build up into what an overall, like, actual production chip, what are their components of that. Yep. At the very bottom level of a chip, the primitives that we work with are, logic gates, which are very simple things like and or not. And then these are connected together by by wires that have to be laid out, physically as metal traces on a chip. The main function that that AI chips want to, compute is, multiplication of matrices. And really inside that is the fundamental primitive is multiply accumulative, just like of of pairs of numbers. So we're gonna sort of demonstrate what our calculation looks like by hand, and then sort of infer what what a, circuit would look like for that. It'll turn out to be sort of easiest if if I do multiplication, accumulator. Something like a, a four bit number, with another four bit number. And then we're going to the the actual clearest primitive is actually, multiply accumulates. So there's a multiply these two terms, and then we're going to add in so product of these two terms, and then we're going to add in an eight bit, number. And and can I ask a clarifying question? Why is this the natural primitive for, you know, whatever computation happens inside a computer? Yeah. So, there there's a few reasons for this. It it's a little bit more efficient, but the the reason it's natural for AI chips is that if you look what's happening during a matrix multiply, the, what is matrix multiply? In very short, it is, there's a full loop over I and over j Yep. And over k of output I k plus equals to, input I j times other input j k. And so multiply accumulate happens at every single step of of a matrix multiply. Makes sense. And then the other observation is that, the precision will almost always be higher in the accumulation step than in the multiplication step. This is maybe specific to AI chips, but you're you're multiplying low precision numbers. But then when you accumulate, errors accumulate quickly and so you need more precision here. So this is why we've chosen to do a four bit multiplication and an eight bit addition. Let me make …

Get the full transcript (14,263 words) + summary by email — free

One-time email with the complete transcript and AI summary of this episode. No account needed.

One email, no spam. We’ll also show you what SignalCast does.

Browse all Dwarkesh Podcast transcripts →

You just read a 3-minute summary of a 77-minute episode.

Get Dwarkesh Podcast summarized like this every Monday — plus up to 2 more podcasts, free.

Pick Your Podcasts — Free

Keep Reading

Books, tools, and gear mentioned in this episode

SignalCast may earn commission on purchases via these links. As an Amazon Associate, SignalCast earns from qualifying purchases.

Gear

  • by NVIDIA

    This is why NVIDIA's B300 reports FP4 as 3× faster than FP8, though the true theoretical advantage is 4×.

company

  • MaddoxBy guest
    Reiner Pope, CEO of Maddox AI chip company, explains chip architecture from logic gates through multiply-accumulate units, systolic arrays, register files, clock cycles, FPGAs, and GPU versus TPU design tradeoffs.
  • This is why NVIDIA's B300 reports FP4 as 3× faster than FP8, though the true theoretical advantage is 4×.

More from Dwarkesh Podcast

We summarize every new episode. Want them in your inbox?

Similar Episodes

Related episodes from other podcasts

Explore Related Topics

Read this week's Investing & Markets Podcast Insights — cross-podcast analysis updated weekly.

You're clearly into Dwarkesh Podcast.

Every Monday, we deliver AI summaries of the latest episodes from Dwarkesh Podcast and 192+ other podcasts. Free for one show.

Start My Monday Digest

No credit card · Unsubscribe anytime