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
  • Datapath Synthesis14
  • Area, Power and Test14
    • Area, Power and Timing Trade-offs
      • The Three-Way Trade-Off
      • Dynamic Power Arithmetic
      • Leakage and Vt Mixing
      • Sizing and Duplication Cost
      • Fair Comparison and Pareto Filtering
    • Clock Gating and Low Power
    • DFT and Scan Insertion
  • Verification, ECO and Handoff15
  • Flows and Debugging15
  • Interview and Judgment11
Loading lesson

‹Area, Power and Timing Trade-offs
  1. Topics
  2. Logic Synthesis
  3. Area, Power and Test
  4. Area, Power and Timing Trade-offs
  5. Sizing and Duplication Cost

Part 6 · Area, Power and Test · Intermediate

Sizing and Duplication Cost

Sizing and duplication cost area and power to buy timing.

On this page

    Sizing up a gate

    Sizing swaps a cell for a stronger, larger sibling that drives its load faster. The faster arrival costs area and switched capacitance, hence power.

    The trade is local and bounded: it helps the paths it touches and taxes the power budget. Whether it closes timing varies with load and library.

    Duplicating logic to cut load

    Duplication copies a cone so each copy drives fewer sinks. Each sink sees less load, so arrivals improve, but every copy adds its full area and power.

    The script below proves the cost in a synthesis tool: the same addition written twice stays two add cells after the share pass, as the assertion pins. Each copy is paid in full.

    yosys
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    read_verilog <<EOV
    module top(input [7:0] a, b, output [8:0] y, z);
    assign y = a + b;
    assign z = a + b;
    endmodule
    EOV
    hierarchy -check -top top
    proc
    share
    select -assert-count 2 t:$add
    log PASS: two identical 8-bit adds stay two add cells after share

    A worked area cost

    Areas below are library units of the fictional teaching library course.lib, not a real process. The cone is one AOI21 plus one MUX2.

    Sharing keeps one cone; duplicating it for two sinks doubles the cone. The calc block prices the copy.

    Build

    Cells

    Area (library units)

    Shared cone

    One AOI21 + one MUX2.

    3 + 5 = 8.

    Duplicated cone

    Two of each.

    2 x 8 = 16.

    Extra cost

    One full copy.

    16 - 8 = 8, which is +100%.

    Diagram
    teaching library course.lib areas in library units: AOI21 = 3, MUX2 = 5
    shared cone: one AOI21 + one MUX2 = 3 + 5 = 8 units
    duplicated cone (one copy per sink): 2 x 8 = 16 units
    extra cost = 16 - 8 = 8 units, 8 / 8 = 1.00 = +100% area for that cone

    Common mistakes

    Duplication without load relief buys nothing: two copies driving the same heavy net cost area for no timing gain. Always check what the copy unloads.

    Common pitfall

    Sizing every gate on a failing path can overshoot the power budget long before timing closes. Size the worst violators first, re-time, and stop when slack turns non-negative.

    Interview

    Likely probes: pricing speed in area and power.

    • Sizing trades larger, thirstier cells for faster arrival on one path.

    • Duplication trades a full copy of the cone for lighter load per copy.

    • The shared cone costs 8 units; the duplicated cone costs 16 units.

    Check yourself A cone of 8 library units is duplicated for two sinks. What is the new cone area?

    16 units. The copy adds 8 units, which is +100% for that cone.

    Check yourself The Yosys script writes the same addition twice, and the assertion counts two add cells after share. What does that prove?

    Each textual addition becomes its own adder: the share pass does not merge the two copies, so the duplication costs two adders.

    Related topics

    • Next: Fair Comparison and Pareto Filtering

    • See also: Technology Mapping

    Previous

    88 / 139

    Next: Fair Comparison and Pareto Filtering

    Up next

    Up nextFair Comparison and Pareto Filtering

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • The Three-Way Trade-Off
    • Dynamic Power Arithmetic