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
  • How to Read the Diagrams
  • Part 0: What Is a Protocol?10
  • Part 1: Timing and Clocking11
  • Part 2: Encoding and Framing12
  • Part 3: Handshakes13
  • Part 4: Flow Control17
  • Part 5: Transactions19
  • Part 6: Concurrency and Performance17
  • Part 7: Ordering13
  • Part 8: Sharing and Arbitration12
  • Part 9: Deadlock and Liveness13
  • Part 10: Reliability and Recovery20
  • Part 11: Bring-Up and Link Management10
  • Part 12: Power8
  • Part 13: Shared State and Coherence9
  • Part 14: Security and Isolation7
  • Part 15: Specifying and Verifying11
    • Writing an Interface Contract
    • Safety and Liveness
    • Protocol Assertions
    • Monitors and Transaction Reconstruction
    • Ordering-Aware Scoreboards
    • Protocol Coverage
    • Formal Methods for Protocols
    • Compliance and VIP
    • Observability and Tracing
    • A Waveform Debug Method
    • Drills: Specifying and Verifying
  • Part 16: Protocols Dissected17
  • Part 17: Capstones5
  • Part 18: Interview Preparation6
Loading lesson

‹Part 15: Specifying and Verifying
  1. Topics
  2. First Principles of Hardware Protocols
  3. Part 15: Specifying and Verifying
  4. Compliance and VIP

Part 15 · Specifying and Verifying · Senior (S)

Compliance and VIP

A design and its testbench written by the same team share the same misreadings of the specification. Verification IP, written independently against the standard, and compliance programmes break that loop. What VIP contains, and why teams buy it for standard protocols.

On this page

    Note

    Level: Senior (S) · Answers: How do we know it is correct?

    Before this: Protocol Coverage

    A team designs a PCI Express endpoint and its testbench. Every test passes. At the first interoperability event, the endpoint fails to work with three other vendors' root ports. The team had read one requirement in the specification differently from everyone else, and since the same engineers wrote the design and the tests, the tests checked the same misreading. The design was consistent with itself, not with the standard.

    How do you check an implementation against the specification, rather than against your own reading of it?

    The obvious answer, and why it breaks

    The obvious answer is a thorough in-house testbench. But a testbench checks what its authors believe the specification says. When the designer and the verification engineer sit together and resolve ambiguities together, their misunderstandings agree, and the tests pass. The check needs a second, independent reading of the specification, ideally one already tested against many other implementations.

    The idea: an independent model of the standard

    Verification IP (VIP) is a reusable, independently written implementation of a standard protocol for testbenches:

    The design is driven by an independent model of the partner, checked by an independent set of rules, and measured against an independent coverage model.

    VIP part

    Does

    Active agent

    Plays the partner: drives legal traffic, corner cases and injected errors, and responds as a compliant partner would

    Protocol checker

    Assertions for every rule of the standard (lesson 15.3)

    Monitor and scoreboard hooks

    Rebuilt transactions for the user's checks (lessons 15.4, 15.5)

    Coverage model

    The standard's situations, ready to measure (lesson 15.6)

    Compliance sequences

    Tests derived from the standard's requirements

    Why buy, why build

    Situation

    Choice

    Because

    Standard protocol (PCIe, USB, Ethernet, AXI)

    Buy VIP

    An independent reading, already exercised against many designs; the standard is too large to model from scratch

    Your own protocol (DCLink)

    Build it, with a separate author

    Nobody else has it; independence comes from a different engineer writing from the specification alone

    Interoperability sign-off

    Compliance testing and plugfests

    The final test is real partners, not models

    Compliance beyond simulation

    • Compliance programmes test silicon against the standard, often at events where many vendors' products are tested together.

    • Interoperability is the real goal: a VIP pass is evidence, a working link with other vendors' parts is proof.

    • Feedback: every interoperability failure becomes a new test, in the VIP or in your own suite.

    How real programmes work

    Standard

    Compliance

    PCI Express

    PCI-SIG compliance workshops; passing products are listed on the Integrators List (fact P37)

    USB

    USB-IF certification programme (fact P37)

    AMBA AXI

    No certification; Arm's protocol assertions and commercial VIP serve as the independent check (fact A29)

    What breaks

    The opening endpoint (illustrative) was re-verified with commercial VIP, whose checker flagged the misread requirement on the first test. Two other issues found by the VIP's compliance sequences were also present in silicon; all three were fixed in the next revision, which passed the following compliance workshop.

    Why this matters

    Senior lens. Independence is the point of VIP. For standard protocols, buy it and use its checker and coverage as the reference, not your team's reading. For your own protocols, create independence deliberately: the testbench, checker and reference model are written from the specification by someone other than the designer. Close the loop with compliance and interoperability testing on silicon.

    Interview

    Asked: "Why buy a VIP for a standard protocol?"

    Weak answer: It saves time writing a testbench.

    Strong answer: Mostly for independence. If the same team writes the design and the tests, the tests check the team's reading of the spec, and shared misreadings pass. A VIP is an independent implementation of the standard, already exercised against many designs: an active agent that behaves like a compliant partner and injects errors, a checker for every rule, a coverage model and compliance sequences. It also saves building a model of a huge standard. For your own protocol, you get independence by having someone other than the designer write the checker and model from the spec, and for standards the final word is compliance and interoperability testing.

    Follow-ups: (1) How do you get independence for an in-house protocol? (2) What does an interoperability event find that VIP doesn't?

    Check yourself Why can a design and its testbench pass every test and still violate the standard?

    If both were written from the same misreading of the specification, the tests check the misreading, not the standard.

    Check yourself What does a VIP's active agent provide beyond a checker?

    It plays a compliant partner and drives legal corner cases and injected errors the design must handle.

    Key takeaways

    • A design and testbench from the same team share the same misreadings of the specification.

    • VIP is an independent model of the standard: agent, checker, coverage and compliance sequences.

    • Buy it for standards, build it independently for your own protocols, and finish with compliance on silicon.

    Keep going

    Next: Lesson 15.9, Observability and Tracing. Designing an interconnect so it can be debugged in silicon.

    Related topics

    • Part 15 overview: Specifying and Verifying

    • UVM course

    Previous

    203 / 234

    Next: Observability and Tracing

    Up next

    Up nextObservability and Tracing

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Writing an Interface Contract
    • Safety and Liveness
    • Protocol Assertions