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

  • 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

‹Retiming and Pipelining
  1. Topics
  2. Logic Synthesis
  3. Sequential, FSM and Memory
  4. Retiming and Pipelining
  5. Reset, Initial State and Equivalence

Part 4 · Sequential, FSM and Memory · Intermediate

Reset, Initial State and Equivalence

Why reset sequences and initial states need rechecking after registers move.

On this page

    Reset travels with the register

    A reset value belongs to a register, not to a position in the pipeline. When the register moves, its reset value moves with it.

    Logic that sat after the register now sits before it, or the reverse. The reset-time output changes even though the steady stream does not.

    A reset-cycle example

    Take f(x) = x + 10 and g(x) = 2x as EXAMPLE functions. One register sits between them, and it resets to 0.

    Cycle

    in

    out before

    out after

    0

    7

    0

    20

    1

    8

    34

    34

    2

    9

    36

    36

    3

    10

    38

    38

    Before the move, reset holds the register at 0, so cycle 0 outputs 2 x 0 = 0. After moving the register back across f, cycle 0 outputs 2 x (0 + 10) = 20.

    The streams agree from cycle 1 onward. Only the reset cycle differs, so any comparison must skip it.

    What equivalence can still show

    Combinational equivalence fails after retiming because register positions differ. Sequential equivalence reasons over several cycles instead, and it must skip the flush cycles.

    Gated clocks, clock enables and asynchronous resets block the move in most flows. A register the tool cannot analyze stays where it is.

    Common mistakes

    Common pitfall

    Comparing outputs from cycle 0 flags a mismatch that is only the reset transient. Restart the comparison after the pipeline flushes, and re-derive the expected reset values first.

    Interview

    Likely probes: what retiming preserves and what it breaks.

    • The steady-state stream is preserved; the reset-cycle outputs are not.

    • Cycle 0 above reads 0 before the move and 20 after it, then agrees.

    • Registers with enables or asynchronous resets usually cannot move.

    Check yourself The moved register resets to 0. Why does cycle 0 read 20 after the move instead of 0?

    The register now sits before f instead of after it. Cycle 0 computes g(f(0)), which is 2 x 10 = 20.

    Check yourself A pipeline register has a clock enable. Can the tool freely retime it?

    Usually not. The enable changes which cycles the register samples, so the move needs enable-aware handling that most flows skip.

    Related topics

    • Latency, throughput and register count

    • Equivalence checking

    Previous

    68 / 139

    Next: Pipelining a Long Path by Hand

    Up next

    Up nextPipelining a Long Path by Hand

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • What Retiming Moves
    • A Retiming Model and the Tool Flow