A DMA channel copies a block of data from memory into a peripheral's FIFO. The DMA block's own scoreboard checks that every byte it read from memory was written out correctly on its own bus. The peripheral's own scoreboard checks that every byte arriving at its FIFO gets consumed correctly. Both can report a clean pass - and the data can still have been silently corrupted, dropped, or duplicated in between, because neither scoreboard was ever looking at the same question: did the exact bytes that left memory actually arrive at the peripheral, in the right order, with nothing lost along the way?

11 min read | Intermediate Level

What You'll Learn

  • Why two block-level scoreboards can both pass while the data path between them is broken
  • How to tag data so it can be tracked across multiple interfaces without duplicating each block's own checking
  • What changes when the data itself is transformed - not just moved - as it crosses a block boundary
  • How to handle data that passes through memory instead of a live transaction stream
  • How a block's original scoreboard keeps running unchanged once it's plugged into the SoC environment, and what an analysis port fanning out to two subscribers actually looks like

What a Block-Level Scoreboard Actually Proves

A block-level scoreboard answers a local question: given what came in on this block's input, was what came out on its output correct? The DMA block's scoreboard proves the DMA engine read the right bytes from the right memory addresses and issued the right bus transactions. The peripheral's scoreboard proves the peripheral correctly processed whatever transactions it received.

Neither one has any way to know whether the peripheral actually received what the DMA engine sent, because neither one has visibility into the other's interface - reusing both scoreboards, exactly as they were at block level, checks two real things correctly and still leaves the connection between them completely unverified.

Tagging Data So It Can Be Tracked

An end-to-end scoreboard needs to correlate a transaction seen at the source with the corresponding transaction seen at the destination, potentially several blocks and several clock domains later. A raw data value usually isn't a safe key to match on by itself - the same byte pattern can legitimately show up more than once in the same test, and a mismatch on a repeated value could match the wrong pair and hide a real bug.

What works instead is whatever unique identifier is already flowing with the data: a DMA descriptor's transfer ID, an AXI transaction's ID field, or a source address that's guaranteed not to repeat within the window the checker cares about.

End-to-end scoreboarding: a transfer ID that already travels with the data tags each item at the source and at the destination, several blocks and clock domains later, while the block-level scoreboards stay in place for each hop

class dma_e2e_scoreboard extends uvm_scoreboard;
  `uvm_component_utils(dma_e2e_scoreboard)
  `uvm_analysis_imp_decl(_src)
  `uvm_analysis_imp_decl(_dst)

  uvm_analysis_imp_src #(mem_bus_item, dma_e2e_scoreboard) src_imp;
  uvm_analysis_imp_dst #(periph_bus_item, dma_e2e_scoreboard) dst_imp;

  mem_bus_item pending_q[bit[31:0]];   // keyed by descriptor tag

  function new(string name, uvm_component parent);
    super.new(name, parent);
  endfunction

  function void build_phase(uvm_phase phase);
    src_imp = new("src_imp", this);
    dst_imp = new("dst_imp", this);
  endfunction

  function void write_src(mem_bus_item item);
    pending_q[item.desc_tag] = item;
  endfunction

  function void write_dst(periph_bus_item item);
    if (!pending_q.exists(item.desc_tag)) begin
      `uvm_error("E2E", $sformatf("Data arrived for tag %0h with no matching source transfer", item.desc_tag))
      return;
    end
    if (pending_q[item.desc_tag].data !== item.data)
      `uvm_error("E2E", $sformatf("Data mismatch for tag %0h", item.desc_tag))
    pending_q.delete(item.desc_tag);
  endfunction

  function void check_phase(uvm_phase phase);
    foreach (pending_q[tag])
      `uvm_error("E2E", $sformatf("Source data for tag %0h never arrived at destination", tag));
  endfunction
endclass

Both src_imp and dst_imp subscribe to the same passive monitors the block-level scoreboards already use - the end-to-end checker doesn't re-verify either block's own protocol, it only correlates what each one already observed. check_phase() at the end of the test catches the case a per-transaction check can't: data that left the source and simply never showed up anywhere.

A source address can make a fine tag as long as it's genuinely unique for the duration the checker needs to track it. A ring buffer or a circular DMA descriptor queue reuses the same addresses across a test, so a tag built from address alone can pair a destination transaction with the wrong, stale source entry. Adding a transfer sequence number or a descriptor generation count to the key avoids that without needing a bus-level ID field that might not exist on every interface.

When the Data Changes Along the Way

Comparing raw bytes only works when the data genuinely doesn't change between source and destination. A lot of real data paths don't work that way - a DMA engine might byte-swap on certain transfer widths, a bridge might repack a 64-bit beat into two 32-bit beats, or a peripheral might apply a checksum or compress the payload before it's visible anywhere else.

