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
  • Environment & Test Classes11
  • Checking & Coverage in UVM21
  • UVM Register Abstraction Layer (RAL)22
    • RAL Overview
    • Register Access
      • The Access API: write, read, set, get, update, mirror, predict, peek, poke
      • The Adapter Contract: reg2bus, bus2reg and provides_responses
      • Prediction: Auto, Explicit and Passive
      • Field Access Policies and Callbacks
      • Volatile Fields and Mirror Checks
      • Backdoor Access: HDL Paths and User Backdoors
      • User-Defined Frontdoors: Indirect and Paged Registers
    • Registers in Verification
  • Advanced UVM in Practice13
  • Debug & Regression10
  • Coding Practice47
  • Verification in Industry Practice10
  • Senior Prep: Architecture, Leadership and Interviews32
Loading lesson

‹UVM Register Abstraction Layer (RAL)
  1. Topics
  2. UVM Verification
  3. UVM Register Abstraction Layer (RAL)
  4. Register Access

Part 9 · Register Model (RAL) · Intermediate

Register Access

Using the register model on the DMA: the access API, the adapter contract, prediction modes, field policies and callbacks, volatile fields and mirror checks, backdoor access and user frontdoors.

  • 7topics
  • 7lessons
On this page

    The RAL Overview topic built the DMA's register model: five registers, one map, an adapter and a predictor. This topic is about using it, and about the dozen places where the model and the DUT quietly drift apart. Every lesson runs on the course bench's register layer, dma_ral_tb.sv, and every trap in it was hit for real while that bench was built: a trigger bit that update() refuses to write, a bit-bash that failed on 94 bits of a correct design, a backdoor peek that hid a real mismatch.

    What you will be able to do

    • Say which of the three values (desired, mirrored, DUT) each access call moves, and pick the right call for a test, a sequence or a check.

    • Write a bus adapter that honours the full uvm_reg_adapter contract: provides_responses, byte enables, extensions and status.

    • Choose auto, explicit or passive prediction, and predict exactly where each one goes stale.

    • Model field behaviour with the built-in access policies, a custom policy name and a post_predict callback.

    • Use volatile fields, UVM_CHECK and check_on_read so mirror checks catch real bugs and nothing else.

    • Add backdoor access through HDL paths or a user backdoor class, and frontdoor access to indirect and serial registers.

    Where each lesson sits on the access path

    Flowchart: a test call goes through the register map, optionally a user frontdoor, the adapter, the APB driver and DUT; the monitor feeds the predictor, field policies and callbacks update the mirror, which mirror checks compare. A backdoor path goes from the test straight to the mirror.
    One register access, from the call in the test to the mirror. Lesson 1 is the call itself; the others each own one stage.

    Lessons in order

    #

    Lesson

    The question it answers

    1

    The Access API

    Which value does each call move, and why does update() sometimes write nothing?

    2

    The Adapter Contract

    What must an adapter promise, and what happens to the mirror on a bus error?

    3

    Prediction: Auto, Explicit and Passive

    Who updates the mirror, when, and what does each mode miss?

    4

    Field Access Policies and Callbacks

    How does the model know what a write does, and how do you teach it a rule it lacks?

    5

    Volatile Fields and Mirror Checks

    Which bits can a mirror check trust, and when does a check silently pass?

    6

    Backdoor Access

    How do you reach a register without the bus, and what does a peek do to the mirror?

    7

    User-Defined Frontdoors

    How do you access a register that has no address of its own?

    Note

    The runs in this topic use Verilator and the open-source IEEE 1800.2-2020 UVM library. Where UVM 1.2 behaves differently (the mirror after a bus error, a few warnings), the lesson says so. Logs marked scratch run come from a scratch file that includes dma_ral_tb.sv unchanged and adds only the code shown in that lesson.

    Related topics

    • Up: Register Model (RAL)

    • RAL Overview

    • The DMA you will verify

    PreviousNext: The Access API: write, read, set, get, update, mirror, predict, peek, poke

    Up next

    Up nextThe Access API: write, read, set, get, update, mirror, predict, peek, poke

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • RAL Overview
    • Registers in Verification