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
    • Flip-Flops and Registers
    • Counters and Timers
    • Shift Registers and LFSRs
    • Pipelining
      • Throughput and Latency
      • A Three-Stage Arithmetic Pipeline
      • Valid/Ready Flow Control
      • Pipelined MAC
      • Precision Verification
    • Stalls, Bubbles and Hazards
    • Retiming
  • FSM & Control27
  • Timing & Clocking39
  • Reset & CDC34
  • Memory & Buses57
  • Advanced RTL28
  • Senior & Interview76
  • Glossary and Notation
Loading lesson

‹Sequential Design
  1. Topics
  2. RTL Design
  3. Sequential Design
  4. Pipelining

Part 3 · Sequential · Intermediate

Pipelining

Pipelining trades registers and latency for clock rate, with valid/ready flow control under backpressure.

  • 5topics
  • 5lessons

Topics in this section

  1. 1Throughput and Latency1 lesson
  2. 2A Three-Stage Arithmetic Pipeline1 lesson
  3. 3Valid/Ready Flow Control1 lesson
  4. 4Pipelined MAC1 lesson
  5. 5Precision Verification1 lesson
On this page

    A long chain of logic limits the clock rate. Pipelining cuts it with registers, so each stage does part of the work while several items are in flight.

    A three-stage pipeline with a register after each stage.
    Three stages separated by registers. While stage 3 works on item 1, stage 2 works on item 2, and stage 1 on item 3.

    Lessons in this topic

    5 lessons, about 19 min

    1. 1Throughput and LatencyYou can compute the period, frequency, latency and throughput of an S-stage pipeline, and say when pipelining does not help.3 min
    2. 2A Three-Stage Arithmetic PipelineYou can split y = a*b + c into three stages, carry a valid bit and the late operand along, and predict when each result is consumed.4 min
    3. 3Valid/Ready Flow ControlYou can state the four valid/ready rules, build a stage that holds data through a stall, and explain what its combinational ready path costs.4 min
    4. 4Pipelined MACYou can build a pipelined MAC with a frame-aware valid, state which registers need reset, and name how to break the accumulator recurrence.3 min
    5. 5Precision VerificationYou can plan arithmetic verification with a bit-exact model, a high-precision model, an error budget and boundary stimulus, and show which mutant each check catches.5 min
    Check yourself A 4-stage pipeline runs at 1 GHz and produces a result every cycle. What are its throughput and latency?

    Throughput: 1 result per ns (10⁹ results/s). Latency: 4 cycles = 4 ns from input to the corresponding output.

    Interview

    Expect: “What is pipelining and what does it cost?”, “Define throughput and latency”, and “How do you stall a pipeline without losing data?”. The third is the valid/ready lesson.

    Revision sheet

    The whole topic on one page, taken from each lesson's Remember box. Read it before an interview, or print it.

    Throughput and Latency

    • With S balanced stages the period falls toward D/S plus register overhead.

    • Latency in time barely changes and can grow; the gain is throughput over a stream.

    • The slowest stage sets the clock, and a loop such as acc <= acc + x cannot simply gain stages.

    A Three-Stage Arithmetic Pipeline

    • Give the slow multiply its own stage; the add then has slack.

    • Delay each late operand by the same number of stages as the data it belongs with.

    • Reset only the valid bits; consumers ignore y while out_v is low.

    Valid/Ready Flow Control

    • A transfer happens on an edge where both valid and ready are high.

    • Once valid is asserted it stays asserted, with data stable, until the transfer.

    • in_ready = !out_valid || out_ready keeps one item per cycle, but a stall ripples back combinationally through a chain.

    Rule of thumb: never drop an item because ready was low, and never copy it because the consumer stalled.

    Pipelined MAC

    • Delay valid and frame markers by the same number of stages as the data.

    • Count accepted products, not clock cycles. Reset validity and frame state, not every wide data register.

    • The accumulator is a loop-carried add, so its adder path sets the clock; partial sums or interleaving break it.

    Precision Verification

    • Test one LSB below, at and above every rounding and saturation boundary, with ties of both signs.

    • The bit-exact model proves conformance; the high-precision model measures accuracy against the budget.

    • At a tie both neighbours are half an LSB away, so only the bit-exact compare catches a wrong tie rule.

    Rule of thumb: mutate the rounding, a shift and a valid delay, and confirm the testbench fails.

    Practise it

    • Mini project: a programmable timer with prescaler, compare and interrupt

    • Code lab: Pipeline register stage

    • Practice question: Design a 3-stage pipelined ALU with stall support

    • Code lab: Pipelined multiplier stage

    • Practice question: Two-stage valid/ready pipeline: throughput, latency and backpressure

    • Interview: run a mock interview on this topic

    PreviousNext: Throughput and Latency

    Up next

    Up nextThroughput and Latency

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Flip-Flops and Registers
    • Counters and Timers
    • Shift Registers and LFSRs