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
    • Levels and What They See
    • What to Verify Where
    • Reuse up the Hierarchy
    • Standard Interfaces and VIP
    • SoC and Software-Driven Tests
    • Hardware-Software Co-Verification
    • Performance and Power Verification
    • Drills: Verification Levels and Reuse
  • 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
  • Part 16: Case Studies5
  • Part 17: Capstones5
  • Part 18: Interview Preparation6
Loading lesson

‹Part 8: Verification Levels and Reuse
  1. Topics
  2. First Principles of Verification Strategy
  3. Part 8: Verification Levels and Reuse
  4. Standard Interfaces and VIP

Part 8 · Verification Levels and Reuse · Senior (S)

Standard Interfaces and VIP

Verification IP (VIP) is an independent, reusable model of a standard interface: drivers, monitors, protocol checkers and coverage written from the standard, not from your design. Why independence matters (your design's engineers and your testbench's engineers share the same misreadings), what VIP provides and does not, and when to buy, build or reuse it.

On this page

    Note

    Level: Senior (S) · Answers: At which level should each thing be verified?

    Before this: Reuse up the Hierarchy, Specification Bugs

    DCRouter's APB register interface was verified with an APB task written by the same course that wrote DCRouter. Both read the APB rules the same way. If the writer had misread one rule, say whether pslverr may be sampled outside the access phase, the RTL and the testbench would share the misreading, and every test would pass. A model of the standard written by someone else, against the standard itself, does not share your mistakes.

    What is verification IP for, and when is it worth having?

    The obvious answer, and why it breaks

    The obvious approach is to write your own interface model: you know the protocol, and it is only a few hundred lines. For a simple internal interface, that is fine. For a standard interface (a bus protocol, PCIe, USB, a memory interface), your model encodes your reading of a long specification, the same reading your designers had, and your design must interoperate with other people's implementations that read it differently. Independence is the point.

    The idea: an independent model of the standard

    The design and the VIP are separate readings of the same standard; connecting them turns any disagreement into a test failure.

    VIP provides

    VIP does not provide

    Drivers that can produce every legal (and chosen illegal) behaviour of the protocol

    A check of your design's function behind the interface

    Protocol checkers: every rule of the standard as assertions

    Your scoreboard and reference model

    Coverage of the protocol's features

    Coverage of your design's features

    Monitors producing transactions for your scoreboard

    Knowledge of your system's configuration and use

    Compliance test suites, for some standards

    Proof of interoperability with every real partner

    Buy, build or reuse

    Situation

    Choice

    Why

    Complex industry standard (PCIe, USB, Ethernet, DDR)

    Buy (or use a mature internal VIP)

    Thousands of pages of rules; compliance matters; independence is essential

    Simple standard bus (APB, simple AXI uses)

    Reuse a proven internal VIP, or buy

    Small, but shared misreadings are still costly

    Internal, project-specific interface (DCRouter's packets)

    Build

    No standard exists; write it from the interface specification (lesson 2.2), ideally by someone other than the designer

    Using VIP well

    • Configure it to your use: optional features on or off as your design implements them.

    • Turn on every protocol check: VIP checkers often catch more than VIP drivers.

    • Merge its coverage with yours: protocol coverage plus design coverage.

    • Keep the design's own checks: VIP checks the interface; your scoreboard checks the function.

    How real teams use VIP

    Practice

    Purpose

    Commercial or internal VIP for every standard interface

    Independent protocol models across projects

    VIP checkers active at block, subsystem and chip level

    Protocol violations caught wherever they occur

    Compliance suites before tape-out for interoperability standards

    Evidence beyond your own tests

    What breaks

    A team (illustrative) built its own model of a high-speed serial standard and passed thousands of tests. The model and the design shared an interpretation of an optional ordering rule, which a partner's chip read differently. Interoperability failed at the first plug-in test. A third-party VIP, or a compliance suite, had the other reading built in.

    Why this matters

    Senior lens. For any standard interface, ask who wrote the model your design is tested against. If it is the same team, or the same reading, the interface is only verified against itself. Buy or reuse independent VIP for standards, build your own only for internal interfaces, and keep your scoreboard for the function behind the interface.

    Interview

    Asked: "Why buy VIP?"

    Weak answer: To save time writing a testbench.

    Strong answer: For independence as much as time. A standard interface model written by your team encodes the same reading of the specification your designers had, so shared misreadings pass every test, and your chip must interoperate with partners who read it differently. VIP is an independent model of the standard, with drivers for every legal behaviour, protocol checkers for every rule, protocol coverage and often compliance tests. It doesn't check your design's function behind the interface; your scoreboard still does that.

    Follow-ups: (1) When would you build your own instead? (2) What does VIP coverage add?

    Check yourself Why would DCRouter's packet interface get a home-built model rather than bought VIP?

    It is an internal interface with no standard; the model is written from DCRouter's own interface specification, ideally by someone other than its designer.

    Check yourself A VIP's protocol checkers pass. Is the design behind the interface verified?

    No: VIP checks the interface rules; whether the right data comes out depends on the design's own scoreboard and reference model.

    Key takeaways

    • VIP is an independent model of a standard interface: drivers, checkers, coverage, monitors.

    • Independence matters: your own model shares your designers' reading of the standard.

    • Buy or reuse VIP for standards, build for internal interfaces, and keep your own functional checks.

    Keep going

    Next: Lesson 8.5, SoC and Software-Driven Tests. Tests written as software running on the chip's processor.

    Related topics

    • Part 8 overview: Verification Levels and Reuse

    • VIP and compliance course: VIP Integration

    Previous

    85 / 160

    Next: SoC and Software-Driven Tests

    Up next

    Up nextSoC and Software-Driven Tests

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Levels and What They See
    • What to Verify Where
    • Hardware-Software Co-Verification