On this page 13 sections
- What is placement in VLSI?
- Inputs and pre-placement checks
- Stage 1: Global placement
- Placement optimization
- Stage 2: Legalization
- Stage 3: Detailed placement
- Placement QoR: what to check before CTS
- Common placement problems and fixes
- Debug flowchart for placement problems
- Interview questions and answers
- FAQ
- Summary
- References
Placement decides where every standard cell in the netlist sits inside the core. Most of the wirelength, routing congestion and data-path timing you fight for the rest of the flow is set here, and CTS cannot rescue paths whose cells are spread across the die. That is why placement is one of the stages interviewers ask about most, and why experienced engineers spend real time reading placement reports before moving on.
This guide explains what placement does, the three sub-steps (global placement, legalization and detailed placement), the optimization that runs in between, the knobs that matter, how to check the result, a debug flowchart and interview Q&As. The worked examples are illustrative: the numbers show the method and do not come from any foundry, library or project, except where an open-source flow is named. Command names follow the open-source OpenROAD tools because their documentation is public; commercial place-and-route tools have equivalent steps with different command names, so check your tool's manual. Related reading on iVLSI: Floorplanning in VLSI, Macro Placement in VLSI, Routing Congestion in VLSI and SDC Constraints in VLSI.
What is placement in VLSI?#
Placement is the physical design step that assigns a legal location (row, site and orientation) to every movable standard cell in the synthesized netlist, after floorplanning and before clock tree synthesis (CTS). By the time placement starts, the floorplan has already fixed the die and core, macros, I/O pins, the power grid and physical-only cells such as tap and endcap cells (see Physical-Only Cells in VLSI). Placement works with what is left: thousands to millions of standard cells that all have the same height (or a multiple of it) and different widths.
Its goals, roughly in order of how often they cause trouble:
- Short wires. Connected cells should sit close together, because wirelength drives delay, power and routing demand.
- Routability. No region should be so dense in cells or pins that the router cannot finish it.
- Timing. Cells on critical paths should be close enough that setup can be met once real wires are added.
- Legality. Every cell on a row, aligned to a site, with no overlaps and correct power-rail orientation.
- Power. Nets that toggle often should be short, and the design should not be over-buffered.
Inputs and pre-placement checks#
Placement reads the floorplanned database plus the timing and physical libraries and the SDC. Before running it, most teams check:
- Netlist health: floating or undriven inputs, unloaded outputs and multi-driven nets (the classic list in our pre-placement sanity checks post).
- Constraints: every clock defined, I/O delays present, no endpoints left unconstrained. A placement driven by a wrong SDC optimizes the wrong paths.
- Floorplan legality: macros, tap cells and endcaps fixed and legal, rows and sites present everywhere cells should go, placement blockages where you intended them. OpenROAD's
check_placement -fixedchecks fixed instances and macros before standard cells are placed. - Wire RC model: the per-unit resistance and capacitance used to estimate parasitics before routing. If it is badly off, every timing number during placement is off too.
Stage 1: Global placement#
Global placement finds a rough position for every cell that minimizes total wirelength while keeping density under control. It is allowed to produce overlaps and off-grid positions; legality comes later.
How wirelength is measured#
Placers cannot afford to route every net while deciding where cells go, so they use an estimate. The usual one is half-perimeter wirelength (HPWL): the half perimeter of the smallest rectangle that encloses all pins of a net. It is exact for two- and three-pin nets with a Steiner-optimal route and a lower bound for larger nets, and it is cheap to compute.
Worked example A: HPWL of a net (illustrative)#
A net has a driver at (1, 1) and loads at (6, 5), (3, 6) and (7, 2), in µm. The bounding box spans x from 1 to 7 and y from 1 to 6, so:
HPWL = (xmax - xmin) + (ymax - ymin) = (7 - 1) + (6 - 1) = 11 umIf the placer moves the load at (7, 2) to (5, 2), the box shrinks to x from 1 to 6 and HPWL drops to 10 µm.
Analytical placement and density#
Modern global placers are analytical: they treat cell positions as continuous variables and minimize a smooth approximation of total weighted wirelength plus a density penalty that pushes cells out of crowded areas. The OpenROAD global placer (gpl) is based on RePlAce, which in turn uses the ePlace approach: it models cells as electric charges, solves the resulting electrostatic problem, and uses Nesterov's method to move cells. Its documentation lists an optional initial placement step before the Nesterov iterations and says that initial placement improves HPWL by about 5% on large designs.
The core is divided into a grid of bins. Each bin's density is the cell area inside it divided by the bin's free area. The placer has a target density: in OpenROAD global_placement -density defaults to 0.7 (70%). Overflow measures how much cell area still sits above the target across all bins; the placer iterates until overflow drops below a threshold (the -overflow default is 0.1).
Target density is not the same as floorplan utilization. OpenROAD-flow-scripts (ORFS) sets the floorplan with CORE_UTILIZATION and global placement with a separate PLACE_DENSITY; its nangate45 platform file sets PLACE_DENSITY ?= 0.30, and the nangate45 gcd example uses CORE_UTILIZATION ?= 55 with PLACE_DENSITY_LB_ADDON = 0.20, which the flow adds to the lower-bound placement density it computes. A lower target spreads cells and leaves room for buffers and routing; a higher one packs them for shorter wires but risks hotspots.
Timing-driven and routability-driven modes#
Pure wirelength minimization treats every net the same. Two common extensions:
- Timing-driven placement gives higher weight to nets on the worst-slack paths, so the placer pulls them shorter. In OpenROAD,
-timing_drivenruns a virtualrepair_designto find slacks, then reweights nets: by default the top 10% of nets (-timing_driven_nets_percentage) get a weight that ramps up to 5x (-timing_driven_net_weight_max) for the most critical. The reweighting is triggered at overflow checkpoints (default 64% and 20%). - Routability-driven placement estimates congestion during placement and inflates cells in congested regions so the density penalty pushes neighbours away. OpenROAD uses RUDY, a fast congestion estimate, by default, with an option to use the global router instead for a more precise but slower estimate.
ORFS enables both by default (GPL_TIMING_DRIVEN and GPL_ROUTABILITY_DRIVEN both default to 1). In commercial flows the equivalents are usually on by default too; what you tune is how hard they push.
Cell padding#
Padding adds empty sites to the left and right of cells. The placer treats padded cells as wider, so local density and pin density drop. ORFS exposes CELL_PAD_IN_SITES_GLOBAL_PLACEMENT and CELL_PAD_IN_SITES_DETAIL_PLACEMENT, and OpenROAD's set_placement_padding can pad all cells, specific masters or specific instances. Padding complex, pin-dense cells such as large multiplexers or AOI/OAI gates is a common congestion fix, but global padding costs area everywhere.
Placement optimization#
Between global placement and final legalization, the flow fixes electrical problems using estimated parasitics. Clocks are still ideal at this point, so the focus is setup timing and design rule violations (DRVs); most hold fixing waits until after CTS, when real clock skew is known.
Typical operations:
- Buffering and high-fanout net repair. Long wires and high-fanout nets get buffer trees. OpenROAD's
repair_designinserts buffers to fix max slew, max capacitance and max fanout, and buffers long wires to reduce RC delay. When neither the library nor the SDC limits fanout, it uses a default of 50 load pins to build a buffer tree. Its documentation notes that placement parasitics cannot accurately predict routed parasitics, so margins (-slew_margin,-cap_margin) can be used to over-repair. - Removing synthesis buffers first. ORFS runs
remove_buffersbefore timing-driven global placement, because buffers chosen without placement information often end up in the wrong places. - Gate sizing and Vt swap. Upsize drivers on critical paths, downsize off-critical ones to recover area and leakage.
- Logic restructuring, pin swapping and cloning. Move a late-arriving signal to a faster input pin, or clone a driver so each copy serves a nearby group of loads.
For DRV background, see Design Rule Violations (DRVs) in VLSI.
Worked example B: is this a placement problem or a constraint problem? (illustrative)#
After placement optimization, a path reports −120 ps setup slack at a 1.0 ns clock. The report shows a data arrival of 1,010 ps (630 ps of cell delay including clock-to-Q, 380 ps of wire delay across 9 stages), 0 ps clock skew (ideal clocks), 50 ps uncertainty and a 60 ps setup time, so the required time is 1,000 − 50 − 60 = 890 ps and the slack is 890 − 1,010 = −120 ps.
- Wire delay is 380 ps of the 1,010 ps arrival. That is a large share for nine stages, so the cells are probably far apart.
- Plot the path. The start flop sits near an I/O pin on the left; the end flop is next to a macro on the right. The cells between them are spread across the core.
- Ask why they are far apart. If both endpoints are fixed by the floorplan, no placement effort can make the wire short. The fix is in the floorplan (move the pin or the macro) or the logic (add a pipeline stage). If the endpoints are movable, check that timing-driven placement was on and the path was among the reweighted nets.
The lesson: a large wire share on a path is a placement symptom, but the cause is often upstream.
Stage 2: Legalization#
Legalization moves each cell from its global placement position to the nearest legal location: on a row, aligned to a site, not overlapping another cell, not on a blockage, and with an orientation that matches the row's power rails. The goal is minimal displacement, because every micron moved undoes some of global placement's work.
In OpenROAD, legalization is done by the detailed placer (dpl): its detailed_placement command moves instances to legal sites on rows while minimizing displacement. Its documentation describes a negotiation-based legalizer as the default, which is slightly slower but handles dense designs, with the older diamond search (fast, linear runtime, but not able to handle dense designs) available as a legacy option. It also supports mixed-cell-height designs, fence regions and fragmented rows. A -max_displacement option limits how far a cell may move.
Legalization is also run again whenever optimization changes the netlist: after buffering, resizing, CTS buffer insertion and timing ECOs, new or bigger cells must be legalized without disturbing everything else.
Things that make legalization hard or bad:
- Density too high in a region. There is simply no free site nearby, so cells travel far and timing degrades.
- Cell-edge and spacing rules. Advanced nodes add rules about which cell edges may abut (see PODE vs CPODE), which removes candidate sites.
- Multi-height cells. Double-height flops and multi-bit flops (see Multi-Bit Flip-Flops) need two aligned free rows with the right rail order.
Stage 3: Detailed placement#
Detailed placement improves the legal placement locally while keeping it legal: swapping neighbouring cells, sliding cells within a row, moving a cell to a nearby gap, and mirroring cells so their pins face the nets they connect to. OpenROAD's improve_placement optimizes a placed design, and optimize_mirroring mirrors instances about the Y axis to reduce total HPWL. ORFS then runs check_placement -placeable to report remaining violations of movable cells.
Detailed placement moves are small, so the gains are modest but cheap: a few percent of wirelength, slightly better pin access, and fewer short local detours for the router.
Worked example C: how much does a swap save? (illustrative)#
Two cells, E and F, sit side by side in a row. E connects to a net whose other pins are all to the right; F connects to a net whose other pins are all to the left. With E on the left and F on the right, each net's bounding box has to stretch across the other cell, say 2 µm extra each, 4 µm in total. Swapping them removes that overlap: total HPWL drops by about 4 µm, no timing path gets longer and both remain legal. A detailed placer evaluates millions of moves like this.
Placement QoR: what to check before CTS#
| Check | What "good" looks like | Typical action if not |
|---|---|---|
| Legality | No overlaps, all cells on rows/sites, check_placement clean |
Find the blocked region, free sites, relegalize |
| Utilization | Close to plan, with space left for CTS buffers and hold fixing | Recover area by downsizing, reduce buffering, revisit floorplan |
| Congestion | No large hotspots in the global-route or estimated congestion map | Padding, partial blockages, lower density, move macros |
| Setup timing | WNS and TNS within what CTS and routing can recover | Fix constraints first, then timing-driven placement, floorplan changes |
| DRVs | Max transition, capacitance and fanout clean or close to clean | repair_design-style buffering and sizing |
| Cell displacement | Small average and max legalization displacement | Lower density in the hotspot, check fixed cells and blockages |
There are no universal numbers for these: acceptable WNS, utilization and congestion margins depend on the node, the library, the clock period and how aggressive later stages are. Compare against your own project's history rather than a rule of thumb from the internet.
Also look at the density map, the congestion map and a plot of the worst paths: they show problems, such as a module smeared across the die, that summary numbers hide.
Common placement problems and fixes#
- Congestion hotspot near macros or in channels. Add placement blockages (partial blockages limit density without forbidding cells), widen channels, or move macros. See Routing Congestion in VLSI and Macro Placement in VLSI.
- High-fanout nets (resets, enables, select lines). Buffer them with a proper tree, or treat them as ideal until later and synthesize them like clocks if your flow supports it.
- Logic scattered across the die. Often due to connectivity to fixed objects far apart (pins and macros), or to a module with no natural centre. Region or fence constraints can keep a module together, but use them sparingly: hard fences reduce the placer's freedom.
- Timing is fine after placement but collapses after routing. The wire RC estimate or the congestion was hiding detours. Correlate placement-stage timing against post-route timing early in the project (see Parasitic Extraction and SPEF).
Debug flowchart for placement problems#
Work top to bottom: legality first (nothing else is meaningful while cells are unplaced), then congestion and timing, then DRVs and area.
Interview questions and answers#
Q1. What are the main steps of placement? Global placement (rough positions minimizing wirelength under a density target, overlaps allowed), placement optimization (buffering, sizing, DRV and setup repair with estimated parasitics), legalization (snap to legal rows and sites with minimal displacement) and detailed placement (local swaps, shifts and mirroring that keep the placement legal).
Q2. Why is hold usually not fixed during placement? Clocks are ideal before CTS, so clock skew is unknown. Hold depends strongly on skew; fixing it now would add delay cells that may be unnecessary or wrong after CTS.
Q3. What is HPWL and why do placers use it? Half-perimeter wirelength is the half perimeter of the bounding box of a net's pins. It is cheap, smooth enough to optimize, and tracks routed wirelength well for most nets.
Q4. What is the difference between utilization and placement density? Utilization is total cell area divided by available core area, set by the floorplan. Placement (target) density is the maximum local density the global placer aims for in each bin. A design can have moderate utilization and still have local hotspots.
Q5. How does timing-driven placement work? The placer runs timing analysis with estimated wires, finds the worst-slack paths and increases the weights of their nets in the wirelength cost so those nets get shorter, re-evaluating at intervals during placement.
Q6. What does legalization do and why does displacement matter? It moves cells to legal sites without overlap. Large displacement means global placement's optimized positions were thrown away, usually because the region was too dense, and timing and wirelength suffer.
Q7. How do you fix congestion at the placement stage? Reduce local density (lower target density, partial blockages), pad pin-dense cells, enable or strengthen routability-driven placement, and fix floorplan causes such as narrow macro channels or badly placed pins.
For more short-answer practice, see our placement interview questions.
FAQ#
Is placement done before or after CTS? Before. Placement places the data-path cells and flops; CTS then builds the clock tree to those flop locations, and the placer legalizes the inserted clock buffers.
Summary#
Placement turns a floorplanned netlist into legal cell locations. Global placement minimizes weighted wirelength under a density target, with timing- and routability-driven extensions; placement optimization repairs DRVs and setup with estimated parasitics while clocks are still ideal; legalization snaps cells to rows and sites with minimal displacement; and detailed placement makes small local improvements. Check constraints and the floorplan before you start, judge the result on legality, congestion, timing, DRVs and utilization together, and fix the cause where it really lives, which is often the floorplan or the SDC rather than the placer.
References#
- OpenROAD global placement (
gpl) documentation: RePlAce/ePlace basis, Nesterov's method,global_placementoptions (-densitydefault 0.7,-overflowdefault 0.1, timing-driven and routability-driven arguments, padding): https://github.com/The-OpenROAD-Project/OpenROAD/blob/master/openroad/gpl/README.md - OpenROAD detailed placement (
dpl) documentation:detailed_placement, negotiation-based and diamond-search legalizers,set_placement_padding,filler_placement,check_placement,optimize_mirroring,improve_placement: https://github.com/The-OpenROAD-Project/OpenROAD/blob/master/openroad/dpl/README.md - OpenROAD resizer (
rsz) documentation:remove_buffers,repair_design(default 50-load fanout limit, slew and capacitance margins),repair_timing: https://github.com/The-OpenROAD-Project/OpenROAD/blob/master/openroad/rsz/README.md - OpenROAD-flow-scripts placement scripts
flow/scripts/global_place.tcl,resize.tcl,detail_place.tcl, variable definitionsflow/scripts/variables.yaml, and the nangate45 platform andgcddesignconfig.mkfiles: https://github.com/The-OpenROAD-Project/OpenROAD-flow-scripts - J. Lu et al., "ePlace: Electrostatics-Based Placement Using Fast Fourier Transform and Nesterov's Method," ACM TODAES, 2015 (linked from the OpenROAD
gpldocumentation): https://cseweb.ucsd.edu/~jlu/papers/eplace-todaes14/paper.pdf




