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
      • Contract and Invariants
      • Pointers, Occupancy and Flags
      • Portable Registered-Output FIFO
      • Simultaneous Push and Pop
      • Standard vs Fall-Through Output
      • Almost Flags and Parameter Edges
      • Verification and Signoff
    • Register-Map and CSR RTL
    • Memory Reliability
    • Peripheral RTL Integration
    • Full AXI4: RTL Roadmap
  • Advanced RTL28
  • Senior & Interview76
  • Glossary and Notation
Loading lesson

‹Synchronous FIFO
  1. Topics
  2. RTL Design
  3. Memory & Buses
  4. Synchronous FIFO
  5. Standard vs Fall-Through Output

Part 7 · Memory & Buses · Intermediate

Standard vs Fall-Through Output

Registered-read and first-word-fall-through FIFO interfaces, their timing, and their memory-inference consequences.

On this page

    Why this matters

    Two blocks can both be called a FIFO and differ by a full cycle in when data is valid. A fall-through output also needs an asynchronous memory read, which many SRAM macros do not offer.

    After this lesson you can: compare registered-output and first-word fall-through FIFOs, and say what a prefetched fall-through design adds.

    Two valid FIFO contracts

    Property

    Registered output

    First-word fall-through (FWFT/show-ahead)

    When data appears

    After an accepted pop

    As soon as the FIFO is non-empty

    Output qualification

    Pop-result valid pulse

    !empty or an output-valid level

    Read path

    Clocked memory read

    Combinational array read or a prefetch register

    Latency

    One cycle from pop to result

    Front word already visible

    Timing

    Registered boundary

    May expose memory/mux delay to the consumer

    Memory mapping

    Usually block-RAM friendly

    Direct combinational form may force flops/LUT RAM

    Each slot is one clock cycle. Both FIFOs hold A and B before slot 0, and both get pops in slots 1 and 3.

    • Slot 0: the fall-through FIFO already shows A with fwft_valid high. The registered FIFO shows nothing valid yet.

    • Slot 1: the pop takes A. The fall-through consumer reads A in this same slot; the registered FIFO delivers A in slot 2 with a one-cycle valid pulse.

    • Slot 3: the second pop takes B. The registered result arrives in slot 4.

    • Slot 4: the fall-through FIFO is empty, so its valid is 0 and its data is unknown. Only valid gives the data meaning.

    Direct fall-through

    design.sv
    1
    2
    3
    4
    // snippet: simple FWFT view; often not block-RAM compatible
    assign dout_o       = mem[rd_ptr];
    assign dout_valid_o = !empty_o;
    assign pop_take     = pop_i && dout_valid_o;

    This is easy to reason about, but it creates an asynchronous memory read. It is suitable for a small flop-based queue and risky for a large FIFO intended for a synchronous SRAM macro.

    Because the running FIFO targets a synchronous memory, it retains registered pop-result behavior. A separate FWFT variant would need a prefetch controller and a different consumer contract rather than a one-line output substitution.

    Prefetched fall-through

    A memory-friendly FWFT design keeps an output register filled whenever data exists. The prefetch controller reads the next word before the current front word is consumed. That preserves a registered external path but adds state for output-valid, refill, and the case where pop and refill coincide.

    FIFO memory prefetching into an output register controlled by output-valid and consume events.
    A prefetch register gives fall-through behavior without exposing a combinational memory path.

    Tip

    Name the mode in the interface or module name. Two blocks can both be called fifo while disagreeing by a full cycle about when data is valid.

    Check yourself Why can assign dout = mem[rd_ptr] prevent block-RAM inference?

    It describes an asynchronous read. Many block RAMs and ASIC SRAM macros provide a clocked read, so the tool must use distributed memory or flops to preserve the combinational behavior.

    Check yourself What extra state does a prefetch FWFT FIFO need?

    At minimum an output register and output-valid state, plus refill control that keeps the register loaded across consumes, memory latency, and simultaneous push/pop cases.

    Remember

    • Direct fall-through reads the memory asynchronously. It suits a small flop-based queue, not a large synchronous SRAM.

    • A memory-friendly fall-through FIFO keeps an output register filled by a prefetch controller.

    • The consumer contract changes with the mode, so it is not a one-line output swap.

    Rule of thumb: name the output mode in the interface or the module name.

    Keep going

    • Practice: FWFT FIFO with almost flags and pointer-distance occupancy

    • Interview: run a mock interview on this topic

    Related topics

    • Memory inference starts from coding style

    • Almost flags and parameter edges

    Previous

    220 / 350

    Next: Almost Flags and Parameter Edges

    Up next

    Up nextAlmost Flags and Parameter Edges

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Contract and Invariants
    • Pointers, Occupancy and Flags
    • Portable Registered-Output FIFO
    clkpop_ireg_validreg_dout0abfwft_validfwft_doutabx
    The same two words A and B in a registered-output FIFO and in a fall-through FIFO: the fall-through output shows each word before its pop, the registered output one cycle after