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
  • Part 11: Post-Silicon Validation8
  • Part 12: Bug Economics8
  • Part 13: Debug7
  • Part 14: Sign-Off7
  • Part 15: Verification in Context8
    • Functional Safety Verification
    • Security Verification
    • Low-Power Verification Strategy
    • CDC and RDC in the Plan
    • Verifying Processors
    • Verifying AI Accelerators
    • Verifying Configurable IP
    • Drills: Verification in Context
  • Part 16: Case Studies5
  • Part 17: Capstones5
  • Part 18: Interview Preparation6
Loading lesson

‹Part 15: Verification in Context
  1. Topics
  2. First Principles of Verification Strategy
  3. Part 15: Verification in Context
  4. Verifying Configurable IP

Part 15 · Verification in Context · Principal (P)

Verifying Configurable IP

Configurable IP is shipped as parameters, and every customer builds a different design. Verifying every configuration is impossible; verifying only the default ships bugs. How to choose configurations: legal ranges, the extremes, customer configurations first, pairwise covering arrays, randomised builds in regression, and formal on small instances, with the arithmetic of why pairwise is enough to start.

On this page

    Note

    Level: Principal (P) · Answers: What changes for safety, security, processors and AI hardware?

    Before this: Configuration and Mode Bugs, Crosses and Explosion

    DCRouter has been verified as one design: four ports, fixed FIFOs, CRC on, low power available. Now it is to be sold as IP. Customers will choose 2 to 8 ports, FIFO depths from 2 to 64, flit widths from 8 to 64 bits, and whether to include CRC and low power. Every lesson so far verified one point in that space. Each customer will tape out a different point, and many will be points nobody has simulated.

    How do you verify a design that is really thousands of designs?

    The obvious answer, and why it breaks

    One obvious answer is to verify the default configuration thoroughly; another is to verify every configuration. The first ships bugs that only appear at the extremes or in combinations (lesson 1.6): a FIFO of depth 2 whose almost-full logic underflows, an arbiter that only fails with an odd number of ports. The second is impossible: even with each parameter reduced to a few representative values, the product grows too fast to build and regress.

    The arithmetic

    configurations=i=1∏k​vi​pairs to cover=i<j∑​vi​vj​configurations covering all pairs≥i<jmax​vi​vj​

    With five parameters at four representative values each, every combination is 4^5 = 1,024 builds, each with its own regression. Every pair of values can be covered in far fewer: at least 16, because one pair of parameters alone has 16 value pairs. For four parameters with four values, 16 configurations cover all 96 pairs against 256 for every combination; for five parameters with three values, 11 suffice against 243 (fact M5). The number needed grows only slowly as parameters are added, which is what makes pairwise selection practical.

    Pairs are not everything: NIST's studies found most real failures triggered by one or two interacting parameters, but some by up to six (fact M5). Pairwise is the starting point, raised to three-way coverage for the parameters that interact most.

    The idea: choose configurations deliberately

    Selection

    Why

    Legal ranges defined and checked at elaboration

    Illegal configurations rejected by the IP itself, so they are never shipped or verified

    Extremes: minimum and maximum of every parameter

    Off-by-one and boundary bugs live at the edges (depth 2, 8 ports, width 8)

    Customer configurations first

    The configurations that will become silicon get full regression

    Pairwise (or three-way) covering array

    Every interaction of two settings exercised with few builds

    Random configurations in every nightly regression

    Over months, many more points visited

    Formal on small instances

    Proofs at small parameter values, where state spaces are tractable; structure that does not depend on size gives confidence beyond them

    What changes in the testbench and the plan

    • The testbench is parameterised too: stimulus, reference model, checkers and coverage all read the configuration; a testbench hard-coded for four ports silently tests only four.

    • Coverage is per configuration and across configurations: which configurations were run, and which features were covered in each.

    • Features depend on configuration: CRC checks only when CRC is present; the plan states which evidence applies to which configurations.

    • Every customer configuration is signed off: by full regression on it, or by an argument from neighbouring configurations stated as residual risk (lesson 14.4).

    How real teams verify configurable IP

    Practice

    Purpose

    Configuration generator producing covering arrays plus extremes

    A deliberate, recorded set of builds

    Customer configurations added to regression on delivery

    Silicon-bound points get full evidence

    Random configurations nightly, failures reproduced by configuration and seed

    Broad exploration over time

    Parameter checks in the RTL

    Illegal configurations cannot be built

    What breaks

    An IP team (illustrative) regressed its default configuration and the two largest customer configurations. A new customer chose a FIFO depth of 3, legal but not a power of two, which nobody had built. The pointer wrap logic assumed a power of two and overwrote an entry once every few thousand packets. A pairwise set including the odd depths, or a parameter check rejecting them, would have caught it before delivery.

    Why this matters

    Principal lens. Treat configurable IP as a space, not a design: define legal ranges in the RTL, regress the extremes and every customer configuration, cover all pairs (and triples where parameters interact) with a covering array, explore randomly every night, and prove properties on small instances. Make the testbench as configurable as the design, and state at sign-off which configurations the evidence covers.

    Interview

    Asked: "How do you verify parameterised IP?"

    Weak answer: Test the default configuration and a few others.

    Strong answer: Treat it as a space. Define legal ranges and reject illegal ones in the RTL. Regress the extremes of every parameter, since boundary bugs live there, and every customer configuration in full. Cover every pair of parameter values with a covering array, which takes far fewer builds than every combination: 16 versus 256 for four parameters with four values, and raise to three-way where parameters interact, since NIST found failures triggered by up to six. Run random configurations nightly, prove properties formally on small instances, and parameterise the testbench too. At sign-off state which configurations the evidence covers.

    Follow-ups: (1) Why isn't the default configuration enough? (2) How would you choose representative values for FIFO depth?

    Check yourself Why must the testbench be parameterised as well as the design?

    A testbench hard-coded for one configuration silently exercises and checks only that configuration, whatever the design's parameters say.

    Check yourself What is the minimum number of configurations that can cover all pairs of five parameters with four values each?

    At least 16, because one pair of parameters alone has 4 × 4 = 16 value pairs, each needing a configuration.

    Key takeaways

    • Configurable IP is a space of designs; neither the default nor every configuration works.

    • Regress extremes and customer configurations; cover pairs with covering arrays; explore randomly.

    • Parameterise the testbench too, and state which configurations the evidence covers.

    Keep going

    Next: Drills: Verification in Context. Interview questions, a whiteboard exercise and a ten-question checkpoint for Part 15.

    Related topics

    • Part 15 overview: Verification in Context

    Previous

    143 / 160

    Next: Drills: Verification in Context

    Up next

    Up nextDrills: Verification in Context

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Functional Safety Verification
    • Security Verification
    • Low-Power Verification Strategy