Comparing the source and destination values directly in that case doesn't detect a bug, it just always fails, because the "expected" transform was never modeled.

The fix isn't to duplicate each block's own transform logic in the end-to-end scoreboard - that block already has its own scoreboard checking its own transform is correct. The end-to-end checker only needs to know what the overall, composed transform should look like from source to destination, and apply that once when it builds the expected value for the comparison.

If the DMA engine's own scoreboard already proved the byte-swap is done correctly at that hop, the end-to-end checker can safely assume the byte-swap happened and byte-swap its own expected value the same way before comparing - it's leaning on the block-level check rather than re-implementing it.

Data That Passes Through Memory

Not every end-to-end path is a live transaction stream the whole way. A DMA transfer that writes into memory, followed by the CPU reading that memory much later in the test, doesn't give a destination-side monitor anything to subscribe to at the moment the data "arrives" - the data just sits in memory until something reads it, and that read might happen in a different phase of the test entirely, or not happen at all if the test doesn't need it to.

For that kind of path, correlating on a live transaction at the destination isn't the right model. A backdoor read of the memory model at the point the checker actually needs the answer - typically right before or after whatever consumes that memory - is simpler and doesn't require guessing when a read transaction might occur.

Reusing the Block-Level Scoreboards, Not Replacing Them

None of this end-to-end layer replaces what each block's own scoreboard already does. The DMA block's scoreboard still needs to run and still needs to catch DMA-specific bugs - a malformed descriptor, an incorrect burst length, a wrong address calculation - that an end-to-end checker watching only the two endpoints would never see, because those bugs might still produce byte-for-byte correct data at the far end by coincidence, or might produce a failure the end-to-end checker can't localize to a specific block.

Running both together, each reused exactly as it was at block level, is what turns two separately-passing local checks and one thin correlation layer into actual end-to-end coverage of the data path.

When a block's environment gets plugged into the SoC environment, its scoreboard usually doesn't need to be rewritten at all - it needs to be fed. A UVM analysis port isn't limited to a single subscriber, so the same reused, passive monitor can connect to the block's original scoreboard and to the new end-to-end correlator at the same time, each getting its own copy of every transaction.

The block scoreboard keeps doing exactly what it did at block level, watching exactly the interface it always watched; the correlator is just one more thing listening in.

"Plugged in appropriately" matters most when the block's original scoreboard was built against a reference model or an internal signal that isn't visible from outside the block at SoC level. In that case the scoreboard itself still doesn't change - a thin adapter sits between it and the chip-level interface, translating whatever chip-level bus activity corresponds to that internal event into the same transaction shape the block scoreboard always expected. The scoreboard keeps comparing exactly the way it always did; only what feeds it changes.

Common Mistakes

Mistake: Re-implementing a block's own transform logic inside the end-to-end scoreboard instead of trusting that block's own check.

If the block already has a scoreboard proving its transform is correct, the end-to-end checker only needs to apply the same transform once to build its expected value - not re-derive or re-verify it. Duplicating that logic is extra maintenance for no additional coverage.

Mistake: Tagging transactions by raw data value or by address alone in a test that reuses addresses or data patterns.

A repeated value or a recycled address can pair a destination transaction with the wrong source entry, hiding a real mismatch behind an accidental match. A key needs to be unique for as long as the checker has to track it, not just unique on average.

Mistake: Treating a live transaction-stream scoreboard as the right model for data that sits in memory between being written and being read.

There may be no destination-side transaction to correlate against at all, or it may happen much later than expected. A backdoor check of the memory model at the point the data is actually needed avoids depending on a read that the test might not even issue.

Summary

In this article, you learned:

  • Two block-level scoreboards can both pass while the connection between them is completely unverified, because each one only checks its own local input-to-output correctness
  • An end-to-end scoreboard correlates source and destination transactions using a tag that's genuinely unique for the tracking window - not raw data value or a reused address - and reuses the same passive monitors the block-level scoreboards already subscribe to
  • When data is transformed between source and destination, the end-to-end checker applies the same transform once to build its expected value, leaning on the block-level scoreboard that already proved the transform correct, rather than re-implementing it
  • Data that passes through memory instead of a live transaction stream is better checked with a backdoor read at the point it's actually needed than by trying to catch a destination-side transaction that may never come
  • A block's original scoreboard rarely needs to be rewritten when it's plugged into the SoC - the same reused monitor's analysis port can fan out to both the block scoreboard and the end-to-end correlator, and when an internal reference isn't visible at chip level, a thin adapter feeds the unchanged scoreboard instead of the scoreboard itself being modified
Did you find what you were looking for?

Quiz

Test Your Knowledge

1 of 5 Score: 0 / 5
Cron Job Starts