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

  • Start Here4
  • UVM Foundations14
  • UVM Phases & Simulation Lifecycle26
  • Factory & Configuration15
  • Transaction-Level Modeling (TLM)13
  • UVM Sequences & Stimulus21
  • UVM Agents & Protocol VIP21
    • Agent Architecture
    • Reusable VIP: Active, Passive and Protocol Agents
    • Error and Fault Injection
    • Agent Patterns: Slaves, Reset, Interrupts and Pipelines
      • Reactive Slave Agents
      • Reset on the Fly
      • Interrupt Agents
      • Pipelined and Out-of-Order Drivers
  • Environment & Test Classes11
  • Checking & Coverage in UVM21
  • UVM Register Abstraction Layer (RAL)22
  • Advanced UVM in Practice13
  • Debug & Regression10
  • Coding Practice47
  • Verification in Industry Practice10
  • Senior Prep: Architecture, Leadership and Interviews32
Loading lesson

‹UVM Agents & Protocol VIP
  1. Topics
  2. UVM Verification
  3. UVM Agents & Protocol VIP
  4. Agent Patterns: Slaves, Reset, Interrupts and Pipelines

Part 6 · Agents & Protocol IP · Intermediate

Agent Patterns: Slaves, Reset, Interrupts and Pipelines

Four agent shapes that senior interviews probe: reactive slaves, reset on the fly, interrupt agents and pipelined drivers.

  • 4topics
  • 4lessons
On this page

    The agents you have built so far all have the same shape: a sequence decides, a driver obeys, a monitor reports. Real interfaces break that shape in four ways. Some interfaces are answered rather than commanded. Resets arrive while a transfer is half done. Interrupts are not a bus at all. And fast buses keep many transactions in flight at once. Each of those breaks a beginner's driver loop, and each is a favourite senior interview question.

    Every pattern in this topic is built on the DMA bench, and all four were run: three on the bench itself and the pipelined driver on a small AXI-style read model.

    What you will be able to do

    • Build a reactive slave agent that answers the DUT with random backpressure, and swap it in with an instance override that touches one agent only.

    • Make drivers, monitors and the scoreboard survive a reset in the middle of a job, and explain why the scoreboard flushes when reset ends, not when it starts.

    • Turn an interrupt wire into a passive agent that publishes transactions and triggers events, so tests and sequences never need its virtual interface.

    • Write a pipelined, out-of-order driver with separate request and response threads, an outstanding table per ID, and correct response routing.

    Where each pattern sits in the bench

    Block diagram: the DMA env with a reset-aware APB driver and stream driver, a reactive sink agent on the output, a passive interrupt agent feeding a global event that the test waits on, and a reset-aware scoreboard.
    The block bench with every phase 4 variant shown at once. Each test swaps in only the variants it needs, through factory overrides; the env source never changes.

    The lessons, in order

    Lesson

    What it covers

    Reactive Slave Agents

    axis_sink_agent and axis_ready_seq: the driver waits for TVALID and asks a forever sequence how long to stall; dma_backpressure_test.

    Reset on the Fly

    Reset-aware drivers with an isolated fork, item_done for a held item, killing stimulus, and a scoreboard that flushes when reset ends; dma_reset_test.

    Interrupt Agents

    A passive irq agent with analysis items and a global uvm_event; level versus edge, W1C clearing, storms and cause coverage; dma_irq_agent_test.

    Pipelined and Out-of-Order Drivers

    Address and data threads, get versus get_next_item, put_response with set_id_info, and an outstanding table keyed by ID.

    Tip

    The sequence side of two of these patterns is taught in the Sequences section: Reactive sequences and Responses and pipelined drivers. These lessons build the component side and link back rather than repeat.

    Related topics

    • Up: Agents & Protocol VIP

    • Previous topic: Error and Fault Injection

    • Next: Environment & Test

    PreviousNext: Reactive Slave Agents

    Up next

    Up nextReactive Slave Agents

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Agent Architecture
    • Reusable VIP: Active, Passive and Protocol Agents
    • Error and Fault Injection