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
      • Why a Register Model: Desired, Mirrored and the DUT
      • Blocks, Registers, Fields and Memories
      • Maps, Offsets and Endianness
      • Nested Blocks and Submaps
      • Build, Lock and Generated Models
      • The Frontdoor Path, End to End
      • The Register Layer: Full Source
    • Register Access
    • 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. RAL Overview

Part 9 · Register Model (RAL) · Intermediate

RAL Overview

What a register model is for and how it is built: the three values, blocks, registers, fields and maps, composition into a subsystem, build and lock, and the frontdoor path end to end, all on the DMA's model.

  • 7topics
  • 7lessons

Topics in this section

  1. 1Why a Register Model: Desired, Mirrored and the DUT1 lesson
  2. 2Blocks, Registers, Fields and Memories1 lesson
  3. 3Maps, Offsets and Endianness1 lesson
  4. 4Nested Blocks and Submaps1 lesson
  5. 5Build, Lock and Generated Models1 lesson
  6. 6The Frontdoor Path, End to End1 lesson
  7. 7The Register Layer: Full Source1 lesson
On this page

    This topic builds the register model of the course's DMA, dma_reg_block in dma_ral_tb.sv, and follows one access through it. By the end you can read any UVM register model, generated or hand-written, and say where each value it holds came from.

    What you will be able to do

    • Say what problem a register model solves, and keep desired, mirrored and DUT values apart.

    • Read and write field configure() calls, and pick the access policy, volatility and reset for each DMA bit.

    • Turn a register name into a bus address and back, and say what map endianness does and does not do.

    • Compose two DMA models into one subsystem model with add_submap, and catch an overlapping base.

    • Put build(), configure() and lock_model() in the right order, and keep a generated model as the one source of truth.

    • Trace one frontdoor access from the test to the mirror, and explain why the mirror can lag the bus.

    The picture: what is wired to what

    Flowchart: the register model owns a map; the map is bound to the APB sequencer and uses the adapter; the sequencer feeds the driver, which drives the DUT; the monitor watches the DUT and feeds the predictor, which updates the register model.
    The register layer inside dma_ral_env. The map sends accesses through the adapter to the APB sequencer; the monitor's analysis port feeds the predictor, which updates the model.

    The lessons

    #

    Lesson

    What it covers

    1

    Why a Register Model

    Name-based access instead of hand-built bus writes; desired, mirrored and DUT values; the LEN write the model believed and the DMA ignored. Start here.

    2

    Blocks, Registers, Fields and Memories

    The DMA model as a tree; every configure() argument; access policies, volatility and memories.

    3

    Maps, Offsets and Endianness

    create_map and add_reg, address math, the reverse lookup the predictor uses, and what endianness really orders.

    4

    Nested Blocks and Submaps

    Two DMA models under one subsystem block, HDL paths across levels, and a base-address slip that only warns.

    5

    Build, Lock and Generated Models

    The build order, what lock_model() freezes, and models generated from SystemRDL or IP-XACT with one source of truth.

    6

    The Frontdoor Path, End to End

    One STATUS read from the test to the mirror, on the real log, including the moment the mirror lags the bus.

    The first lesson is about why; lessons 2 to 5 build the model; lesson 6 runs it. The access API, the adapter contract and the prediction modes each have their own lessons in Register Access.

    Interview

    The question that spans this whole topic: walk me through what happens when a test calls `write()` on a register. A strong answer names the map, the adapter, the sequencer and driver, the monitor and the predictor in order, and says when the mirror changes.

    Related topics

    • Up: Register Model (RAL)

    • Next topic: Register Access

    PreviousNext: Why a Register Model: Desired, Mirrored and the DUT

    Up next

    Up nextWhy a Register Model: Desired, Mirrored and the DUT

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Register Access
    • Registers in Verification