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

  • How to Use This Course
  • The NanoSoC Tour
  • Reading Path
  • SoC Glossary10
  • SoC Metrics Reference
  • SoC Cheatsheet
  • What SoC Integration Is12
  • Architecture and Budgets21
    • Partitioning and Hierarchy
    • Area Budgets
      • Area Roll-Up
      • Utilisation and Margin
      • How Area Budgets Move
    • Timing Budgets Across Hierarchy
    • Power Budgets
    • Bandwidth Budgets
    • Budget Governance
    • Multi-Die and Chiplet View
  • Memory Maps and Address Decode26
  • Interconnect and Bus Fabrics26
  • Clock and Reset Architecture24
  • Power Architecture21
  • Interrupts, DMA and Peripherals15
  • Memories, Boot and Security21
  • IP Integration and Handoff21
  • Top-Level Verification and Bring-up21
  • Package, Pads and I/O18
  • Chip Signoff and Tapeout18
  • SoC Interview Prep16
  • Capstone: Integrate NanoSoC14
Loading lesson

←Area Budgets
  1. Topics
  2. SoC Design
  3. Architecture and Budgets
  4. Area Budgets
  5. Utilisation and Margin
On this page

    Part 2 of 14, lesson 5 of 21Part 2 of 14/Architecture and Budgets/Lesson 5 of 21All levels

    Utilisation and Margin

    What 69.7% utilisation means, how much margin to keep, and when the die is pad-limited instead.

    Why it matters

    A utilisation number is only useful if it leads to a decision. At 69.7% NanoSoC looks comfortable, but comfort depends on what the remaining 30% must absorb: a late memory increase, a wider fabric, a second DMA, and the routing congestion none of the block rows price. Utilisation is not a score; it is the margin expressed upside down.

    The core idea

    A common planning guideline for a small placed design is about 70% core utilisation: dense enough to be economical, open enough to route and to absorb growth. The headroom is typically consumed in this order. Routing and buffering take the first share, because the overhead line is only an estimate until the design is routed. Engineering change orders take the second share: a metal fix needs spare sites near the fault. Planned growth takes the third. NanoSoC has reserved peripheral slots (hole H3, slots 7 to 15) that claim a little area before they exist. To make the growth share concrete the lesson prices one hypothetical addition that is not in the NanoSoC map: a 128 KB RAM block, which today would have no address (everything from 0x2002_0000 up is hole H2 and answers DECERR). A design at 90% has spent all three shares in advance; a design at 50% is paying for silicon it does not use.

    Diagram
    # not-run: NanoSoC utilisation headroom, NanoSoC teaching values
    Core 0.655 mm2 in budget 0.940 mm2: headroom 0.285 mm2 (30.3%).
    Hypothetical 128 KB RAM (not in the NanoSoC map). At the NanoSoC SRAM
    density, 64 KB = 0.100 mm2, so 128 KB = 0.200 mm2 of blocks; with the 12%
    overhead that is 0.224 mm2.
    Hypothetical second DMA plus slot logic: about 0.020 mm2 of blocks, 0.0224 mm2
    with overhead.
    Remaining: 0.285 - 0.224 - 0.0224 = 0.0386 mm2, about 4% of the die budget.
    Verdict: 69.7% is comfortable but not generous; one growth step fits, a
    third item does not.

    Pad-limited versus core-limited

    Area has a second floor that no budget table shows: the pads. If the pad ring with its drivers needs more perimeter than the core needs area, the die is pad-limited and the core utilisation number is decorative — shrinking logic no longer shrinks the die. NanoSoC with its modest pin count is core-limited, so the 69.7% is the binding constraint. The review question to ask on every project is which limit binds: quote both the core utilisation and the pad-ring perimeter check, and manage the binding one.

    example.py
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    budget, core = 0.940, 0.655
    util = core / budget
    assert abs(util - 0.697) < 0.002
    headroom = budget - core
    assert abs(headroom - 0.285) < 0.001
    # Hypothetical growth priced on the headroom, with the 12% overhead (NanoSoC teaching values).
    overhead = 1.12
    ram_128k = 2 * 0.100 * overhead  # 128 KB = two 64 KB blocks at specification density
    dma2 = 0.020 * overhead
    assert abs(ram_128k - 0.224) < 0.0005, ram_128k
    remaining = headroom - ram_128k - dma2
    assert abs(remaining - 0.0386) < 0.001, remaining
    floor = 0.03 * budget  # illustrative floor kept for routing slack and ECOs
    assert remaining >= floor, (remaining, floor)
    # The check can fail: one more 0.020 mm2 item breaks the floor.
    assert remaining - 0.020 * overhead < floor
    # Pad-limited check (illustrative pad ring): die side vs the side the pads need.
    import math
    die_side = math.sqrt(budget)  # square-die illustration, 0.970 mm
    pad_side_needed = 0.700  # illustrative: pads need 0.700 mm of edge per side
    limited = "pad-limited" if pad_side_needed > die_side else "core-limited"
    assert limited == "core-limited"
    assert (1.2 > die_side)  # a ring needing 1.2 mm per side would flip the verdict
    print(f"PASS: util {util*100:.1f}%, headroom {headroom:.3f}, growth leaves {remaining:.3f} (floor {floor:.3f}); {limited}")

    What the review looks for

    • A utilisation target written down before layout, with the headroom shares named: routing, ECO, growth.

    • Planned growth priced against the headroom with the 12% overhead included, not assumed free.

    • The pad-limited check quoted beside the utilisation, with the binding limit circled.

    Verify and debug

    Track utilisation weekly once synthesis starts: estimated gate area plus macro area against the same 0.940 budget. A jump of more than two points in a week means a block estimate changed, not that the tools drifted — ask which one. If utilisation crosses 80% before routing, call the rebalancing review early; the governance topic runs that meeting.

    Managing to the block subtotal instead of the core total. The overhead line grows with congestion, so a design at 65% blocks can still fail routing. Quote utilisation on core area always, and re-estimate overhead after the first trial route. (Quoting it on blocks alone is the same failure as pricing growth without the 12% overhead.)

    If asked what utilisation to target, answer about 70% for a small design, then spend the 30%: routing slack, ECO sites, planned growth. Interviewers score the spending plan, not the number.

    Run the pad-limited check as its own small budget: sum signal, power and analogue pads, divide by the four sides, and compare against the die side (the square root of the 0.940 mm2 die budget is about 0.97 mm, before the ring width). If the pad side wins, the project manages pad count and bump pitch instead of gate area — multiplexing functions, sharing supplies, cutting test pins. NanoSoC never reaches that regime, but the check belongs in every review pack beside utilisation, because the binding limit decides which budget the team meets weekly.

    Check yourself Why is 69.7% comfortable but not generous on NanoSoC?

    Because even modest growth — a hypothetical 128 KB RAM and a second DMA, 0.224 plus 0.0224 mm2 with overhead — claims most of the 0.285 mm2 headroom, leaving about 0.039 mm2 (4% of the die budget) for routing slack and fixes. One growth step fits; a third item needs a bigger budget.

    Related topics

    • Area Roll-Up

    • Next: How Area Budgets Move

    • Arch: Floorplan-Aware Budgets

    Previous

    22 / 289

    Next: How Area Budgets Move

    Up next

    Up nextHow Area Budgets Move

    Sign in to save progress

    Practice this lessonPrevious lessonReport an error