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

  • Logic Synthesis Glossary
  • Logic Synthesis Cheatsheet
  • Synthesis Foundations14
  • Logic Optimisation and Mapping20
  • Constraints and Timing15
  • Sequential, FSM and Memory19
    • Flops, Resets and Enables
    • FSM Synthesis
    • Memory and Macro Inference
    • Retiming and Pipelining
      • What Retiming Moves
      • Latency, Throughput and Register Count
      • Reset, Initial State and Equivalence
      • Pipelining a Long Path by Hand
      • A Retiming Model and the Tool Flow
  • Datapath Synthesis14
  • Area, Power and Test14
  • Verification, ECO and Handoff15
  • Flows and Debugging15
  • Interview and Judgment11
Loading lesson

←Sequential, FSM and Memory
  1. Topics
  2. Logic Synthesis
  3. Sequential, FSM and Memory
  4. Retiming and Pipelining

Part 4 of 9Part 4 of 9/Sequential, FSM and MemoryIntermediate

Retiming and Pipelining

Moving registers across logic to balance stages; reset behavior must be rechecked.

  • 5topics
  • 5lessons

A pipeline that is too slow invites two different operations that learners constantly confuse: sliding registers across logic, and adding new registers. Mixing them up mispredicts both latency and what verification must recheck.

After this lesson you can: tell retiming from pipelining by what each does to path register counts, and predict which checks a move invalidates.

Retiming repositions registers without adding or removing any along a path. Each input-to-output path crosses the same number of registers before and after; only the split of logic between consecutive registers changes, and that split sets the clock period.

Reset-cycle outputs and the power-up flush can still change even when the steady stream does not, so they must be rechecked. Pipelining adds registers to split long paths, which adds latency: the price retiming never pays.

Flowchart of retiming balancing two uneven stages into two even stages.
Retiming shifts one block across the register: stages 8 and 4 ns become 6 and 6 ns.

Lesson

What it covers

What retiming moves

Forward and backward register moves across gates and fanout, with a tool-recorded 3-to-2 move.

Latency, throughput and register count

Why latency stays fixed while throughput rises, and when the register count changes.

Reset, initial state and equivalence

Reset-cycle differences after a move and what equivalence can still show.

Pipelining a long path by hand

Cutting a datapath into three stages with valid bits, timed per stage and proved at the right latency.

A retiming model and the tool flow

Where retiming sits in a synthesis flow, what blocks a move, and what verification must do instead.

Check yourself Two stages take 8 ns and 4 ns. Retiming balances them to 6 ns and 6 ns. What changed and what did not?

The clock period changed from 8 ns to 6 ns. Latency did not: each input-to-output path still crosses one register, so each result still takes one cycle.

Retiming against pipelining, LEC after a move, and travelling reset values.

  • Weak answer: retiming and pipelining both add registers to go faster, and equivalence always passes afterwards.

  • Strong answer: retiming keeps every path register count fixed so latency never changes, while pipelining adds a register stage per cut and pays a cycle each. A combinational check fails after retiming because the register boundaries moved; only a reset-state sequential check agrees. Reset values travel with their register and must be re-justified, as the NAND pair in lesson 3 proves.

  • Follow-up: your LEC reports mismatches on every output after a retiming pass. What do you check first? Whether any pass actually moved a register: compare the flop count before and after. If the count changed, the boundary moved with it, so switch to the retiming-aware sequential check from lesson 5 instead of a positional comparison.

  • Retiming preserves every path register count, so latency never changes; only the stage split moves.

  • Pipelining adds a register stage per cut and pays one cycle of latency each.

  • Reset values travel with their register and must be re-justified after any move.

Rule of thumb: name the path register count before arguing about speed: if it changed, that was pipelining, not retiming.

How this was checked

This hub runs nothing; its flowchart is a drawing of the lesson structure. The evidence for each claim sits on the five lesson pages, each recorded with Yosys 0.70 and ABC and listed in that page's frame.

  • Interview: run a mock interview on this topic

PreviousNext: What Retiming Moves

Up next

Up nextWhat Retiming Moves

Sign in to save progress

Practice this lessonPrevious lessonReport an error

See also

  • Flops, Resets and Enables
  • FSM Synthesis
  • Memory and Macro Inference