📚 VLSI PHYSICAL DESIGN ARCHITECTURE SERIES

VLSI Physical Design Planning & Floorplanning Handbook

14 comprehensive mentor-led chapters — master hierarchical floorplanning, die sizing, macro placement, power network synthesis, clock trunks, 3D-IC multi-die stacking, and timing budgeting with one continuous Nimbus-8 SoC.

Design planning in plain terms: deciding the shape of a chip before you build it

Design planning is the early stage of physical design where you decide how a large chip will be split into blocks, how big and what shape each block is, where the macros, the power network and the pins go, and how much timing each block is allowed to use. It happens before detailed implementation, so the decisions that are expensive to change later are made once, with the whole chip in view.

The nine decisions, in the order you usually make them

  1. Partition the design into blocks. Decide which logic lives in which block and what crosses between them. Chapter 1 and chapter 8.
  2. Split the timing constraints. Turn the chip-level constraints into a set each block owner can apply on their own, so a block does not open as a netlist with no clock. Chapter 3.
  3. Size the die and core. Estimate area, then choose aspect ratio, utilisation, rows and tracks. Chapter 4.
  4. Represent what is missing. Blocks and IP that are late, partial or hard are modelled well enough to plan around. Chapter 5.
  5. Plan the I/O and bumps. Decide where signals and power enter the chip, on pads or flip-chip bumps. Chapter 6.
  6. Shape and place blocks and macros. Set block outlines, place macros and leave keep-out margins around them. Chapter 9.
  7. Plan power. Size rings, straps and the mesh for the current each region draws. Chapter 10.
  8. Plan routing, clocks and pins. Reserve room for the wires between blocks and check congestion early, plan the clock trunks, then assign pins on block edges. Chapter 11, chapter 12 and chapter 13.
  9. Budget timing and commit. Split the chip-level timing into block budgets so each owner has numbers to meet, then commit the blocks for implementation. Chapter 14.

What a finished plan looks like

  • Every block has an outline, a set of pins and its own constraints.
  • Macros are placed with keep-out margins and nothing overlaps.
  • The power network meets the voltage-drop budget in every region.
  • There are no unexplained congestion hot spots between blocks.
  • Every block has a timing budget its owner can work to.

How plans usually go wrong

  • Block work starts before the constraints are split, so blocks cannot be timed on their own.
  • The die is sized from gate count alone, ignoring macros and routing space.
  • Pins are assigned without looking at the neighbouring block, which creates long, slow connections.
  • Power is planned late, so macros collide with straps and have to move.

Read it free. Every chapter is free to read online, starting with What a design plan is. The PDF bundle is the printable copy of all 14 chapters.

SAVE ₹220
Complete 14-Chapter Book Bundle: ₹179 (M.R.P: ₹399) · All 14 high-resolution PDFs & 199 vector schematics in one ZIP
Part 1

Part 1: Fundamentals & Tool Environment

Master the core concepts of physical design planning, IC Compiler II shell automation, and splitting chip-level SDC and UPF constraints into clean block-level scopes.

CHAPTER 01 ⏱️ 18 min read
Part 1 • 24 pages • 15 figures

What a Design Plan Is

What a design plan contains, how to partition a logical netlist into physical blocks, core sizing, utilization estimation, and flow readiness gates.

  • What a design plan contains & why downstream tools obey it
  • Partitioning a logical netlist into physical blocks
  • Die and core sizing, utilization & flow readiness gates
  • 15 vector figures & step-by-step Tcl workflow
CHAPTER 02 ⏱️ 16 min read
Part 1 • 22 pages • 13 figures

Living in the Shell

The IC Compiler II shell, help system, app options, units, scripts, setup files, logs, parallel work, and distributed task monitoring.

  • IC Compiler II shell, help system & application options
  • User units, reproducible sessions & environment setup
  • Parallel execution modes & distributed task monitoring
  • 13 vector figures & shell automation scripts
CHAPTER 03 ⏱️ 15 min read
Part 1 • 20 pages • 13 figures

Splitting Constraints

Splitting chip-level SDC and UPF constraints into top-level and block-level files, modes, corners, scenarios, and mapping files.

  • Splitting chip-level SDC and UPF into block-level files
  • Scenario construction, mode, and corner mapping
  • Handling top-to-block timing budgets & pin constraints
  • 13 vector figures & constraint splitting examples
Part 2

Part 2: Die Sizing, Floorplanning & 3D-IC Multi-Die

From initial area estimation and FinFET grid alignment to black-box IP exploration, flip-chip I/O bump arrays, and 3D-IC multi-die stacking architectures.

CHAPTER 04 ⏱️ 17 min read
Part 2 • 22 pages • 13 figures

Creating a Floorplan

Floorplan styles, outline reader, initialize_floorplan, aspect ratios, rows, tracks, the FinFET grid, and resizing the die boundary.

  • Floorplan exploration, outline reader & initialization
  • Aspect ratio, core utilization, rows, and routing tracks
  • FinFET grid alignment & boundary adjustments
  • 13 vector figures & interactive sizing equations
CHAPTER 05 ⏱️ 20 min read
Part 2 • 26 pages • 13 figures

Handling Black Boxes

