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. Latency, Throughput and Register Count

Part 4 · Sequential, FSM and Memory · Intermediate

Latency, Throughput and Register Count

Latency stays fixed while throughput rises, and fanout moves change the register count.

On this page

    Latency is cycles, throughput is rate

    Latency counts register stages from input to output. Throughput counts results per second after the pipeline fills.

    Retiming keeps every path register count, so latency is unchanged. A shorter period then raises throughput at the same latency.

    When the count changes

    The total register count can still move. Forward moves across fanout duplicate registers, and backward moves across shared gates merge them.

    Variant

    Registers before

    Registers after

    Path count

    Move across a gate

    1

    1

    Unchanged at 1.

    Forward across 2-way fanout

    1

    2

    Unchanged at 1 per branch.

    Backward across 2-way fanout

    2

    1

    Unchanged at 1.

    A counted example

    Take the balanced pair from the previous lesson. Move its register forward across a two-way fanout instead of across a gate.

    Diagram
    path registers before = 1, path registers after = 1, latency = 1 cycle both ways
    total registers before = 1, total registers after = 2, change = +1
    teaching-library cost: one DFF = 8 area units, added area = 1 x 8 = 8 area units
    throughput before = 1 result per 8 ns, after = 1 result per 6 ns

    Each branch still crosses one register, so latency is one cycle. The design pays one extra register of 8 teaching-library area units.

    Common mistakes

    Common pitfall

    Counting total registers instead of per-path registers misleads. Duplication across fanout raises the total while every path still crosses one register.

    Interview

    Likely probes: latency against throughput, and who pays for balance.

    • Latency is path register stages; throughput is results per second at the achieved period.

    • Retiming holds latency fixed and moves throughput with the period.

    • Fanout duplication costs one register per extra branch at 8 area units each.

    Check yourself A forward fanout move takes the total from 1 register to 2. What is the latency of each branch?

    One cycle per branch. Each branch crosses exactly one of the two registers.

    Check yourself The period improves from 8 ns to 6 ns at fixed latency. What happens to throughput?

    It rises: one result per 6 ns instead of one per 8 ns, once the pipeline is full.

    Related topics

    • What retiming moves

    • Delay models and slack

    Previous

    67 / 139

    Next: Reset, Initial State and Equivalence

    Up next

    Up nextReset, Initial State and Equivalence

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Pipelining a Long Path by Hand
    • A Retiming Model and the Tool Flow