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

AboutRoadmapCareersInternshipsFAQContactPrivacyTerms
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
On this page

    Part 3 of 9Part 3 of 9/SequentialIntermediate

    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

    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.

    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.

    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 lessonPrevious lessonReport an error

    See also

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