Identifying missing or partial modules, creating black box references, target boundaries, timing models, and budgeting across blocks.

  • Managing missing, partial, or hard IP blocks
  • Creating black box references, boundaries & timing models
  • Budgeting across unknown blocks & early planning
  • 13 vector figures & black box verification flows
CHAPTER 06 ⏱️ 22 min read
Part 2 • 28 pages • 13 figures

Planning I/Os & Flip-Chip Bumps

I/O rings, bump arrays and patterns, pad-to-bump assignment, corner, break, and filler cells, and RDL routing and shielding.

  • I/O rings, pad placement & flip-chip bump arrays
  • Pad-to-bump assignment & matching algorithms
  • Corner cells, break cells, filler cells & RDL routing
  • 13 vector figures & I/O design rule checks
CHAPTER 07 ⏱️ 22 min read
Part 2 • 28 pages • 13 figures

Creating a 3DIC Design

3DIC & 2.5D arrangements, interposers with C4 bumps and TSVs, z-levels, microbump mirroring, die-to-die channels, and check_3d_design.

  • 3DIC & 2.5D multi-die system arrangements
  • Interposers, C4 bumps, TSVs, and z-level stacking
  • Microbump mirroring, die-to-die channels & check_3d_design
  • 13 vector figures & 3D floorplanning methods
Part 3

Part 3: Hierarchical Partitioning & Power Planning

Committing logical hierarchy to physical blocks, block shaping, macro placement channels, keepouts, relative constraints, and PG power mesh synthesis.

CHAPTER 08 ⏱️ 20 min read
Part 3 • 25 pages • 15 figures

Managing Design Blocks

Exploring hierarchy, module boundaries, committing blocks, placement abstracts, push/pop objects, shadow netlists, and ECO scripts.

  • Exploring hierarchy & committing logical modules to physical blocks
  • Module boundaries, placement abstracts & shadow netlists
  • Push/pop objects, block handoff & hierarchical ECO scripts
  • 15 vector figures & block management commands
CHAPTER 09 ⏱️ 24 min read
Part 3 • 30 pages • 15 figures

Block Shaping & Macro Placement

Macro constraints, keepouts, relative placement, shape_blocks, constraint files, Tcl shaping, MIB grids, and ML macro placement.

  • Block shaping, macro constraints, keepouts & relative placement
  • Shape_blocks command, constraint files & Tcl shaping scripts
  • MIB grids, macro channels & ML-assisted macro placement
  • 15 vector figures & placement guideline checks
CHAPTER 10 ⏱️ 22 min read
Part 3 • 28 pages • 15 figures

Power Planning

Pattern-based power planning, PG strategies, compile_pg, power rings, meshes, stdcell rails, and power integrity check rules.

  • Pattern-based power planning & PG strategy creation
  • Compile_pg commands, power rings, meshes & stdcell rails
  • Quiet areas, macro PG hooks & power integrity check rules
  • 15 vector figures & complete PG Tcl recipes
Part 4

Part 4: Routing, Clock Trunks & Timing Signoff

Global routing corridor analysis, early CTS clock trunk latency, pin assignment and feedthrough corridors, and top-level timing budgeting signoff.

CHAPTER 11 ⏱️ 20 min read
Part 4 • 26 pages • 16 figures

Global Planning & Corridors

Routing corridors, global routing in design planning, congestion heatmaps, cross-block feedthrough estimation, and routing budgets.

  • Routing corridors & global route estimation in design planning
  • Congestion heatmaps, overflow analysis & bottleneck debug
  • Cross-block feedthrough estimation & metal resource planning
  • 16 vector figures & congestion analysis commands
CHAPTER 12 ⏱️ 22 min read
Part 4 • 28 pages • 17 figures

Clock Trunk Planning

Clock trunk architecture, early CTS latency estimation, synthesize_clock_trunks, anchor insertion, and cross-block clock tree balance.

  • Clock trunk architecture & early CTS latency estimation
  • Synthesize_clock_trunks command & anchor cell insertion
  • Cross-block clock tree balance & top-level skew closure
  • 17 vector figures & clock trunk synthesis Tcl
CHAPTER 13 ⏱️ 22 min read
Part 4 • 28 pages • 18 figures

Pin Assignment

Pin assignment, block and individual constraints, pin bundles, feedthrough routing corridors, place_pins, and pin checks.

  • Pin assignment, block constraints & individual pin placement
  • Pin bundles, feedthrough routing corridors & layer rules
  • Place_pins command, alignment checks & boundary verification
  • 18 vector figures & pin rule automation
CHAPTER 14 ⏱️ 25 min read
Part 4 • 30 pages • 16 figures

Timing Budgeting

Timing abstracts, virtual in-place optimisation (VIPO), estimated_corner, compute_budget_constraints, and budget shells.

  • Timing abstracts, VIPO & estimated corner analysis
  • Compute_budget_constraints & block-level timing shells
  • Top-level timing closure & hierarchical signoff handoff
  • 16 vector figures & complete timing budgeting scripts

Where this fits

This book covers how a chip is planned — floorplan, macros, power grid, clock trunks, and timing budgets. Once the plan is signed off, PnR Flow Mentor Guide covers how it is actually built: library setup, placement, clock tree synthesis, routing, chip finishing, and ECO, all the way to stream-out.