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
    • Peripheral RTL Integration
    • Full AXI4: RTL Roadmap
  • Advanced RTL28
  • Senior & Interview76
  • Glossary and Notation
Loading lesson

‹RTL Design
  1. Topics
  2. RTL Design
  3. Memory & Buses

Part 7 · Memory & Buses · Intermediate

Memory & Buses

Memories, FIFOs, CSRs, reliability, flow control, AXI, peripheral shells, and SoC bus integration.

  • 11topics
  • 57lessons
On this page

    On-chip memory and standard buses connect datapaths to software and peripherals. This section covers inference rules, flow control, AXI family basics, SoC bus integration, and robust single-clock buffering.

    Learning path through the memory and bus topics.
    Suggested order. Start with storage and flow, then transport and FIFOs, software-visible control, reliability, peripheral integration, and advanced AXI concurrency.

    The eleven topics

    Topic

    Lessons

    After it you can…

    Study time

    SRAM and ROM

    6

    Write portable single-port, dual-port, and ROM templates.

    50 min

    Register Files

    3

    Build a multi-port register file with correct bypass.

    25 min

    Valid/Ready Handshakes

    4

    Apply flow-control rules and absorb backpressure with a skid buffer.

    25 min

    AXI-Lite

    5

    Write a register-mapped slave with correct strobes and responses.

    30 min

    AXI-Stream

    3

    Move packet data with TLAST and TKEEP framing.

    25 min

    Bus Integration

    6

    Decode an address map and handle muxing, errors, and arbitration.

    40 min

    Synchronous FIFO

    7

    Build and verify an arbitrary-depth FIFO with explicit boundary and latency contracts.

    2–3 h

    Register-Map RTL

    9

    Implement and generate CSR semantics, atomic updates, interrupts, and bus adapters.

    3–4 h

    Memory Reliability

    7

    Add parity/SECDED, reporting, scrubbing, injection, and repair hooks.

    3 h

    Peripheral Integration

    5

    Build a reusable shell around protocol engines, FIFOs, interrupts, and DMA.

    2 h

    Full AXI4 Roadmap

    2

    Plan bursts, IDs, ordering, and outstanding state, then continue in Protocols.

    45 min

    Study time covers reading each lesson and running its examples. The section's hands-on project takes extra hours on top.

    Tip

    When a transfer stalls, check who owns the wait: the source holds valid and payload stable, and only the sink drives ready. Most handshake bugs come from mixing up those two jobs.

    Check yourself Before starting AXI, can you say when a valid/ready transfer actually happens?

    Only when valid and ready are high in the same cycle. Either side may wait, and the payload must stay stable while the source waits. The Valid/Ready Handshakes topic builds the rules, the skid buffer, and the AXI interpretation.

    Interview

    Typical screening tasks from this section: explain read-first versus write-first memory behavior, design a synchronous FIFO or skid buffer, write an AXI-Lite slave, frame an AXI-Stream packet, and decode an address map with a default slave.

    End-of-section checkpoint

    Use these four questions to decide whether you are ready to move on: explain, predict, implement and debug. If one is shaky, each answer names the lesson to revisit. New readers can skip this until they finish the section.

    Check yourself Explain: state the two valid/ready rules that keep a channel from deadlocking or losing data.

    A source must not wait for ready before asserting valid, and once valid is high it must hold valid and the data stable until the handshake (valid && ready at a clock edge). The receiver may wait for valid before asserting ready. Revisit Rules that keep flow control safe.

    Check yourself Predict: a synchronous single-port RAM is written and read at the same address in the same cycle. What does the read return in read-first and in write-first mode?

    Read-first returns the old contents at that address; write-first returns the data being written. Code it the way the target memory behaves, or the RTL and the inferred RAM disagree. Revisit Read-first vs write-first behavior.

    Check yourself Implement: a synchronous FIFO keeps a count. How does count change when push and pop happen in the same cycle?

    A push is accepted only when not full and a pop only when not empty. When both are accepted, count stays the same; push alone adds one; pop alone subtracts one. Decide explicitly whether a push is allowed on a full FIFO in a cycle that also pops. Revisit Simultaneous push and pop.

    Check yourself Debug: an AXI-Lite slave raises BVALID one cycle after the AW handshake, before the write data has arrived. What rule does it break?

    The write response may only be given after both the write address and the write data handshakes have happened. The slave must wait for the W handshake (and use its data and strobes) before asserting BVALID. Revisit Responses, strobes and errors.

    Related topics

    • Previous: Reset & CDC

    • Next: Advanced

    PreviousNext: SRAM and ROM

    Up next

    Up nextSRAM and ROM

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • RTL Foundations
    • Combinational Design
    • Sequential Design