Skip to content
DenseChip
Learn
PracticeCode labInterview

DenseChip

Navigate

Menu

LearnPracticeCode labInterview

Tools

All toolsSV editorCode repoResume
DenseChip

Practice, courses, and chip-design tools in one focused workspace.

LearnPracticeCode labInterviewToolsLearning paths

© 2026 DenseChip

AboutContactPrivacyTerms
Skip to lesson

Course contents

  • How to Use This Course
  • Reading Paths
  • Concept Map
  • Meet DCRouter
  • Glossary
  • Part 0: What Verification Is8
  • Part 1: What Can Go Wrong11
  • Part 2: Specifications as Checkable Rules8
  • Part 3: Observability and Controllability7
  • Part 4: Stimulus11
  • Part 5: Checking11
  • Part 6: Coverage10
  • Part 7: Formal and Simulation10
  • Part 8: Verification Levels and Reuse8
  • Part 9: Planning and Risk9
  • Part 10: Emulation and Prototyping8
    • Why Cycles Matter
    • Simulation Speed and Its Limits
    • Emulation
    • FPGA Prototyping
    • Virtual Platforms and Hybrids
    • Debug at Scale
    • Choosing the Platform
    • Drills: Emulation and Prototyping
  • Part 11: Post-Silicon Validation8
  • Part 12: Bug Economics8
  • Part 13: Debug7
  • Part 14: Sign-Off7
  • Part 15: Verification in Context8
  • Part 16: Case Studies5
  • Part 17: Capstones5
  • Part 18: Interview Preparation6
Loading lesson

‹Part 10: Emulation and Prototyping
  1. Topics
  2. First Principles of Verification Strategy
  3. Part 10: Emulation and Prototyping
  4. Choosing the Platform

Part 10 · Emulation and Prototyping · Principal (P)

Choosing the Platform

Formal, simulation, virtual platforms, hybrids, emulation, FPGA prototypes and silicon each answer some questions well and others badly. Choosing means matching each question's needs (cycles, accuracy, visibility, turnaround, availability) to the platform that meets them most cheaply, and planning when each platform becomes available. A decision table, and the platform plan for DCRouter's SoC.

On this page

    Note

    Level: Principal (P) · Answers: How do we run enough cycles?

    Before this: Debug at Scale

    Three teams queue for the same emulator. The DCRouter team wants to rerun block-level random tests faster. The software team wants to boot the OS nightly. The performance team wants a benchmark run. Only one of these needs the emulator: block tests run better in block simulation, and the benchmark might be better on an FPGA prototype. Platform choice is a planning decision, made question by question.

    Which platform should answer which question?

    The obvious answer, and why it breaks

    The obvious rule is "the fastest platform available". Fast platforms are slower to set up, less visible and less flexible, and they arrive later in the project. Running a question on a platform faster than it needs wastes scarce hardware; running it on one too slow means it never finishes. The right platform is the cheapest one that answers the question in time.

    The idea: match the question's needs

    Need

    Formal

    Simulation

    Virtual platform

    Emulation

    FPGA prototype

    Silicon

    Cycles per run

    Short (bounded)

    Thousands to millions

    Billions

    Billions

    Trillions

    Unlimited

    Accuracy

    Exact, for properties

    Exact RTL

    Functional

    Exact RTL

    RTL, prototype clocks

    Real

    Visibility

    Full counterexample

    Full

    Software-level

    High, with planning

    Low

    Very low

    Turnaround after a change

    Minutes

    Minutes

    Minutes

    Hours

    Hours to a day

    Months

    Available from

    RTL

    RTL

    Specification

    RTL compiles

    Stable RTL

    Tape-out

    Questions and their platforms

    Question

    Best platform

    Why

    Does DCRouter's arbiter grant the right winner, always?

    Formal

    Exhaustive, short reach (lesson 7.9)

    Do DCRouter's 13 rules hold under random traffic?

    Block simulation

    Full control and visibility, fast turnaround

    Does the driver program DCRouter correctly?

    Virtual platform, then hybrid

    Early; then real RTL for timing

    Does the OS boot with DCRouter carrying network traffic?

    Emulation

    Billions of cycles with debug visibility

    Does the network stack run stably for hours?

    FPGA prototype

    Trillions of cycles, real cables

    What bandwidth does a real workload get?

    Emulation or prototype, against a performance model

    Billions of cycles of real software

    Does it work at temperature and voltage limits?

    Silicon

    Physical effects (Part 11)

    Planning platforms over the project

    • Specification stage: virtual platform for software; formal and simulation as RTL appears.

    • RTL development: block simulation and formal dominate; hybrids for early software on new blocks.

    • Integration: chip simulation for short flows, emulation for boot and long runs.

    • Late RTL: FPGA prototypes for software teams and long stability runs.

    • After tape-out: the same tests prepared for silicon validation (Part 11).

    How real teams choose

    Practice

    Purpose

    A platform column in the verification plan

    Each question assigned to the cheapest adequate platform

    Emulator and prototype capacity planned like any resource

    Queues sized to the questions that need them

    Tests portable across platforms

    The same scenario moves from simulation to emulation to silicon (fact V11)

    What breaks

    A team (illustrative) used its emulator mostly to run block-level regressions faster, because it was available and fast. When the OS boot was ready to run, the emulator queue was full of block tests that a simulation farm could have handled, and boot testing slipped by three weeks. Assigning platforms by question, not by availability, would have kept the emulator for the questions only it could answer.

    Why this matters

    Principal lens. Plan platforms by question: cycles, accuracy, visibility, turnaround and availability decide. Keep scarce fast platforms for software-scale questions, keep block questions in simulation and formal, and make tests portable so a scenario can move to the next platform as it becomes available.

    Interview

    Asked: "Which platform for which goal?"

    Weak answer: Use the fastest one available.

    Strong answer: The cheapest platform that answers the question in time. Formal for exhaustive control-logic questions; block simulation for rules under random traffic, with full visibility and fast turnaround; virtual platforms for early software and register contracts; emulation for OS boot, driver bring-up and long runs with debug; FPGA prototypes for long stable software runs and real peripherals; silicon for physical effects. Each arrives at a different time, so the plan assigns questions to platforms and schedules capacity, and tests are written to move between them.

    Follow-ups: (1) Why not run block tests on the emulator? (2) What does each platform cost in turnaround?

    Check yourself Why is block simulation better than emulation for DCRouter's rule checks?

    Block tests need only thousands to millions of cycles, full visibility and minutes of turnaround; emulation adds hours of rebuild for speed they do not need.

    Check yourself Which platform is available earliest, and what is it good for?

    The virtual platform, available from the specification: early software development and register-contract checks.

    Key takeaways

    • Choose the cheapest platform that answers each question in time.

    • Cycles, accuracy, visibility, turnaround and availability decide.

    • Plan platform capacity by question and keep tests portable across platforms.

    Keep going

    Next: Drills: Emulation and Prototyping. Interview questions, a whiteboard exercise and a ten-question checkpoint for Part 10.

    Related topics

    • Part 10 overview: Emulation and Prototyping

    Previous

    105 / 160

    Next: Drills: Emulation and Prototyping

    Up next

    Up nextDrills: Emulation and Prototyping

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Why Cycles Matter
    • Simulation Speed and Its Limits
    • Emulation