Static Timing Analysis Fundamentals
Static Timing vs. Dynamic Simulation
Static Timing Analysis (STA) is a static verification technique that exhaustively proves that all synchronous timing constraints are met across all legal signal paths, operating modes, and process corners without applying functional input vectors or testbenches. Dynamic gate-level simulation (GLS) tests only a tiny fraction of functional state-space trajectories ($< 0.01\%$), whereas STA guarantees $100\%$ path coverage across billions of potential state transitions.
| Characteristic | Static Timing Analysis (STA) | Dynamic Simulation (GLS) |
|---|---|---|
| Coverage | 100% exhaustive across all paths and corners. | Limited strictly to exercised testbench vectors. |
| Execution Speed | Minutes to hours for 500M+ gate SoCs. | Weeks to months (computationally prohibitive). |
| Input Vectors | None required; reads netlist + SDC + .lib + SPEF. | Requires complex VCD/FSDB stimulus testbenches. |
| Signoff Authority | Industry-standard golden signoff (PrimeTime / Tempus). | Secondary functional sanity check (X-propagation). |
Timing Paths: Startpoints, Endpoints, and Types
Every static timing path is bounded by a valid Startpoint and Endpoint:
- Startpoints: Primary input ports (`in_data[*]`) or clock pins of sequential cells (Flip-Flop `CLK`, Latch `G`). Data launches on the active clock edge.
- Endpoints: Sequential data pins (Flip-Flop `D`, Latch `D`), clock-gating enable pins (`ICG/E`), or primary output ports (`out_data[*]`). Data is captured and held stable.
| Path Classification | Startpoint | Endpoint | Governing SDC Constraints |
|---|---|---|---|
| Reg-to-Reg | Launch FF Clock Pin (`CLK`) | Capture FF Data Pin (`D`) | create_clock, set_clock_uncertainty |
| In-to-Reg | Top-Level Input Port | Capture FF Data Pin (`D`) | set_input_delay, set_driving_cell |
| Reg-to-Out | Launch FF Clock Pin (`CLK`) | Top-Level Output Port | set_output_delay, set_load |
| In-to-Out (Feedthrough) | Top-Level Input Port | Top-Level Output Port | set_input_delay + set_output_delay / set_max_delay |
Slack, WNS, and TNS
Slack ($S$) is the difference between Data Required Time and Data Arrival Time:
- Setup Slack: $S_{ ext{setup}} = T_{ ext{required}} - T_{ ext{arrival}}$. Positive slack indicates timing is met; negative slack indicates timing violation.
- Hold Slack: $S_{ ext{hold}} = T_{ ext{arrival}} - T_{ ext{required}}$. Positive slack indicates data remained stable long enough.
- Worst Negative Slack (WNS): The single worst negative slack value among all violating paths in a path group or design. Represents the absolute clock period deficit.
- Total Negative Slack (TNS): The scalar sum of negative slack across all violating endpoints. Reflects the total magnitude of timing debt across the chip.
Setup Timing Analysis: Mechanics, Decomposition & Diagnostics
The Mathematical Setup Constraint (Max Delay Check)
Setup timing ensures that data launched from register $A$ propagates through combinational logic and interconnect, arriving at register $B$ before the capture clock edge, and remaining stable for at least the library setup time ($T_{ ext{setup}}$):
Decomposing Negative Slack: Cell Delay vs. Net Delay
When an engineer inspects a timing report with negative slack, the first diagnostic step is calculating the Cell-to-Net Delay Ratio:
| Net Delay % | Cell Delay % | Primary Physical Root Cause | Recommended Engineering Action |
|---|---|---|---|
| > 45% | < 55% | Interconnect congestion, long wire detours, layer promotion failure, high coupling cap. | Insert repeater buffers, promote critical net to top thick metals (M6/M7), add physical placement bounds. |
| < 30% | > 70% | Excessive logic depth, weak gate drive strength, high fanin cascade, standard-Vt or high-Vt cells. | Upsize driving cells, swap critical gates to LVT/ULVT, restructure Boolean logic cones in RTL. |
| 30% – 45% | 55% – 70% | Balanced path with cascading transition degradation or high fanout net driving intermediate gates. | Buffer high-fanout net, clean up max-transition violations, optimize CTS clock latency. |
Impact of Slew (Transition Time) and Capacitance
Standard cell delay is characterized in Liberty (.lib) files as a 2D non-linear delay lookup table indexed by Input Slew ($T_{ ext{trans}}$) and Output Load Capacitance ($C_{ ext{load}}$):
$$T_{ ext{cell}} = f(T_{ ext{in\_slew}}, C_{ ext{out\_load}})$$
A single weak buffer driving a high-capacitance net causes its output slew to degrade (e.g. from 40 ps to 180 ps). This slow transition cascades into the next 4 logic stages, multiplying gate delays by up to $3 imes$. Claude scans the path for pins with transition times exceeding 80–100 ps and flags them as driver starvation bottlenecks.
# PrimeTime: Dissect Critical Setup Path with Slew, Net, and Cap Details
report_timing -delay_type max -max_paths 1 -input_pins -nets -capacitance -transition_time -significant_digits 4 -crosstalk_delta
Hold Timing Analysis: Short Paths, Skew & Delay Buffering
The Mathematical Hold Constraint (Min Delay Check)
Unlike setup timing (which checks if data arrives before the next clock edge), hold timing verifies that data launched by active clock edge $N$ does not race through fast logic and overwrite data captured by the same clock edge $N$ at the receiving register:
Why Fast/Cold Corners Dominate Hold Violations
Hold constraints do not depend on clock period ($T_{ ext{period}}$). Therefore, hold violations cannot be fixed by lowering clock frequency in the lab! A chip with a hold violation on silicon is permanently dead.
Hold violations peak at the Fast-Fast-Global (FFG) corner at maximum operating voltage (e.g. 0.85V) and extreme temperatures ($-40^\circ ext{C}$ or $125^\circ ext{C}$), where transistor channel conductances are highest and parasitic wire delays are lowest.
Clock Skew: The Primary Amplifier of Hold Failures
In the hold equation, positive clock skew ($\Delta T_{ ext{skew}} = T_{ ext{capture}} - T_{ ext{launch}} > 0$) directly increases Data Required Time, stealing margin from the data path. If capture latency is 400 ps and launch latency is 250 ps ($\Delta T_{ ext{skew}} = +150\, ext{ps}$), and $T_{ ext{hold}} = 30\, ext{ps}$, data must take at least 180 ps to arrive. On a shift register with 0 combinational gates ($T_{ ext{CK} o ext{Q}} pprox 70\, ext{ps}$), a severe hold violation of $-110\, ext{ps}$ is guaranteed.
Hold Buffer Insertion Strategy & Side Effects
| Consideration | Best Practice Rule | Engineering Risk / Side Effect |
|---|---|---|
| Buffer Selection | Use dedicated non-inverting delay cells (`DELAY_X1`, `DELAY_X2`) or clock buffers (`CLKBUF_X1`). | Avoid high-drive inverters that introduce asymmetric rise/fall hold skews. |
| Buffer Placement | Place delay buffers physically adjacent to the capture flip-flop $D$ pin. | Placing near launch pin can delay branches feeding other setup-critical endpoints. |
| Setup Margin Safety | Ensure target path has setup margin $> T_{ ext{inserted\_delay}} + 40\, ext{ps}$ at worst slow corner. | Fixing hold blindly causes setup timing regressions on common functional paths. |
| Dynamic Power & Area | Bundle multiple parallel short paths into multi-bit delay cells where supported. | Inserting thousands of hold buffers consumes routing tracks and increases leakage. |
Timing Report Analysis: PrimeTime & Tempus Full Clock Expansion
Anatomy of a Full Clock-Expanded Timing Path
A production timing report generated by Synopsys PrimeTime or Cadence Tempus contains three distinct functional segments: Launch Clock Path, Data Path, and Capture Clock Path. Below is an illustrative example of an annotated PrimeTime setup report:
****************************************
Report : timing
-path full_clock_expanded
-delay_type max
-max_paths 1
Design : aes_cipher_top
Scenario: func_ssg_0p65v_m40c (Slow-Slow-Global, 0.65V, -40C)
****************************************
Startpoint: u_core/u_key_expand/r_round_key_reg_127/CLK (DFCNQD1)
Endpoint: u_core/u_sub_bytes/r_state_out_reg_63/D (DFCNQD1)
Path Group: CLK_1GHz
Path Type: max (setup check)
Point Cap Trans Incr Path
-----------------------------------------------------------------------------------
# ═══════════ LAUNCH CLOCK NETWORK ═══════════
clock CLK_1GHz (rise edge) 0.0000 0.0000
clock source latency 0.1500 0.1500
u_clock_tree/U_clk_buf_root/Y (CLKBUF_X16) 0.045 0.038 0.0650 0.2150 r
u_clock_tree/U_clk_buf_b1/Y (CLKBUF_X8) 0.028 0.042 0.0820 0.2970 r
u_clock_tree/U_clk_buf_leaf/Y (CLKBUF_X4) 0.014 0.048 0.0780 0.3750 r
u_core/u_key_expand/r_round_key_reg_127/CLK 0.0000 0.3750 r
# ═══════════ DATA PATH PROPAGATION ═══════════
u_core/u_key_expand/r_round_key_reg_127/Q (DFCNQD1) 0.052 0.1420 0.5170 f
u_core/u_key_expand/n_key_127 (net) 0.024 0.052 0.0860 0.6030 f
u_core/u_sub_bytes/U_sbox_lut_0/Y (NAND2_X1) 0.012 0.068 0.0980 0.7010 r
u_core/u_sub_bytes/n_sbox_stage1 (net) 0.035 0.074 0.1120 0.8130 r <-- High net delay
u_core/u_sub_bytes/U_mix_col_add/Y (XOR3_X1) 0.008 0.092 0.1650 0.9780 f <-- High transition
... [14 intermediate logic gates omitted] ...
u_core/u_sub_bytes/U_final_mux/Y (MUX2_X1) 0.006 0.045 0.0950 1.5200 r
u_core/u_sub_bytes/r_state_out_reg_63/D (net) 0.008 0.048 0.0280 1.5480 r
data arrival time 1.5480
# ═══════════ CAPTURE CLOCK NETWORK ═══════════
clock CLK_1GHz (rise edge) 1.0000 1.0000
clock source latency 0.1500 1.1500
u_clock_tree/U_clk_buf_root/Y (CLKBUF_X16) 0.045 0.038 0.0650 1.2150 r
u_clock_tree/U_clk_buf_b2/Y (CLKBUF_X8) 0.031 0.044 0.0890 1.3040 r
u_clock_tree/U_clk_buf_leaf2/Y (CLKBUF_X4) 0.016 0.050 0.0840 1.3880 r
u_core/u_sub_bytes/r_state_out_reg_63/CLK 0.0000 1.3880 r
clock reconvergence pessimism removal (CPPR) 0.0220 1.4100
clock uncertainty -0.0500 1.3600
library setup time -0.0420 1.3180
data required time 1.3180
-----------------------------------------------------------------------------------
slack (VIOLATED) -0.2300
How Claude Analyzes This Path
- Arrival Breakdown: Total arrival = 1.548 ns. Launch clock latency = 0.375 ns. True data path delay = $1.548 - 0.375 = 1.173\, ext{ns}$.
- Required Breakdown: Clock period = 1.000 ns (1 GHz). Capture clock latency = 0.388 ns. Skew = $+0.013\, ext{ns}$. Uncertainty = 0.050 ns. Setup requirement = 0.042 ns. CPPR credit = +0.022 ns. Required = 1.318 ns.
- Slack Deficit: $1.318 - 1.548 = -0.230\, ext{ns}$ (VIOLATED).
- Bottlenecks Identified:
• Netn_sbox_stage1has 112 ps delay ($> 9.5\%$ of entire data path alone).
• GateXOR3_X1has input transition of 74 ps and adds 165 ps delay due to weak $X1$ drive strength.
• Prescribed ECO: UpsizeXOR3_X1toXOR3_X4; insert repeater buffer onn_sbox_stage1. Estimated slack recovery: $+160\, ext{ps}$.
SDC Constraint Analysis: Syntax, Pitfalls & Automated Review
Core SDC Commands and Invariant Signoff Rules
Synopsys Design Constraints (SDC) define the physical clock environment, external board interfaces, and intentional timing exceptions. A bug in SDC either causes an EDA tool to optimize phantom paths (wasting power/area) or masks real silicon violations (causing chip death).
| SDC Command | Primary Function | Critical Verification Check |
|---|---|---|
create_clock |
Defines master clock at primary input pin or internal oscillator pin. | Explicit waveform: -period 1.0 -waveform {0.0 0.5}. Never leave waveform default unless 50% duty cycle is intended. |
create_generated_clock |
Defines divided, multiplied, or inverted clock derived from master. | Must include -source pointing to physical pin, and explicit -divide_by or -multiply_by. |
set_input_delay |
Specifies external board trace delay from external launch clock edge. | Always specify both -max (setup budget) and -min (hold budget). |
set_output_delay |
Specifies external board setup/hold requirement outside the chip. | Ensure reference clock is synchronous to the interface domain or use virtual clock. |
set_clock_uncertainty |
Reserves timing margin for PLL jitter, duty-cycle distortion, and OCV. | Pre-CTS includes clock jitter + tree skew; Post-CTS includes jitter only (skew is propagated). |
set_false_path |
Instructs STA tool to completely ignore timing between specified pins. | Strictly for asynchronous resets or static test modes. Never apply to active functional paths to eliminate violations! |
set_multicycle_path |
Relaxes setup check by $N$ clock cycles for multi-cycle arithmetic logic. | Mandatory rule: set_multicycle_path N -setup must be paired with set_multicycle_path (N-1) -hold! |
set_clock_groups |
Declares clock domains asynchronous, exclusive, or logically independent. | Verify sub-clocks derived from the same PLL are not accidentally cut with -asynchronous. |
The Classic Multicycle Path Hold Trap
When an engineer writes:
set_multicycle_path 2 -setup -from [get_pins u_fsm/reg/Q] -to [get_pins u_alu/reg/D]
The tool moves the setup check to edge 2. However, by default, the hold check remains anchored to one cycle before the setup check (edge 1)! This forces the data to take at least 1 full clock cycle of delay, creating massive hold violations.
# The Invariant SDC Pair for 2-Cycle Multicycle Path
set_multicycle_path 2 -setup -from [get_pins u_fsm/state_reg*/Q] -to [get_pins u_mult/acc_reg*/D]
set_multicycle_path 1 -hold -from [get_pins u_fsm/state_reg*/Q] -to [get_pins u_mult/acc_reg*/D]
Clock and Timing Analysis: Skew, CPPR, Gating & Resets
Clock Network Dynamics: Latency, Skew & Common Path Pessimism
The clock distribution network delivers clock pulses to every sequential storage element in the SoC. In deep sub-micron FinFET designs, clock tree propagation delay (latency) can exceed several clock cycles.
Clock Common Path Pessimism Removal (CPPR / CRPR)
Under On-Chip Variation (OCV), STA tools apply late derate factors ($1 + \delta$) to the launch clock path and early derate factors ($1 - \delta$) to the capture clock path. However, for register pairs sharing common clock tree buffers (from the clock root down to the branch divergence point), a physical buffer cannot simultaneously be fast for capture and slow for launch at the exact same instant in time!
set_app_var timing_remove_clock_reconvergence_pessimism true
Clock Gating Checks (Integrated Clock Gating - ICG)
To eliminate dynamic clock switching power in idle modules, Integrated Clock Gating (ICG) cells gate the clock. A standard active-high ICG consists of a negative-edge latch feeding an AND gate:
- ICG Setup Check: The enable signal ($E$) must arrive and set up at the latch input before the clock transitions low ($T_{ ext{clk}} = 0$). If $E$ toggles while the clock is high, a truncated clock glitch is transmitted to downstream registers.
- ICG Hold Check: The enable signal must remain stable for the required hold time after the falling edge of the clock.
Recovery and Removal: Asynchronous Reset Timing
| Check | Definition | Analogy | Failure Result |
|---|---|---|---|
| Recovery ($T_{ ext{rec}}$) | Minimum time asynchronous reset deassertion must precede the active clock edge. | Setup check on reset pin. | Flip-flop enters metastable state; unknown reset exit state across registers. |
| Removal ($T_{ ext{rem}}$) | Minimum time asynchronous reset must remain asserted after the active clock edge. | Hold check on reset pin. | Register deasserts reset too early, capturing illegal combinational state. |
Timing Closure: Systematic Optimization, Sizing & ECO Workflows
Systematic Timing Closure Hierarchy
Timing closure is the methodical convergence of WNS and TNS to zero across all signoff scenarios. Rather than randomly running automated ECO tools, an expert STA engineer applies precision interventions in order of increasing risk and cost:
| Optimization Tactic | Physical Mechanism | Primary Benefit | Design Side Effect & Risk |
|---|---|---|---|
| Vt Swapping (LVT/ULVT) | Modifies transistor threshold implant without changing cell footprint or placement. | 15%–30% cell delay reduction with zero physical routing disturbance. | Sub-threshold leakage power increases exponentially ($10 imes$ higher for ULVT). |
| Driver Upsizing (e.g. X1 → X4) | Increases transistor channel width to lower driving resistance. | Sharpens output transition and reduces cell internal delay under load. | Increases input pin capacitance seen by the preceding logic stage. |
| Buffer Insertion | Breaks long distributed RC interconnects into shorter, linear delay segments. | Reduces total net delay ($T_{ ext{net}} \propto L^2 o rac{L^2}{N}$). | Requires legal placement site; risks local cell congestion. |
| Pin Swapping | Swaps logically equivalent input pins on multi-input gates (e.g., NAND3 A vs C). | Assigns critical signal to internal pin with fastest internal path to output. | Zero power or area cost; verified automatically by Formality/LEC. |
| Useful Skew Scheduling | Intentionally delays capture clock on setup-critical endpoints using CTS latency. | Borrow cycle time from subsequent non-critical downstream pipeline stages. | Eats into hold margin on the same register; must be bounded strictly. |
Before-and-After Timing Comparison Table
Whenever Claude generates an ECO recommendation script, it tabulates the expected delta metrics:
| Path Identifier | Baseline Slack | Proposed Intervention | Estimated Delta | Post-ECO Slack | Hold Margin Status |
|---|---|---|---|---|---|
u_alu/r_add_reg_63/D |
-240 ps | Upsize U_fa31 to X4 + Swap to LVT |
+190 ps | -50 ps | Hold slack safe (+85 ps at FFG) |
u_mmu/r_pt_reg_15/D |
-85 ps | Insert repeater BUF_X8 on net n_mmu_addr |
+115 ps | +30 ps (MET) | Hold slack safe (+110 ps at FFG) |
u_dma/r_desc_reg_0/D |
-42 ps | Swap MUX2_X1 to MUX2_X2_LVT |
+55 ps | +13 ps (MET) | Hold slack safe (+60 ps at FFG) |
Advanced STA: OCV, AOCV, POCV/LVF, Crosstalk & Temperature Inversion
Evolution of Variation Modeling: From Flat OCV to POCV / LVF
As process geometries scaled below 16nm FinFET into 5nm/3nm Gate-All-Around (GAA), random microscopic variations — such as Random Dopant Fluctuation (RDF), line-edge roughness (LER), and work-function variation — made classical flat margin derating obsolete.
| Variation Paradigm | Mathematical Principle | Pessimism Level | Applicable Nodes |
|---|---|---|---|
| Flat OCV | Applies uniform global derate (e.g. Late $+8\%$, Early $-8\%$) to every cell. | Extreme pessimism on deep paths; causes over-design. | Legacy planar nodes (> 40nm). |
| AOCV (Stage-Based) | Derate factor scales down as path logic depth increases ($ ext{Derate} \propto rac{1}{\sqrt{N}}$). | Moderate; accounts for statistical cancellation of independent cell variations. | Mature FinFET nodes (28nm – 16nm). |
| POCV / LVF | Models delay as nominal plus statistical sigma ($T_{ ext{cell}} = \mu \pm 3\sigma$). | Physically realistic; captures asymmetric Gaussian and non-Gaussian tails. | Advanced FinFET / GAA (7nm, 5nm, 3nm, Intel 18A). |
Signal Integrity (SI) & Crosstalk Delay (Miller Effect)
When two adjacent parallel metal wires run alongside each other, capacitive coupling ($C_c$) accounts for up to 75% of total wire capacitance. The dynamic switching relationship between the Aggressor net and Victim net alters delay dramatically:
- Opposite-Direction Switching (Setup Penalty): If victim net falls ($1 o 0$) while aggressor rises ($0 o 1$), voltage delta across $C_c$ is $2V_{DD}$. By the Miller effect, effective capacitance doubles ($C_{ ext{eff}} pprox C_{ ext{ground}} + 2C_c$), significantly slowing signal transition and worsening setup slack.
- Same-Direction Switching (Hold Penalty): If both nets switch simultaneously in the same direction, voltage delta across $C_c$ is $0V$. Effective capacitance drops ($C_{ ext{eff}} pprox C_{ ext{ground}}$), accelerating transition and creating unexpected hold violations.
Temperature Inversion Phenomenon
In legacy planar CMOS, cells are always slowest at high temperatures ($125^\circ ext{C}$) due to reduced carrier mobility ($\mu \propto T^{-1.5}$). However, in FinFET nodes operating at ultra-low supply voltages ($V_{DD} \le 0.75\, ext{V}$), threshold voltage reduction ($V_{ ext{th}}$ decreases as temperature drops) dominates over carrier mobility.
Timing Report Automation: Python Parsers & PrimeTime Tcl Pipelines
Automating Multi-Corner STA Triage
Modern ASIC projects execute timing analysis across 30+ MMMC scenarios, generating hundreds of gigabytes of text reports. Claude assists STA engineers in developing automated Python and Tcl pipelines to parse, summarize, and correlate violations across runs.
import re
import csv
import sys
def parse_sta_timing_report(report_path, output_csv="timing_summary.csv"):
with open(report_path, 'r', encoding='utf-8') as f:
content = f.read()
# Split report into individual timing paths
paths = content.split("Startpoint:")
parsed_records = []
for path_str in paths[1:]:
full_path = "Startpoint:" + path_str
startpoint = re.search(r"Startpoint:\s+([^\s\(\)]+)", full_path)
endpoint = re.search(r"Endpoint:\s+([^\s\(\)]+)", full_path)
path_group = re.search(r"Path Group:\s+([^\s]+)", full_path)
path_type = re.search(r"Path Type:\s+([^\s]+)", full_path)
slack_m = re.search(r"slack\s+\((VIOLATED|MET)\)\s+([-\d\.]+)", full_path)
# Calculate cell vs net delay components
net_delays = [float(x) for x in re.findall(r"\(net[^\)]*\)\s+([\d\.]+)", full_path)]
total_net = sum(net_delays)
arrival_m = re.search(r"data arrival time\s+([\d\.]+)", full_path)
if startpoint and endpoint and slack_m:
s_name = startpoint.group(1)
e_name = endpoint.group(1)
p_group = path_group.group(1) if path_group else "UNKNOWN"
p_type = path_type.group(1) if path_type else "max"
status = slack_m.group(1)
slack = float(slack_m.group(2))
t_arr = float(arrival_m.group(1)) if arrival_m else 1.0
net_pct = (total_net / t_arr) * 100 if t_arr > 0 else 0.0
parsed_records.append({
"Startpoint": s_name,
"Endpoint": e_name,
"PathGroup": p_group,
"Type": p_type,
"Status": status,
"Slack_ns": slack,
"NetDelay_ns": round(total_net, 4),
"NetDelay_Pct": round(net_pct, 1),
"Diagnosis": "Net Detour / Congestion" if net_pct > 45 else "Logic Depth / Sizing"
})
# Export to CSV
if parsed_records:
keys = parsed_records[0].keys()
with open(output_csv, 'w', newline='', encoding='utf-8') as f:
dict_writer = csv.DictWriter(f, fieldnames=keys)
dict_writer.writeheader()
dict_writer.writerows(parsed_records)
print(f"Successfully parsed {len(parsed_records)} paths to {output_csv}")
else:
print("No valid timing paths found in report.")
if __name__ == "__main__":
if len(sys.argv) > 1:
parse_sta_timing_report(sys.argv[1])
else:
print("Usage: python parse_sta_report.py ")
Timing Debugging Scenarios with Claude: Real-World Investigations
Scenario 1: Negative Setup Slack on High-Fanout ALU Control Net
Evidence Presented: PrimeTime report shows -215 ps slack on 32-bit ALU carry path. Logic depth is 14 levels. Net n_alu_op_sel has a fanout of 48 with net delay of 280 ps and transition time of 165 ps.
Claude Diagnostic Reasoning: The logic depth itself is within target bounds, but the driver of n_alu_op_sel is a minimum-drive cell (INV_X1) struggling to charge the gate capacitances of 48 standard cells. Slew degradation accounts for over 180 ps of excess gate delay.
Prescribed Solution: Build a balanced buffer tree using insert_buffer with a fanout limit of 8 (e.g. BUF_X8 feeding 6 BUF_X4 cells) or upsize driver to INV_X16. Slack recovers by +190 ps.
Scenario 2: Negative Hold Slack on Scan Register Chain Post-CTS
Evidence Presented: Post-CTS min-delay report reveals -95 ps hold slack between r_scan_ff_0 and r_scan_ff_1. Path has 0 combinational gates ($T_{ ext{CK} o ext{Q}} = 85\, ext{ps}$). Clock skew between registers is $+140\, ext{ps}$.
Claude Diagnostic Reasoning: The registers are logically adjacent in the scan chain but physically placed 250 μm apart across different clock tree branch buffers, creating 140 ps of positive clock skew that overwhelms the 85 ps propagation delay.
Prescribed Solution: Reorder the scan chain based on physical flip-flop locations (Innovus scanReorder or ICC2 reorder_scan_chains) or insert two DELAY_X2 hold buffers near the capture register $D$ pin.
Scenario 3: Unexpected Clock Skew across Core Partitions
Evidence Presented: CCOpt skew report shows 380 ps global skew between CPU core and Crypto co-processor (target: < 100 ps).
Claude Diagnostic Reasoning: Inspection of clock trunk routing shows the clock net feeding the crypto engine was forced to detour around a large multi-channel DDR PHY hard macro on lower metal layers (M3/M4), accumulating massive wire resistance ($R_{ ext{wire}}$).
Prescribed Solution: Promote clock trunk nets to top thick metals (M6/M7) with a 2W2S non-default routing rule (NDR) and apply target insertion delay constraints to force balanced CTS synthesis.
15 Reusable Claude Code Skills for STA Engineers
Claude Code skills are modular, version-controlled markdown packages located in your ASIC repository's .claude/skills/<skill-name>/SKILL.md directory. When placed in your workspace, Claude dynamically activates the exact skill matching your timing task — enforcing strict signoff formats, cell-to-net delay calculations, and validation checklists without cluttering your global instructions.
SKILL.md files pre-structured for immediate deployment in your ASIC workspace.---
name: sta-report-analyzer
description: Parses full clock-expanded PrimeTime and Tempus STA reports to break down data arrival, required time, cell delay vs net delay, and identify the root cause of timing violations.
---
# STA Report Analyzer Skill
## Purpose
Performs deep structural dissection of Synopsys PrimeTime or Cadence Tempus timing reports (`report_timing -significant_digits 4 -net -capacitance -transition_time -input_pins`), separating launch clock latency, CK-to-Q delay, combinational logic delay, interconnect RC delay, capture clock latency, and clock uncertainty.
## When to Activate
Activate when evaluating any `.tarpt` or `.rpt` timing path with negative slack, or when conducting post-synthesis, post-CTS, or post-route timing reviews.
## Required Input Files
- Detailed path report (`report_timing -delay_type max/min -max_paths 1 -input_pins -nets -capacitance -transition_time`)
- Standard cell library PVT corner context (e.g., SSG 0.65V -40C or FFG 0.85V 125C)
- SDC clock frequency and clock uncertainty definitions
## Step-by-Step Analysis Workflow
1. **Header & Context Verification:**
- Extract Startpoint, Endpoint, Path Group, Path Type (max/min), and Corner.
- Verify whether the path is register-to-register, input-to-register, register-to-output, or feedthrough.
2. **Clock Tree Breakdown:**
- Calculate Launch Clock Latency ($T_{\text{launch}}$) and Capture Clock Latency ($T_{\text{capture}}$).
- Compute Clock Skew ($\Delta T_{\text{skew}} = T_{\text{capture}} - T_{\text{launch}}$ for setup; opposite for hold).
- Check Clock Uncertainty ($T_{\text{uncert}}$) and CPPR/CRPR credit.
3. **Data Path Delay Decomposition:**
- Separate Launch Flip-Flop $T_{\text{CK}\to\text{Q}}$.
- Sum combinational cell delays ($\sum T_{\text{cell}}$).
- Sum interconnect net delays ($\sum T_{\text{net}}$).
- Calculate **Cell-to-Net Delay Ratio**: $\frac{\sum T_{\text{net}}}{T_{\text{datapath}}} \times 100\%$.
4. **Bottleneck Cell & Net Pinpointing:**
- Identify nets with excessive transition time ($T_{\text{trans}} > 100\,\text{ps}$) or high capacitive loading ($C_{\text{load}} > 30\,\text{fF}$).
- Flag high-fanout nets ($\text{Fanout} > 16$) or physical placement detours.
- Flag weak drive strength cells (e.g., `_X1` or `_X0.5`) in the critical logic cone.
## Example Input
```text
Startpoint: u_core/u_alu/r_operand_a_reg_15/CLK (DFCNQD1)
Endpoint: u_core/u_alu/r_result_reg_31/D (DFCNQD1)
Path Group: CLK_CORE
Path Type: max
Data Arrival Time: 1.482 ns
Data Required Time: 1.250 ns
Slack: -0.232 ns (VIOLATED)
Net Delay on n_alu_carry: 0.310 ns (fanout=24)
```
## Expected Output
- **Path Summary Matrix:** Startpoint, Endpoint, Slack, Corner, Clock Skew, Logic Depth.
- **Delay Ratio Analysis:** Cell Delay % vs Net Delay %.
- **Bottleneck Hierarchy:** Top 3 gates/nets causing > 60% of data path delay.
- **Prescribed ECO Tactics:** Buffer insertion, cell upsizing, or Vt swapping.
## Limitations
- Claude cannot calculate SPICE non-linear delay tables or 3D field extraction parasitics. All recommended delay reductions are engineering estimates; PrimeTime/Tempus signoff is mandatory.
## Verification Checklist
- [ ] Clock period and uncertainty validated against golden SDC.
- [ ] Transition times checked against library max_transition limits.
- [ ] ECO sizing does not induce new hold violations or max-capacitance violations. ---
name: setup-timing-debugger
description: Diagnoses negative setup slack (max delay violations) across PVT corners, identifying root causes (deep logic cascades, detoured nets, high transition, clock skew deficits) and formulating precision closure actions.
---
# Setup Timing Debugger Skill
## Purpose
Systematically analyzes negative setup slack ($S_{\text{setup}} = T_{\text{required}} - T_{\text{arrival}} < 0$), determining whether the failure stems from architectural logic depth, weak cell drive strength, interconnect RC delay, clock network latency mismatch, or over-constrained SDC budgets.
## When to Activate
Activate when analyzing setup WNS/TNS regressions after synthesis, placement optimization, CTS, or detailed routing.
## Mathematical Formulation
$$\text{Data Arrival} = T_{\text{launch\_latency}} + T_{\text{CK}\to\text{Q}} + \sum T_{\text{cell}} + \sum T_{\text{net}}$$
$$\text{Data Required} = T_{\text{period}} + T_{\text{capture\_latency}} - T_{\text{setup}} - T_{\text{uncertainty}} + T_{\text{CPPR}}$$
$$\text{Slack}_{\text{setup}} = \text{Data Required} - \text{Data Arrival}$$
## Diagnostic Decision Tree
1. **Is Net Delay > 45% of Data Path Delay?**
- *Yes:* Placement detour, high routing congestion, or unbuffered long net. Solution: Buffer insertion, layer promotion, or physical cell padding.
2. **Is Logic Depth > 20 levels for 1 GHz+ targets?**
- *Yes:* Combinational logic cascade too deep. Solution: Architectural pipelining, register retiming, or logic restructuring.
3. **Are Input Transition Times > 120 ps on Critical Pins?**
- *Yes:* Output driver starvation. Solution: Gate upsizing (e.g. `_X1` $\to$ `_X4`) or buffer insertion.
4. **Is Capture Clock Significantly Earlier than Launch Clock ($\Delta T_{\text{skew}} < -80\,\text{ps}$)?**
- *Yes:* Clock tree imbalance. Solution: Useful skew scheduling or CTS trunk rebalancing.
## Limitations
- Setup fixes (upsizing, LVT swapping) increase dynamic and leakage power, and can create hold violations at fast/cold corners.
## Verification Checklist
- [ ] Setup slack verified under Slow-Slow-Global (SSG) corner at minimum $V_{DD}$.
- [ ] Proposed cell resizing evaluated against cell footprint compatibility.
- [ ] Downstream hold margin verified at Fast-Fast-Global (FFG) corner. ---
name: hold-timing-debugger
description: Diagnoses min-delay hold violations across fast/cold corners, evaluating short data paths, excessive positive clock skew, and prescribing safe delay buffer insertions that do not degrade setup slack.
---
# Hold Timing Debugger Skill
## Purpose
Investigates hold timing violations ($S_{\text{hold}} = T_{\text{arrival}} - T_{\text{required}} < 0$), ensuring data remains stable past the active capture clock edge to prevent race conditions and functional latch-up.
## Mathematical Formulation
$$\text{Data Arrival} = T_{\text{launch\_latency}} + T_{\text{CK}\to\text{Q}} + T_{\text{comb\_min}} + T_{\text{net\_min}}$$
$$\text{Data Required} = T_{\text{capture\_latency}} + T_{\text{hold}} + T_{\text{uncertainty}} - T_{\text{CPPR}}$$
$$\text{Slack}_{\text{hold}} = \text{Data Arrival} - \text{Data Required}$$
## Step-by-Step Analysis Workflow
1. **Corner Verification:** Confirm report is from Fast-Fast-Global (FFG) or Fast-Cold (0.85V, -40C / 125C) corner where silicon propagation is fastest.
2. **Data Path Inspection:** Measure logic depth. Many hold failures occur on shift registers, scan chains, or pipeline stages with 0 combinational gates between launch Q and capture D.
3. **Clock Skew Evaluation:** Check if capture clock latency exceeds launch clock latency ($\Delta T_{\text{skew}} = T_{\text{capture}} - T_{\text{launch}} > 0$). Excessive positive skew eats into the hold budget.
4. **Buffer Insertion Strategy:**
- Select non-inverting delay buffers (`CLKBUF_X1`, `DELAY_X2`).
- Place delay buffers physically close to the capture register D pin to minimize routing disruption.
- Verify that adding delay does not turn a positive setup slack path negative at the slow corner.
## Limitations
- Adding excessive hold buffers increases standard cell density and dynamic switching power. Hold fixes must never be committed without multi-corner setup verification.
## Verification Checklist
- [ ] Hold analysis executed with on-chip variation derates and CPPR enabled.
- [ ] Setup slack margin confirmed $\ge T_{\text{inserted\_delay}} + 30\,\text{ps}$ at worst setup corner.
- [ ] Delay buffer footprint exists in standard cell target library. ---
name: sdc-constraint-reviewer
description: Audits Synopsys Design Constraints (SDC) for missing clocks, invalid false paths, erroneous multicycle hold multipliers, unconstrained ports, and conflicting clock groups.
---
# SDC Constraint Reviewer Skill
## Purpose
Performs rigorous syntactical and architectural audits of SDC/XDC constraint files, preventing under-constraining (which allows un-timed silicon failures) and over-constraining (which wastes routing resources and silicon area).
## Critical SDC Checks Performed
1. **Clock Definition Completeness:**
- Verify all primary clock inputs have `create_clock` with explicit waveform `-waveform {0 period/2}`.
- Audit PLL/divider outputs: Ensure `create_generated_clock` defines explicit `-source`, `-divide_by` or `-multiply_by`, and valid master clock pin.
2. **I/O Delay Constraints:**
- Check all input ports have `set_input_delay -clock [get_clocks ...]` for both `-max` and `-min`.
- Check all output ports have `set_output_delay -clock [get_clocks ...]` for both `-max` and `-min`.
- Flag unconstrained I/O ports (`check_timing` unconstrained endpoints).
3. **Timing Exceptions Audit:**
- `set_false_path`: Verify false paths are strictly applied to truly asynchronous or static control registers. Flag abuse of false paths used to mask real timing violations.
- `set_multicycle_path`: Verify that whenever `set_multicycle_path N -setup` is declared, the corresponding `set_multicycle_path (N-1) -hold` is explicitly included.
- `set_clock_groups`: Check `-asynchronous` groups between asynchronous domains; ensure synchronous sub-clocks are not accidentally severed.
## Limitations
- SDC review cannot verify board-level PCB trace propagation delays unless board design parameters are provided.
## Verification Checklist
- [ ] PrimeTime/Tempus `check_timing` run clean with zero unconstrained endpoints.
- [ ] Multicycle hold multipliers verified using waveform expansion.
- [ ] No false paths applied to clock pins or multi-bit CDC buses. ---
name: critical-path-analyzer
description: Pinpoints the most timing-critical paths in a design, clustering them by clock domain, logic cone, and physical hierarchy, and identifying structural bottlenecks across runs.
---
# Critical Path Analyzer Skill
## Purpose
Clusters and profiles the top 100+ violating paths from WNS down to zero slack, identifying whether timing violations are concentrated in a specific arithmetic datapath, state machine, register file, or interface module.
## Analysis Methodology
1. **Histogram & Distribution Profiling:**
- Group violating endpoints by module hierarchy (e.g., `u_core/u_mmu`, `u_crypto/u_aes`).
- Plot slack distribution: Determine whether violations are isolated (WNS anomaly) or systemic (widespread TNS wall).
2. **Common Sub-Cone Analysis:**
- Trace backwards from violating D pins to find common gating logic, multiplexer trees, or shared ALU operands.
3. **QoR Scorecard Generation:**
- Output WNS, TNS, Violating Endpoint Count (NVP), Worst Clock Domain, and Bottleneck Hierarchy.
## Limitations
- Cannot modify RTL source code directly; recommendations must be fed back to RTL designers or physical design engineers.
## Verification Checklist
- [ ] Critical paths verified across all active operating modes (functional, scan, BIST).
- [ ] Top bottleneck modules documented for architectural refactoring. ---
name: clock-skew-analyzer
description: Analyzes clock network latency, global skew, local skew, and useful skew scheduling between synchronous register pairs.
---
# Clock Skew Analyzer Skill
## Purpose
Evaluates post-CTS and post-route clock latency reports, distinguishing between harmless global skew across non-communicating blocks and dangerous local skew between synchronous launch-capture register pairs.
## Analysis Workflow
1. **Global Skew Evaluation:**
- $\text{Global Skew} = \max(T_{\text{latency}}) - \min(T_{\text{latency}})$ across the entire clock tree.
- Assess if tree balancing effort is within reasonable limits ($< 150\,\text{ps}$ for FinFET nodes).
2. **Local Skew Investigation:**
- For communicating flip-flops: $\Delta T_{\text{local\_skew}} = T_{\text{capture\_latency}} - T_{\text{launch\_latency}}$.
- Negative local skew ($T_{\text{capture}} < T_{\text{launch}}$) reduces available setup time.
- Positive local skew ($T_{\text{capture}} > T_{\text{launch}}$) degrades hold margin.
3. **Useful Skew Verification:**
- Audit whether EDA tool useful skew scheduling (e.g. Innovus CCOpt) has excessively delayed capture clocks, creating downstream hold traps.
## Limitations
- Clock latency values depend on extracted clock tree parasitic accuracy; pre-CTS estimations are purely speculative.
## Verification Checklist
- [ ] Local skew between critical communicating registers $< 40\,\text{ps}$.
- [ ] Clock buffers balanced symmetrically in technology library. ---
name: clock-tree-timing-reviewer
description: Reviews clock tree synthesis results, buffer depth, duty-cycle distortion, transition times on clock nets, and Integrated Clock Gating (ICG) enable timing.
---
# Clock Tree Timing Reviewer Skill
## Purpose
Reviews clock network topology reports, assessing buffer cascade depth, driver transition targets, clock duty cycle preservation, and ICG cell placement proximity to prevent setup violations on gating pins.
## Key Metrics Evaluated
1. **Buffer Depth & Level Balancing:**
- Flag paths where clock buffer levels exceed 8–10 stages.
- Check level mismatches between adjacent floorplan partitions.
2. **Clock Slew / Transition Times:**
- Verify clock net transition times meet tight high-frequency limits ($T_{\text{trans}} \le 60\text{--}80\,\text{ps}$).
3. **Integrated Clock Gating (ICG) Timing:**
- Audit setup and hold timing on ICG `E` (enable) pins.
- Ensure ICG cells are placed close to sink registers to avoid clock latency divergence.
## Limitations
- Cannot alter clock routing topologies directly; requires feeding Tcl properties to CTS engines.
## Verification Checklist
- [ ] ICG enable setup slack $> 50\,\text{ps}$ across all corners.
- [ ] Clock buffer cells selected exclusively from symmetric balanced clock library variants. ---
name: mmmc-timing-analyzer
description: Coordinates Multi-Mode Multi-Corner (MMMC) timing analysis, mapping scenarios across process corners, voltages, temperatures, RC parasitics, and operational modes.
---
# MMMC Timing Analyzer Skill
## Purpose
Triages timing violations across high-dimensional MMMC scenario matrices, identifying whether violations are corner-specific (e.g., leakage-dominated high-temperature hold vs drive-starved low-voltage setup) or systemic across all modes.
## Multi-Corner Dimension Mapping
- **Process Corners:** Slow-Slow (SSG), Typical (TT), Fast-Fast (FFG), Global vs Local variation.
- **Voltage:** $V_{\text{nom}} \pm 10\%$ (e.g., $0.65\text{V}, 0.75\text{V}, 0.85\text{V}$).
- **Temperature:** $-40^\circ\text{C}$ (temperature inversion node check), $25^\circ\text{C}$, $125^\circ\text{C}$.
- **Extraction Corners:** Cbest (min capacitance), Cworst (max capacitance), RCbest, RCworst.
- **Operational Modes:** Functional Normal, High-Speed Turbo, Low-Power Sleep, Scan Shift, Scan Capture, At-Speed BIST.
## Diagnostic Workflow
1. Matrix generation: Tabulate WNS and TNS across all Mode $\times$ Corner pairs.
2. Isolate dominant corners: Identify which corner drives the worst setup slack and which drives worst hold.
3. Detect temperature inversion: Check if low temperature ($-40^\circ\text{C}$) yields worse setup slack than high temperature ($125^\circ\text{C}$) at advanced nodes ($< 16\,\text{nm}$).
## Limitations
- MMMC analysis requires extensive computational runs; Claude synthesizes and interprets existing scenario outputs.
## Verification Checklist
- [ ] Signoff scenario matrix covers all required foundry customer qualification corners.
- [ ] Temperature inversion verified at low Vdd corners. ---
name: ocv-aocv-pocv-reviewer
description: Audits On-Chip Variation (OCV), Advanced OCV (AOCV), and Parametric OCV (POCV / LVF) derating tables, timing graph depth, and common path pessimism removal (CPPR).
---
# OCV, AOCV & POCV Reviewer Skill
## Purpose
Audits statistical timing derates and on-chip variation configurations in PrimeTime and Tempus, verifying that margin models match foundry signoff guidelines without introducing excessive pessimism.
## Methodology Comparison
- **Traditional OCV:** Applies flat percentage derates (e.g., $+5\%$ late, $-5\%$ early) across the entire chip. Highly pessimistic on deep paths.
- **AOCV (Stage-Based):** Derates vary as a function of logic depth and physical path distance. Deeper logic paths receive lower derates due to statistical averaging.
- **POCV / LVF (Parametric / Liberty Variation Format):** Models delay variation as Gaussian distributions ($C \pm n\sigma$). Each cell delay includes nominal delay plus sensitivity coefficient ($\sigma$).
## Key Audit Checks
1. Verify `set_timing_derate` statements match foundry signoff runsets.
2. Confirm Clock Common Path Pessimism Removal (CPPR / CRPR) is enabled:
`set_app_var timing_remove_clock_reconvergence_pessimism true`
3. Check POCV sigma threshold setting (typically $3\sigma$).
## Limitations
- Liberty Variation Format (LVF) tables are proprietary foundry IP; Claude analyzes derate commands and reports, not raw cell characterization tables.
## Verification Checklist
- [ ] CPPR enabled and validated in timing reports.
- [ ] POCV derate tables loaded and applied to both data and clock paths. ---
name: timing-violation-classifier
description: Categorizes thousands of timing violations into actionable buckets (logic depth, fanout, net detour, clock skew, constraint error, crosstalk) for systematic triage.
---
# Timing Violation Classifier Skill
## Purpose
Automates the classification of large-scale timing violation logs into discrete engineering categories, allowing team leads to assign specific paths to RTL designers, physical design engineers, or constraint owners.
## Classification Taxonomy
1. **Type A: Deep Logic Cascade** ($\text{Logic Levels} > 16$, Cell Delay $> 65\%$). Action: RTL designer logic restructuring or pipelining.
2. **Type B: Interconnect Detour** ($\text{Net Delay} > 45\%$). Action: Physical placement bound or buffer insertion.
3. **Type C: High Fanout Starvation** ($\text{Fanout} > 20$, Transition $> 120\,\text{ps}$). Action: Buffer tree synthesis.
4. **Type D: Clock Skew Deficit** ($T_{\text{skew}} < -100\,\text{ps}$). Action: CTS rebalancing.
5. **Type E: SDC Constraint Error** (Illegal I/O budget or false path omission). Action: SDC update.
6. **Type F: Crosstalk Delay Injection** ($\Delta T_{\text{SI}} > 80\,\text{ps}$). Action: Shielding or driver sizing.
## Expected Output
- Ranked breakdown table with violation count and percentage per category.
- Automated assignment recommendations.
## Limitations
- Rule-based heuristics require representative timing reports with net and transition reporting enabled.
## Verification Checklist
- [ ] All violating paths accounted for in categorization table.
- [ ] Root causes validated with sample path spot checks. ---
name: timing-eco-reviewer
description: Evaluates Engineering Change Order (ECO) scripts for timing closure, verifying cell sizing legality, buffer insertion site feasibility, and multi-corner side effect immunity.
---
# Timing ECO Reviewer Skill
## Purpose
Performs pre-commit audits of PrimeTime or Tempus ECO Tcl scripts (`size_cell`, `insert_buffer`, `swap_cell`), ensuring proposed fixes solve target violations without degrading hold timing, violating design rules (DRVs), or inducing routing congestion.
## Audit Workflow
1. **Footprint & Cell Legality:** Verify replacement cells share identical footprint and pinout with original instances.
2. **Setup vs Hold Trade-Off:** Verify that upsizing drivers or inserting LVT cells on setup-critical paths does not create hold violations at the fast corner.
3. **DRV Impact:** Ensure buffer insertions do not exceed max_capacitance or max_transition limits on driving nets.
4. **Physical Density:** Verify ECO buffers are placed into legal placement sites with adequate local whitespace.
## Example Output
```text
ECO Audit Summary:
Total Commands: 42 (28 size_cell, 14 insert_buffer)
Setup Improvement Expected: +85 ps WNS
Hold Risk Detected: 2 paths near threshold (Paths #12, #29)
Recommendation: Add hold delay buffer on Path #12 capture pin before commit.
```
## Limitations
- Claude cannot guarantee physical routability of inserted ECO buffers; incremental PnR execution is mandatory.
## Verification Checklist
- [ ] Replacement cells verified in target technology library.
- [ ] Incremental STA run clean across all MMMC signoff corners.
- [ ] Formal equivalence (LEC) verified post-ECO. ---
name: timing-report-comparator
description: Compares two timing reports (pre-ECO vs post-ECO, or Run A vs Run B), isolating regressions, fixed paths, and net WNS/TNS changes.
---
# Timing Report Comparator Skill
## Purpose
Performs side-by-side delta analysis between two timing report runs, flagging which paths improved, which regressed, and calculating exact WNS/TNS shifts across implementation milestones.
## Metric Deltas Computed
- $\Delta\text{WNS} = \text{WNS}_{\text{Run B}} - \text{WNS}_{\text{Run A}}$
- $\Delta\text{TNS} = \text{TNS}_{\text{Run B}} - \text{TNS}_{\text{Run A}}$
- $\Delta\text{NVP} = \text{Violating Count}_{\text{Run B}} - \text{Violating Count}_{\text{Run A}}$
- Endpoint-by-endpoint correlation: Identifies newly violating endpoints that were previously meeting timing.
## Limitations
- Requires both reports to be generated under identical SDC constraints and operating corners to prevent false regression flags.
## Verification Checklist
- [ ] Consistent corner comparison verified.
- [ ] Zero un-tracked regressions introduced. ---
name: sta-tcl-automation
description: Generates, debugs, and refines custom Tcl scripts for Synopsys PrimeTime and Cadence Tempus, automating path extraction, violation reporting, and custom check loops.
---
# STA Tcl Automation Skill
## Purpose
Writes clean, modular, and robust Tcl automation procedures for PrimeTime (`pt_shell`) and Tempus, extracting timing attributes, formatting custom CSV summaries, and creating batch analysis pipelines.
## Capabilities
- Custom collection filtering (`get_timing_paths`, `get_cells`, `get_nets`).
- Iterating through path collections to extract startpoint, endpoint, slack, and delay components.
- Automating CSV and markdown table generation directly from EDA shells.
## Limitations
- Tcl syntax must strictly match target tool shell versions. Claude avoids deprecated or proprietary unverified commands.
## Verification Checklist
- [ ] Tcl procedure syntax checked with clean source execution in `pt_shell` or `tempus`.
- [ ] Memory-efficient collection handling implemented (e.g. freeing large collections). ---
name: timing-regression-analyzer
description: Investigates unexpected timing regressions between physical implementation stages (e.g. Post-CTS to Post-Route), tracing degradation to routing parasitics, clock latency shifts, or cell displacement.
---
# Timing Regression Analyzer Skill
## Purpose
Diagnoses why timing closed at an earlier stage (e.g., post-placement or post-CTS) degrades severely after subsequent flow steps (e.g., detailed routing or SPEF signoff extraction).
## Diagnostic Investigation
1. **Parasitic Modeling Shift:** Compare wireload models vs virtual route vs extracted 3D SPEF.
2. **Clock Tree Latency Shift:** Compare ideal clock vs propagated clock network insertion delays.
3. **Crosstalk Delay Injection:** Compare timing slack with SI disabled vs SI enabled.
4. **Physical Displacement:** Check if detailed legalizer or detailed router moved critical path cells.
## Limitations
- Cannot reconstruct physical geometry without DEF and SPEF database inspection in the EDA environment.
## Verification Checklist
- [ ] Parasitic extraction settings matched to signoff specs.
- [ ] Propagated clock timing validated post-CTS. ---
name: si-crosstalk-timing-reviewer
description: Analyzes Signal Integrity (SI) crosstalk delay and glitch reports, identifying victim-aggressor coupling nets, Miller effect delay shifts, and recommending physical shielding or driver resizing.
---
# SI Crosstalk Timing Reviewer Skill
## Purpose
Inspects PrimeTime SI or Tempus SI crosstalk analysis outputs, evaluating how dynamic switching on aggressor nets impacts victim net propagation delay (Miller effect) and functional voltage glitch noise.
## Physics Evaluated
- **Crosstalk Setup Delay:** Aggressor switching in opposite direction increases effective coupling capacitance ($C_{\text{eff}} \approx 2 \cdot C_c$), expanding transition time and causing setup violations.
- **Crosstalk Hold Delay:** Aggressor switching in same direction accelerates victim transition ($C_{\text{eff}} \approx 0$), speeding up arrival time and inducing hold violations.
- **Glitch Noise Margin:** Static net experiences voltage bounce due to capacitive charge injection. Peak glitch must remain below library $V_{\text{noise\_margin}}$.
## Prescribed Physical Fixes
1. Upsize victim driver to lower driving impedance.
2. Downsize aggressor driver if aggressor path has excess slack.
3. Insert repeater buffer on long victim interconnect.
4. Shield victim net with VDD/VSS tracks or increase routing track spacing.
## Limitations
- SI calculation requires accurate coupled parasitic extraction (`*C_COUP` in SPEF); lumped capacitance is completely inadequate for SI signoff.
## Verification Checklist
- [ ] Extracted SPEF contains explicit cross-coupling capacitors.
- [ ] Peak glitch height $< 25\%$ of supply voltage ($V_{DD}$). Five Practical Hands-On Projects for STA Engineers
Project 1 Analyze a Setup Timing Violation from a PrimeTime Report
Design Scenario: An 800 MHz cryptographic accelerator shows a setup violation of -185 ps at the Slow-Slow-Global (0.65V, -40°C) corner on the final state accumulator path.
Input: Sample PrimeTime timing report showing 16 logic stages.
Startpoint: u_core/r_round_cnt_reg_3/CLK (DFCNQD1)
Endpoint: u_core/r_state_acc_reg_63/D (DFCNQD1)
Path Group: CLK_CORE (Period: 1.25 ns)
Path Type: max (setup)
Corner: ssg_0p65v_m40c
Point Incr Path
-----------------------------------------------------------------
clock CLK_CORE (rise edge) 0.000 0.000
clock network delay (propagated) 0.380 0.380
u_core/r_round_cnt_reg_3/CLK (DFCNQD1) 0.000 0.380 r
u_core/r_round_cnt_reg_3/Q (DFCNQD1) 0.145 0.525 f
u_core/U_xor_stage1/Y (XOR2_X1) 0.160 0.685 r <-- High cell delay
u_core/n_xor_stage1 (net: fanout=32, cap=48fF) 0.245 0.930 r <-- Net delay bottleneck!
u_core/U_mux_select/Y (MUX2_X1) 0.125 1.055 f
... [10 intermediate gates omitted] ...
u_core/r_state_acc_reg_63/D (DFCNQD1) 0.040 1.435 r
data arrival time 1.435
clock CLK_CORE (rise edge) 1.250 1.250
clock network delay (propagated) 0.395 1.645
clock uncertainty -0.050 1.595
library setup time -0.035 1.560
data required time 1.560
-----------------------------------------------------------------
slack (VIOLATED) -0.185
Claude Diagnostic Analysis:
- Data Arrival Breakdown: Total arrival is 1.435 ns. Launch latency is 0.380 ns. Net
n_xor_stage1alone accounts for 0.245 ns (over 23% of total data path time) due to an excessive fanout of 32 and high capacitive loading of 48 fF. - Cell Strength Starvation:
XOR2_X1is a minimum drive strength cell driving a high-fanout net, causing its internal switching time to inflate to 160 ps.
# PrimeTime Timing ECO Script: Path Closure
# 1. Insert high-drive repeater buffer on high-fanout net
insert_buffer u_core/n_xor_stage1 BUF_X8 -new_cell_name u_eco_buf_xor_0
# 2. Upsize driving gate from X1 to X4
size_cell u_core/U_xor_stage1 XOR2_X4
# 3. Swap downstream multiplexer to low-leakage LVT variant
swap_cell u_core/U_mux_select MUX2_X4_LVT
Expected Result: Net delay on n_xor_stage1 drops from 245 ps to 55 ps; cell delay on XOR2_X4 drops from 160 ps to 65 ps. Path slack closes from -185 ps to +25 ps (MET).
Project 2 Debug a Hold Timing Violation and Formulate Safe Buffering
Design Scenario: A fast shift register reports a hold violation of -110 ps at the Fast-Fast-Global (0.85V, 125°C) corner. The data path has zero combinational logic gates.
Input: Sample PrimeTime min-delay report.
Startpoint: u_pipe/r_stage_0_reg/CLK (DFCNQD1)
Endpoint: u_pipe/r_stage_1_reg/D (DFCNQD1)
Path Group: CLK_FAST
Path Type: min (hold check)
Corner: ffg_0p85v_125c
Point Incr Path
-----------------------------------------------------------------
clock CLK_FAST (rise edge) 0.000 0.000
clock network delay (propagated) 0.220 0.220
u_pipe/r_stage_0_reg/CLK (DFCNQD1) 0.000 0.220 r
u_pipe/r_stage_0_reg/Q (DFCNQD1) 0.065 0.285 r
u_pipe/n_stage_data (net) 0.015 0.300 r
u_pipe/r_stage_1_reg/D (DFCNQD1) 0.000 0.300 r
data arrival time 0.300
clock CLK_FAST (rise edge) 0.000 0.000
clock network delay (propagated) 0.360 0.360
clock uncertainty 0.030 0.390
library hold time 0.020 0.410
data required time 0.410
-----------------------------------------------------------------
slack (VIOLATED) -0.110
Claude Diagnostic Analysis:
The violation is driven by positive clock skew: capture latency (0.360 ns) is 140 ps higher than launch latency (0.220 ns). Because there are no logic gates between the flip-flops, data arrival is only 300 ps, falling short of the 410 ps required time by exactly 110 ps.
# PrimeTime Hold ECO Script
# Insert two non-inverting delay buffers near capture register D pin
# Each DELAY_X2 adds ~75 ps at FFG corner, totaling ~150 ps added delay
insert_buffer u_pipe/n_stage_data DELAY_X2 -new_cell_name u_eco_hold_buf0
insert_buffer u_pipe/n_stage_data_eco DELAY_X2 -new_cell_name u_eco_hold_buf1
Expected Result: Data arrival time increases from 300 ps to 450 ps. Hold slack closes from -110 ps to +40 ps (MET). Setup slack at the slow corner was confirmed to have > 350 ps headroom, ensuring zero setup regressions.
Project 3 Review an SDC File and Identify Suspicious Constraints
Design Scenario: An ASIC constraint file for an image processor SoC causes un-timed silicon failures. Claude audits the SDC file and flags critical constraint bugs.
# Buggy SDC File Snippet
create_clock -period 2.0 -name CLK_MAIN [get_ports clk_in]
# BUG 1: Missing master source pin definition on generated clock
create_generated_clock -name CLK_DIV2 -divide_by 2 [get_pins u_pll/clk_div2_reg/Q]
# BUG 2: Multicycle setup path declared without mandatory hold multiplier
set_multicycle_path 2 -setup -from [get_pins u_pipe/stage1_reg*/Q] -to [get_pins u_pipe/stage2_reg*/D]
# BUG 3: Dangerous false path applied to a synchronous multi-bit bus
set_false_path -from [get_pins u_ctrl/cfg_bus_reg[*]/Q] -to [get_pins u_datapath/cfg_sync_reg[*]/D]
# BUG 4: Missing -min hold constraint on input port delay
set_input_delay -clock CLK_MAIN -max 1.2 [get_ports data_in[*]]
Claude Audit & Corrected Golden SDC:
# Corrected Golden SDC File
create_clock -period 2.0 -name CLK_MAIN [get_ports clk_in]
# FIX 1: Explicit master clock source pin provided
create_generated_clock -name CLK_DIV2 -source [get_ports clk_in] -divide_by 2 [get_pins u_pll/clk_div2_reg/Q]
# FIX 2: Added mandatory corresponding (N-1) hold multiplier
set_multicycle_path 2 -setup -from [get_pins u_pipe/stage1_reg*/Q] -to [get_pins u_pipe/stage2_reg*/D]
set_multicycle_path 1 -hold -from [get_pins u_pipe/stage1_reg*/Q] -to [get_pins u_pipe/stage2_reg*/D]
# FIX 3: Replaced illegal false path with proper datapath-only max delay constraint
set_max_delay 2.0 -datapath_only -from [get_pins u_ctrl/cfg_bus_reg[*]/Q] -to [get_pins u_datapath/cfg_sync_reg[*]/D]
# FIX 4: Added explicit -min hold input delay budget
set_input_delay -clock CLK_MAIN -max 1.2 [get_ports data_in[*]]
set_input_delay -clock CLK_MAIN -min 0.3 [get_ports data_in[*]]
Project 4 Build a Python Timing Report Parser that Generates a CSV
Design Scenario: Automate the extraction of critical paths across 24 PVT corners, calculate cell-to-net delay ratios, and export a structured CSV spreadsheet for executive team reviews.
import re
import csv
import glob
import os
def parse_all_reports(report_dir, output_csv="summary_qor.csv"):
files = glob.glob(os.path.join(report_dir, "*.tarpt"))
all_data = []
for fpath in files:
corner_name = os.path.basename(fpath).replace(".tarpt", "")
with open(fpath, "r", encoding="utf-8") as f:
text = f.read()
paths = text.split("Startpoint:")
for p in paths[1:]:
p_text = "Startpoint:" + p
slack_m = re.search(r"slack\s+\((VIOLATED|MET)\)\s+([-\d\.]+)", p_text)
if slack_m and slack_m.group(1) == "VIOLATED":
start_m = re.search(r"Startpoint:\s+([^\s\(\)]+)", p_text)
end_m = re.search(r"Endpoint:\s+([^\s\(\)]+)", p_text)
nets = [float(x) for x in re.findall(r"\(net[^\)]*\)\s+([\d\.]+)", p_text)]
arr_m = re.search(r"data arrival time\s+([\d\.]+)", p_text)
total_net = sum(nets)
arr_time = float(arr_m.group(1)) if arr_m else 1.0
net_ratio = (total_net / arr_time) * 100 if arr_time > 0 else 0
all_data.append({
"Corner": corner_name,
"Startpoint": start_m.group(1) if start_m else "N/A",
"Endpoint": end_m.group(1) if end_m else "N/A",
"Slack_ns": float(slack_m.group(2)),
"NetDelay_ns": round(total_net, 4),
"NetDelay_Pct": round(net_ratio, 1),
"RootCause": "Routing Detour / Fanout" if net_ratio > 45 else "Logic Cone Depth"
})
all_data.sort(key=lambda x: x["Slack_ns"])
with open(output_csv, "w", newline="", encoding="utf-8") as f:
writer = csv.DictWriter(f, fieldnames=all_data[0].keys())
writer.writeheader()
writer.writerows(all_data)
print(f"Generated {output_csv} with {len(all_data)} violating paths.")
if __name__ == "__main__":
parse_all_reports("reports/timing/")
Project 5 Compare Two Timing Reports and Explain WNS/TNS Regression
Design Scenario: Between CTS and detailed routing, the WNS regressed from -45 ps to -215 ps, and TNS worsened from -1.2 ns to -18.6 ns. Claude performs a differential analysis to isolate the cause.
| Signoff Metric | Pre-Route (CTS Opt) | Post-Route (SPEF Signoff) | Delta (Δ) | Diagnostic Conclusion |
|---|---|---|---|---|
| Worst Negative Slack (WNS) | -0.045 ns | -0.215 ns | -0.170 ns (Regressed) | Severe timing regression on bus data_arb[*]. |
| Total Negative Slack (TNS) | -1.240 ns | -18.650 ns | -17.410 ns (Regressed) | Widespread timing degradation across 84 endpoints. |
| Violating Endpoints (NVP) | 12 | 84 | +72 endpoints | Systemic routing congestion in tile [450, 680]. |
| Coupling Capacitance ($C_c$) | Estimated (0 fF) | Extracted (38.5 fF avg) | +38.5 fF | Root Cause: Crosstalk delay expansion (Miller effect) from dense parallel bus routing. |
Claude Prescribed Action Plan:
- Re-route critical bus
data_arb[*]with double-spacing rule (2S) to eliminate 65% of coupling capacitance. - Promote long bus nets from thin Metal 3 to thick Metal 6 tracks.
- Re-extract SPEF with Quantus/StarRC and re-verify STA in PrimeTime SI.
Practical Claude Prompts Library for STA Engineers
A curated collection of 30 production-ready prompts engineered specifically for ASIC Static Timing Analysis, PrimeTime, Tempus, SDC audits, and timing closure. Filter by category, copy directly to your clipboard, and paste into Claude along with your tool reports.
Claude vs. Commercial STA EDA Engines Matrix
To deploy AI safely in production signoff workflows, engineering teams must maintain clear technical boundaries between generative AI reasoning and deterministic EDA simulation software:
| STA Tool | Vendor | Core Capability | Deterministic EDA Engine Function | How Claude Assists the Engineer | Signoff Boundary |
|---|---|---|---|---|---|
| PrimeTime / PT-SI | Synopsys | Golden ASIC Signoff STA | CCS/NLDM non-linear delay calculation, CRPR, crosstalk glitch/delay, POCV/LVF statistical timing. | Parses 200+ page reports, computes cell-to-net delay ratios, identifies bottleneck gates, writes precision Tcl ECO scripts. | PrimeTime .tarpt is the undisputed foundry tapeout signoff record; Claude estimates are advisory. |
| Tempus | Cadence | Distributed Signoff STA | Massively parallel path-based analysis (PBA), graph-based analysis (GBA), integrated SI noise calculation. | Structures multi-corner comparison loops, audits SDC exception coverage, diagnoses clock gate setup checks. | Cadence signoff certified by foundry signoff rule decks. |
| OpenSTA | Open Source (Parallax) | Gate-Level STA Engine | Fast, scriptable timing analysis engine embedded in OpenLane, OpenROAD, and academic synthesis flows. | Writes Tcl constraint scripts, configures basic clock checks, debugs timing path failures for open-source silicon. | Suitable for exploratory flows and Google/SkyWater shuttle tapeouts; commercial chips use PrimeTime/Tempus. |
| NanoTime | Synopsys | Transistor-Level STA | Full SPICE-accurate transistor-level static timing analysis for custom memories, analog-mixed-signal, and standard cell IP. | Analyzes transistor contention logs, identifies floating node warnings, structures sub-circuit timing reports. | NanoTime SPICE simulation required for custom IP characterization. |
Security, Intellectual Property & Production Design Safety
Protecting Proprietary Silicon IP in Generative AI Workflows
Static Timing Analysis reports, Liberty (.lib) timing libraries, and SDC constraint files contain company trade secrets and strict foundry Non-Disclosure Agreements (NDAs).
- Never upload raw Liberty (.lib) lookup tables: SPICE-characterized NLDM and CCS tables represent multi-million dollar foundry IP.
- Sanitize Hierarchical Module & Net Names: Strip internal project names, confidential cryptographic block labels, and absolute server file paths before prompting.
- Mandate Enterprise Zero Data Retention (ZDR): Backend engineering teams must operate exclusively on private cloud or enterprise AI instances where prompts and reports are never retained for model training.
Automated STA Report Sanitizer in Python
Run this standalone pre-processor script to sanitize your timing reports before feeding them to Claude:
import re
import sys
def sanitize_sta_report(input_file, output_file="sanitized_report.rpt"):
with open(input_file, 'r', encoding='utf-8') as f:
text = f.read()
# Anonymize proprietary module names
text = re.sub(r'u_crypto_engine_\w+', 'u_block_alpha', text)
text = re.sub(r'u_neural_npu_\w+', 'u_compute_core', text)
text = re.sub(r'u_pcie_gen5_\w+', 'u_interface_block', text)
# Mask foundry cell library identifiers
text = re.sub(r'TSMC\w+_SVTLOW', 'STD_CELL_SVT', text)
text = re.sub(r'GF\w+_LVT', 'STD_CELL_LVT', text)
# Anonymize absolute enterprise file system paths
text = re.sub(r'/proj/[^/]+/[^/]+/', '/workspace/asic_run/', text)
with open(output_file, 'w', encoding='utf-8') as f:
f.write(text)
print(f"Sanitized report saved to {output_file}")
if __name__ == "__main__":
if len(sys.argv) > 1:
sanitize_sta_report(sys.argv[1])
else:
print("Usage: python sanitize_sta_report.py ")
Static Timing Analysis & AI Engineering FAQ
1. Can Claude directly execute Static Timing Analysis or calculate delay equations?
No. Claude is an LLM with no integrated numerical delay calculation engine, no non-linear delay model (NLDM) or composite current source (CCS) interpolator, and no 3D parasitic extraction solver. Claude functions as an intelligent diagnostic copilot that parses timing reports, calculates delay component ratios, detects SDC anomalies, and formulates precise Tcl ECO scripts for golden signoff execution in Synopsys PrimeTime or Cadence Tempus.
2. How does Claude differentiate between cell delay and net delay bottlenecks in an STA report?
Claude calculates the Cell-to-Net Delay Ratio across the data path. If net delay exceeds 40% to 50% of the total path arrival time, Claude identifies physical interconnect detours, high wire resistance, or high capacitive loading, recommending buffer insertion or layer promotion. If cell delay dominates (> 65%), it points to excessive logic depth, weak drive strength, or sub-optimal threshold voltage (Vt) cell variants.
3. Can Claude diagnose hold timing violations across multi-corner scenarios?
Yes. Claude evaluates min-delay timing reports at fast/cold corners (such as FFG 0.85V 125C or -40C) where silicon speed is highest. It assesses clock skew between launch and capture registers, measures minimum data path delay, and recommends non-inverting delay buffer insertions (e.g. DELAY_X2) placed close to capture registers, ensuring that proposed fixes do not degrade setup slack at slow corners.
4. How does Claude help audit SDC constraints for subtle bugs?
Claude reviews SDC files for common failure modes: unconstrained ports, generated clocks missing master source definitions, illegal set_false_path statements applied to synchronous multi-bit buses, and set_multicycle_path setup constraints that omit the required corresponding (N-1) hold multiplier.
5. What is Clock Common Path Pessimism Removal (CPPR / CRPR) and how does Claude verify it?
In static timing analysis under on-chip variation (OCV), different early and late derate factors are applied to launch and capture clock paths. However, the shared root clock tree segments cannot physically operate at two different speeds simultaneously. CPPR removes this artificial pessimism. Claude verifies that CPPR is enabled in tool settings and audits the CPPR credit line in timing path reports.
6. Is it safe to share proprietary ASIC timing reports and SDC files with Claude?
Proprietary timing paths, hierarchical instance names, and standard cell library parameters constitute trade secrets. Backend teams must never paste un-sanitized reports into public AI tools. Teams should use enterprise Claude instances under Zero Data Retention (ZDR) agreements or employ automated Python sanitization scripts to anonymize cell names, clock names, and absolute Linux file paths.
7. What are the 15 Claude Code STA skills included in this masterclass?
The 15 skills are version-controlled SKILL.md packages covering: sta-report-analyzer, setup-timing-debugger, hold-timing-debugger, sdc-constraint-reviewer, critical-path-analyzer, clock-skew-analyzer, clock-tree-timing-reviewer, mmmc-timing-analyzer, ocv-aocv-pocv-reviewer, timing-violation-classifier, timing-eco-reviewer, timing-report-comparator, sta-tcl-automation, timing-regression-analyzer, and si-crosstalk-timing-reviewer.
8. How does Claude assist with Signal Integrity (SI) and crosstalk delay analysis?
Claude parses PrimeTime SI and Tempus SI reports, identifying victim nets subjected to capacitive coupling from simultaneously switching aggressor nets (Miller effect). It calculates crosstalk-induced delay expansion and evaluates glitch height against noise margins, prescribing victim upsizing, net shielding, or repeater insertion.