Chip Physical Layout (Place & Route)
Long-cycle design programs where IP, foundry, and ecosystem partnerships execute against tapeout and market windows.
This interactive experience is the shipped product itself — the same application code customers run in production, mounted read-only in your browser over a real sample journey. Not a video, not a mockup: because the demo and the product are one codebase, it can never drift from the real thing.
Inside this journey
-
Outcome Discovery
Map the buyer's tapeout constraints, most critical blocks, current P&R flow, runtime pain points, and measurable success signals.
Discovery Questions
Start with the tightest deadline
- How many weeks before your planned tapeout did the place-and-route flow start missing timing on a critical block in your most recent project?
- Tell me about the full P&R flow you run for representative blocks, from floorplan through signoff, including where you insert manual fixes or custom scripts.
- Which categories best describe the primary tools and custom layers in your current flow?
- Who on your team owns first-response triage when timing first regresses, and what role does each person play?
- Estimate how often a representative congested block requires more than two manual ECO iterations to reach signoff.
Where the tapeout actually stalls
- If a single congested partition adds four weeks, what part of your flow most amplifies that delay?
- Walk me through the last block that forced a tapeout slip or near-slip, including the block type, size, switching activity, and where timing failed.
- Which specific block characteristics tend to correlate with repeat failures in your experience?
- Who notices the issue first, and how long does it take from first detection to the start of a focused fix campaign?
- Name the block or partition that you would immediately delay tapeout for if it missed timing.
Where manual work eats your schedule
- When manual ECOs are your path to closure, what predictable costs are you accepting?
- How many person-weeks did manual ECOs and routing rework consume in your last tapeout?
- Describe the common manual steps your engineers take during an ECO cycle, and which steps are hardest to automate.
- Identify the team owning manual fixes and estimate the percent of their time consumed during crunch periods.
- If you could reduce manual ECO iterations by half, what would that save you in schedule or cost, in concrete terms?
Hidden assumptions that break the run
- What permission, data, or compute gaps would stop an evaluation before it starts?
- List the specific design artifacts we would need access to within two weeks to run a representative evaluation, and who controls each artifact.
- Identify any build or environment dependencies that require coordination across your IT or network teams.
- Estimate available bare-metal or cloud compute in core-hours the buyer can commit to the pilot, per week.
- Would you pause or cancel the evaluation if legal or data-authority approval to share constraint files cannot be obtained within 14 days?
Other paths you're weighing
- What would have to be true for you to keep the current P&R approach rather than change course?
- Select from the following alternatives you are evaluating or have evaluated recently.
- Has anyone on your team proposed solving closure internally without a vendor, and if so, what resources and timeline did they estimate?
- Name a measurable condition in your incumbent flow that would keep you from switching this cycle.
- List the internal stakeholders who must approve a vendor-led pilot, and note typical objections.
Define measurable success
- Assuming the evaluation meets your targets, what would make you sign within one week?
- What single acceptance metric would you use to decide go no-go for migration after the pilot?
- Specify your target timing margin at block-level that constitutes acceptable closure, in picoseconds, for representative blocks.
- Choose the maximum runtime per full P&R iteration you will accept during evaluation.
- State the maximum routing-related DRC violations acceptable post-optimization before you consider a run clean.
- Describe acceptable power or area tradeoffs and how you expect them reported in the evaluation deliverable.
Decision mechanics and next steps
- Suppose the pilot delivers promised convergence in two to three iterations, what internal process would accelerate adoption?
- Provide the names or roles that must sign the purchase and the timeline procurement and legal need to approve after acceptance.
- Outline the top three migration responsibilities you expect to retain, and the top three you expect the seller to own.
- In the event the pilot proves results but integrating your custom scripts requires more effort than planned, would you pause migration or accept a staged rollout?
- How soon could your team start a pilot, given a signed NDA and data authorization?
- What single unresolved technical or organizational risk would stop you from starting a pilot within your target window?
-
Solution Experience
Anchor how the seller's place-and-route approach addresses the buyer's failure modes and shortens iteration on representative scenarios.
Solution Experience
- Solution Experience Session — Place-and-Route Convergence
- Confirm the current state and its cost
- You confirm the described current state and accept the quantified schedule and engineering cost as accurate.
- Run a candidate P&R benchmark on one buyer-provided representative block and deliver a QoR comparison report (timing, iterations, runtime, power, area, DRC) before the next session.
- Map failure modes to the representative scenario
- You confirm the demonstrated workflow materially reduces iterations and manual ECOs on the representative scenario.
- Provide the representative block netlist, constraint files, current run logs, and the list of failure modes to reproduce.
- Walk through the seller's concurrent optimization on a representative run
- Confirm the acceptance metrics (timing slack targets, maximum acceptable runtime, allowed manual ECO hours, and DRC tolerance) and sign off on the benchmark schedule.
- You and the seller agree on the benchmark scope, acceptance metrics, required artifacts, and the schedule for the follow-up run.
- Prepare the execution checklist and mapping of compute and environment requirements needed to run the benchmark on the provided data.
- Compare outcomes and translate to schedule impact
- Validate this matches your needs
- Agree next evaluation scope and data handoff
- Solution Experience Session — Place-and-Route Convergence
- Solution Experience Deck
- Solution Brief
- meeting
- slides
- document
-
Solution Scope
Define which blocks, datasets, tool flow parameters, deliverables, and migration responsibilities are in scope, plus acceptance metrics (timing, power, area, DRC, runtime).
Scope Configuration
- PDK and technology-file integration
- Port physical-constraint scripts to new flow
- Floorplan and macro/block placement
- Global placement with congestion-aware optimization
- Detailed placement and legalization
- Clock tree synthesis and skew optimization
- Concurrent timing–power–routability optimization runs
- Signoff-quality routing and shielding
- DRC/LVS closure and fix generation
- Post-route extraction and STA signoff
- Automated ECO insertion and iterative fixes
- Runtime and convergence tuning for target frequency
Scope Questions
PDK and technology-file integration
- Which PDK version and technology node (for example 3nm / 5nm / 7nm) must be integrated for this engagement?
- Provide the list of technology decks you will supply (LEF, tech LEF, .lef macro files, liberty .lib, DRC deck, LVS deck, parasitic extraction rules)
- Who will host the read-access for the PDK and where (internal artifact repository, secure FTP, vendor portal)?
- Attach or state any required license servers or feature flags needed to enable the process-specific models (for example, parasitic extraction-enabled license)
- Indicate any custom process rule exceptions or proprietary layer mappings (for example custom via stacks, reserved routing layers) that differ from the base PDK
- Specify which deliverable we should produce to confirm integration (LEF/DEF parse report, .lib timing sanity report, DRC parse log)
- List any out-of-scope PDK activities we should exclude from the fixed work (for example full-cell characterization, transistor-level library re-characterization)
Port physical-constraint scripts to new flow
- Which constraint artifacts do you currently use that must be ported (SDC timing constraints, IO placement constraints, floorplan constraint files, power intent CPF/UPF)?
- List the custom SDC constructs or scripts the team relies on (false path patterns, multi-cycle path definitions, multi-corner definitions)
- Who on your team owns constraint validation and what contact should we use for SDC clarifications?
- Estimate how many constraint files and total lines of SDC we should expect to convert
- Indicate whether your power intent is in CPF, UPF, or a mix and whether retention or power-switch designs require special handling
- Provide example SDC or power-intent checks you require after porting (for example: preserved false paths, consistent clock group definitions)
- Which test harness or regression harness should we use to validate translated constraints (internal regression, provided testbench, platform CI)?
Floorplan and macro/block placement
- Which tapeout-critical blocks or macro names should be included in the scoped floorplan (provide block names or GDS grouping identifiers)?
- Specify the target die size, target core utilization, and any preallocated macro keep-out regions from the GDS or floorplan DEF
- Who will provide the initial floorplan sources (existing DEF, placement constraints, floorplan script) and in what path or repository?
- Indicate whether hard macros require re-placement, legalizing, or only boundary checks against the new LEF
- List any thermal, power-grid, or IO adjacency constraints that must be enforced during macro placement
- Provide the expected deliverable for this module (annotated DEF, updated floorplan script, placement constraint diff)
- Estimate the expected number of hard macros and soft blocks in scope for placement validation
Global placement with congestion-aware optimization
- Which representative blocks should be run through global placement to measure congestion behavior (provide block IDs or netlist names)?
- Describe any congestion metrics you currently track that we should report (e.g., routing demand per micron, overflow histogram)
- Identify whether you require layer-aware congestion targets for specific metals or via stacks
- Which placement constraints (pin access rules, keepouts, fence regions) must be preserved during global placement?
- Specify the acceptable routing resource utilization threshold after placement (for example maximum channel utilization percent)
- Who is the owner for signoff of placement results in your team and what artifact do they expect (placement DEF, congestion heatmap)?
Detailed placement and legalization
- Which pin-access or cell-shift policies must be enforced during legalization (for example no cell rotation, keep IP macro pins fixed)?
- Provide the set of standard-cell rows and row-spacing rules from the LEF that must be respected
- List any custom legalization checks you require (multi-height cell handling, IP site compatibility)
- Who will verify the post-legalization DRC-free run locally before routing starts?
- Estimate the number of cells and density (% utilization) the detailed placement flows will act on
- Specify deliverables after legalization (legalized DEF, legalization log, cell movement report)
- Indicate any preferred handling for fixed macros that overlap pre-routed power stripes or retention cells
Clock tree synthesis and skew optimization
- Which clock domains and root names in your SDC should we synthesize CTS for (list clock net names and frequencies)?
- Provide target skew and insertion-delay budgets per domain (for example max skew 50ps, insertion <200ps)
- Identify whether deskew networks, localized buffer trees, or hierarchical CTS are required for any domain
- Who owns the clock gating and clock-disable policies that must be preserved during CTS?
- List any constraints on routing or shielding for clock nets that must be enforced (for example metal layer restrictions, shielding distances)
- Specify the artifact you will accept as CTS deliverable (CTS DEF, clock netlist dump, clock-tree report)
Concurrent timing–power–routability optimization runs
- Which representative scenarios and corners should we run concurrently (timing corners, PVT corners, IR drop cases)?
- Provide the reference .lib views (max-transition, min-delay, etc.) that the multi-objective optimizer must target
- Identify constraints on power vs timing tradeoffs we should not exceed (for example max 5% power increase allowed for timing gain)
- Who will validate optimization strategy and approve changes to cell-sizing or gate-swapping recommendations?
- List the measurable QoR reports you require after each optimization run (timing report, power summary, congestion map, routability metric)
- Indicate whether you require automated rollback points and versioned DEF outputs after each optimization iteration
Signoff-quality routing and shielding
- Which routing layers and via rules from the tech LEF must be used to meet signoff routing rules?
- Specify shielding requirements for sensitive nets (clock, reset, power) and acceptable metal layers for shield insertion
- List any special routing strategies required for high-speed I/O or SerDes lanes in scoped blocks
- Who will run signoff DRC/LVS on routed nets and which rule deck should be used for pre-checks?
- Provide the expected routing deliverables (routed DEF, routing report, via usage summary)
- Indicate whether incremental routing handoffs or full-route regeneration is preferred during iterative runs
DRC/LVS closure and fix generation
- Which DRC and LVS rule decks (file names or deck versions) should we run for closure verification?
- Provide the maximum allowable DRC and LVS counts or categories that you will accept before escalating to manual fixes
- Indicate whether fixes should be automatic edit scripts, flagged fixes in a report, or a mixed approach
- Who will approve any layout edits that change macro boundaries or IP placement during DRC/LVS fixes?
- List any DRC categories that are informational-only and do not require hard closure for this evaluation
- Specify the format you require for the DRC/LVS acceptance artifact (annotated GDS diff, categorized error list, per-rule histogram)
Post-route extraction and STA signoff
- Which parasitic extraction format do you require (SPEF, RSP, CCS) and which extraction deck version should be applied?
- Provide the STA corners and clock uncertainty values that the post-route STA must use for signoff
-
Solution Evaluation
Run the agreed evaluation plan (representative blocks through a full P&R flow) and verify acceptance criteria: timing closure, power/area tradeoffs, DRC cleanliness, and runtime convergence.
- decision_readiness
- stakeholders
- current_state
- desired_state
- success_criteria
- gaps
- decision_readiness
- gaps
- current_state
- desired_state
- stakeholders
- success_criteria
- decision_readiness
- stakeholders
- desired_state
- success_criteria
- current_state
- gaps
- decision_readiness
- decision_readiness
- decision_readiness
- decision_readiness
-
Mutual Commit
Finalize commercial and legal terms, NDA/data-access authorizations, evaluation acceptance, and migration commitments for go/no-go decisions.
Agreement Modules
- Mutual Non-Disclosure Agreement (NDA)
- Order Form / Subscription Agreement
- Master Services Agreement (MSA)
- Statement of Work (SOW) — Evaluation & Migration
- Evaluation Acceptance Agreement
- Migration & Go/No-Go Commitment
- Data Access & Handling Authorization
- Data Processing Agreement (DPA)
- Service Level Agreement (SLA) for Support & Availability
- Change Order Agreement
- Payment Schedule & Invoice Terms
-
Deployment
Lock readiness facts and configuration values before execution begins.
-
Pre-Deployment Readiness
Capture concrete readiness facts the rollout depends on — compute resources, access to design data and scripts, owner assignments, and schedule constraints.
Pre-Deployment Questions
Environment and site access
- Which compute environment types are available for the evaluation (select all that apply)? (This tells us which deployment path to prepare)
- Is license server access for the seller's tool already authorized from the target environment? (so we can schedule install and smoke tests)
- If license access is planned or not yet available, provide the expected availability date or the name of the buyer contact who will approve access. (date or owner; used to schedule installer activities)
- Will the deployment team have network reachability from seller support to the following endpoints? Select all that apply. (network reachability determines VPN/NAT needs)
- If any endpoints require network change (VPN, ACLs, NAT), who is the network owner/contact for approvals? (name, role, and email preferred)
Data and configuration readiness
- Are the representative block datasets for evaluation staged and approved for transfer to the evaluation environment? (This determines whether we can start block-level runs)
- If some or none are staged, list the block identifiers or provide the planned staging date. (block IDs or date; helps schedule data movement)
- Are constraint files, P&R scripts, and the buyer's standard build recipes documented and owned as a single source of truth? (we need an authoritative script set to reproduce runs)
- Who is the owner of the CAD scripts and constraint source of truth? (name, role — used to coordinate migration of build artifacts)
- Which flow variants are in scope for the initial rollout? (select all that apply — drives run recipes and resource sizing)
People, roles, and ownership
- Who is the buyer-side deployment owner accountable for go/no-go cutover decisions? (name and role — this is our primary decision contact)
- Who will own environment & network approvals during deployment? (name and role — needed to clear integrations quickly)
- Who owns migration of CAD scripts, constraints, and handwritten ECO processes? (name and role — needed to resolve script ambiguities during migration)
- Are escalation contacts and on-call coverage defined for the rollout period? (so we can agree SLAs for critical issues)
- If escalation/on-call is partial or not defined, which roles remain unassigned? (list roles — e.g., network owner, CAD lead, build engineer)
Timing, constraints, and compliance
- What is the target date window to begin the first full integration run in the deployment environment? (date or date range — used to build the schedule)
- Are there tapeout blackout windows, freeze periods, or maintenance windows during which tool changes or data transfers are prohibited? (these windows constrain our run cadence)
- If blackout/freeze windows exist, provide the date ranges or the team who will supply them. (date ranges or owner — required to finalize the cutover plan)
- Are there export control, ITAR, or other compliance restrictions that limit data movement or seller personnel access? (so we can determine allowed deployment options)
- If restrictions apply or are unknown, who is the compliance owner we should coordinate with? (name and role)
- Do you require a phased rollout (pilot site(s) before full deployment) or a single-site cutover? (this determines staging and training cadence)
- If phased rollout, list the pilot site(s) or scope to be used first. (site names or scope; used to size resources and schedule training)
-
Configuration Details
Lock exact configuration values the deployment team will use — script mappings, flow parameters, environment settings, and integration credentials.
Configuration Details
ENVIRONMENTS & ENDPOINTS
- Enter the deployment environment name (exact string the deployment build will use; example: "prod-3nm-pnr").
- Enter the P&R compute cluster endpoint URL (format: https://... — exact hostname or load‑balancer the build will call). This value is consumed verbatim by the deployment build.
OPTIONS & FEATURES
- Select which optional product modules to enable for this deployment (the deployment build will enable only the selected modules). Default behavior: "Concurrent multi-objective optimizer (core)" is enabled.
PIPELINE & FLOW PARAMETERS
- Enter the target clock frequency for the representative evaluation (numeric, MHz). The deployment build uses this value in timing and optimization passes.
SCRIPT & FILE MAPPINGS
- Enter the exact path or filename for the P&R entry script the build will invoke (format example: /repo/path/run_pnr.tcl). The string you enter is used verbatim by the build orchestration.
- Enter the exact path to the SDC/constraint file the build will use (format example: /mnt/design/top_constraints.sdc). Provide the single file path the build should mount/read.
INTEGRATIONS & ACCESS (NON-SECRET IDENTIFIERS)
- Enter the key NAME in your secrets manager where deployment secrets will be stored (do NOT paste the secret value; example: "pnr-deploy-key"). The deployment build will reference this key NAME to retrieve credentials.
- Select the role that owns the integration credential (the person/role the deployment team will contact to arrange secret provision). This identifies the owner — we will not request the secret here.
- Select the secure channel you will use to hand off secrets at deployment kickoff (the deployment plan requires the handoff method; no secrets are collected on this sheet).
-
Deployment
Execute migration and rollout: integrate the toolchain, run full evaluations at scale, resolve escalations, and transition operations to the buyer's team.
-
-
Success
Confirm outcomes against acceptance criteria, capture lessons learned, and maintain a shared channel for issues and enhancement requests.
Success Reviews
- Go-live Health Check (weeks 1-4)
- First Measurement, Early KPI Review (weeks 4-10)
- Operational Convergence Review (90-120 days post go-live)
- Quarterly Success Review (ongoing)
Issues & Enhancements
- Refresh training materials and schedule enablement sessions for any teams identified with proficiency gaps.
- Publish the incumbent decommission or archive plan with evidence of data migration and access changes.
- Aggregate outcome presentation across representative blocks
- Confirm timing closure rate and median iterations to convergence are at acceptable levels or have a funded remediation plan tied to Solution Evaluation targets.
- Agree remediation or escalation plans for all high-severity production issues with target resolution windows.
- Produce a short lessons-learned summary that will be used to update operational runbooks and onboarding materials.
- Publish the consolidated outcomes report with per-block trends and lessons learned.
- Create a prioritized enhancement request list with brief scope and acceptance criteria.
- Schedule targeted technical detailed review sessions for each unresolved high-severity item.
- Quarterly operational metrics and trend review
- Validate quarterly trends for average P&R runtime and open high-severity issues and confirm they are stable or improving versus Solution Evaluation targets.
- Agree the prioritized enhancement list for the next quarter and handoff of execution to the delivery backlog.
- Confirm owners and target dates for remaining high-severity issues to ensure continued progress.
- Update the shared dashboard with current quarter metrics and a brief narrative explaining any deviations from targets.
- Publish the next-quarter prioritized enhancement and support backlog with expected delivery windows.
- Re-confirm scope owners and success criteria custodian
- Confirm the deployment checklist is complete and evidence for each item is available in the shared workspace.
- Identify any critical blockers preventing production runs and agree remediation actions and target dates.
- Ensure every acceptance criterion in Solution Evaluation has an assigned owner for post-deployment tracking.
- Provide the completed deployment validation checklist with links to environment snapshots and run logs.
- Publish a short report of initial run outcomes and any immediate errors observed for async review.
- Create remediation tickets for any critical blockers with target resolution dates.
- Present first measurements vs Solution Evaluation targets
- Determine whether median negative slack and average P&R runtime per representative block are on track to meet Solution Evaluation targets or require remediation.
- Document root causes for the top gaps and a specific remediation plan with milestones and target dates.
- Confirm incumbent tool status is either fully decommissioned or retained read-only with an archive and a plan to eliminate silent fallback work.
- Deliver a per-block timing slack and runtime breakdown with traceable links to the runs used for analysis.
- Produce a remediation plan for the top three root causes with concrete parameter changes or process steps and target completion dates.
- Review manual ECO workload and iteration counts
- Enhancement request backlog review and prioritization
- Deployment and migration validation
- Root-cause diagnosis for any metric gaps
- Surface persistent production issues and escalations
- Early adoption signals and usage patterns
- Open issues burn-down and owner updates
- Incumbent system wind-down status
- Blockers, open issues, and temporary workarounds
- Agree corrective actions and timeline to stable operations
- Adoption and training needs check
- Capture lessons learned and update runbooks
- Agree immediate remediation actions
- Agree next operational adjustments and enhancement requests
- Meeting efficiency check