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

  • RTL Foundations36
  • Combinational Design25
  • Sequential Design27
  • FSM & Control27
  • Timing & Clocking39
  • Reset & CDC34
  • Memory & Buses57
    • SRAM and ROM
    • Register Files
    • Valid/Ready Handshake
    • AXI-Lite
    • AXI-Stream
    • Bus Integration
    • Synchronous FIFO
    • Register-Map and CSR RTL
    • Memory Reliability
      • Failure Model and Protection Choice
      • Parity Datapath
      • SECDED Encode and Syndrome
      • Correction and Reporting
      • Partial Writes and Scrubbing
      • Initialization, Injection, and Signoff
      • SECDED on a 32-bit Word, Worked
    • Peripheral RTL Integration
    • Full AXI4: RTL Roadmap
  • Advanced RTL28
  • Senior & Interview76
  • Glossary and Notation
Loading lesson

‹Memory Reliability
  1. Topics
  2. RTL Design
  3. Memory & Buses
  4. Memory Reliability
  5. Correction and Reporting

Part 7 · Memory & Buses · Intermediate

Correction and Reporting

Return corrected data with explicit status, preserve diagnostic evidence, and contain uncorrectable words.

Why this matters

Correcting an error silently hides a failing memory until the second flip arrives. An uncorrectable error returned as ordinary data corrupts the system with no sign.

After this lesson you can: return corrected data, flag uncorrectable reads as poison or error, and capture the failing address and syndrome with the same response.

Read result

Data response

Status

Clean

Raw data

No error

Correctable

Corrected data

CE pulse + sticky/count/address

Uncorrectable

Poison, error response, or blocked result

UE pulse + sticky/fatal policy

The control SRAM returns corrected data at its normal response point and records the first failing address and syndrome. An uncorrectable read never masquerades as normal data; the surrounding transaction receives the block's documented poison or error response.

Correction and reporting occur together. Software may need the failing address and syndrome, but the capture register must define first-error versus last-error behavior and avoid being overwritten before service.

Carry the accepted request address/tag alongside the protected word through every memory/decode stage. Define a response-aligned event {valid, addr, syndrome, ce, ue} at decode completion, one event per decoded read, independently of downstream response stalls. A held response must not increment counters repeatedly. The diagnostic capture below consumes that event; it never samples the current request address.

An accepted read with its address and tag enters the memory read stage, which carries the address alongside. The ECC decoder sends corrected data to a response buffer that may stall, then to the requester, and sends one event with valid, address, syndrome, ce and ue to the diagnostic capture.
The request address travels with the data through each memory stage, and the decoder emits one event per read, before and independent of any response stall

Read the picture from the top: the address of read A never comes from the request port again. It rides beside the data until the decoder reports it.

  • One event per decoded read. A stalled response does not repeat the event, so counters count reads, not stall cycles.

  • The right address. By the time A is decoded, the port may hold request C; the event still says A.

Illustrative edge

Accepted request

Decode event

E0

A

none

E1

B

none

E2

C or idle

valid=1, addr=A, syndrome=5, ce=1

E3

D or idle

valid=1, addr=B, clean

design.sv
1
2
3
4
5
6
7
8
9
// snippet: response-aligned status capture; inside clocked logic
if (ecc_event.valid && ecc_event.ce)
  ce_count_q <= &ce_count_q ? ce_count_q : ce_count_q + 1'b1;
if (ecc_event.valid && (ecc_event.ce || ecc_event.ue) && !first_error_valid_q) begin
  first_error_valid_q <= 1'b1;
  first_error_addr_q  <= ecc_event.addr;
  first_syndrome_q    <= ecc_event.syndrome;
end
if (ecc_event.valid && ecc_event.ue) fatal_error_q <= 1'b1;

Warning

A UE must never be returned as ordinary valid data. Propagate poison/error or stop the transaction according to the architecture.

Check yourself Why record corrected errors if the consumer received good data?

A rising correction rate predicts a failing memory or radiation environment, and repeated errors at one address may reveal a permanent fault requiring repair.

Remember

  • Carry the request address and tag with the word, and raise one event per decoded read, even when the response is held.

  • An uncorrectable read must never look like normal data.

  • Define first-error or last-error capture, and keep it from being overwritten before software reads it.

Rule of thumb: report every correction: a rising rate is the early warning.

Keep going

  • Practice: ECC memory RTL design

  • Interview: run a mock interview on this topic

Related topics

  • Partial writes and scrubbing

Previous

235 / 350

Next: Partial Writes and Scrubbing

Up next

Up nextPartial Writes and Scrubbing

Sign in to save progress

Practice this lessonReport an error

See also

  • Failure Model and Protection Choice
  • Parity Datapath
  • Initialization, Injection, and Signoff