iTO · timing optimization

# Core capabilities

iTO is the timing-closure bridge in the iEDA flow—it does not run static timing analysis (that is iSTA's job), but generates and executes timing repair based on STA diagnostics. iTO intervenes after CTS and post-route: after CTS it mainly fixes hold violations (clock-tree skew) and setup violations (long paths); post-route it runs post-route ECO—repairing residual timing violations while minimizing routing topology changes.

Agent collaboration with iTO is one of the most closed-loop scenarios in EDA Agent workflows: diagnose → generate proposals → evaluate → apply → re-STA → verify. Agents call iTO.diagnose to get violating path lists with per-path slack and WNS distribution; then iTO.optimize to generate ECO proposals (resize drive strength, VT swap, buffer insertion, gate sizing, and more). Agents can filter proposals by policy (e.g. only changes with <5% area increase, prefer route-preserving ECO) and call iSTA after apply to verify fixes. If violations remain, Agents adjust strategy (conservative → aggressive) or target_slack for another iteration.

In AI-enhanced flows, Agents can feed iTO diagnose output (path depth, cell-type distribution, estimated wirelength, VT mix) into learning models to predict the most likely successful repair strategy, reducing trial-and-error rounds. For recurring violation patterns (e.g. a buffer class consistently under-driven), Agents can record rules for proactive prevention in later designs.

iTO optimization uses Lagrangian relaxation and greedy gate sizing. Agent-tunable parameters include strategy (conservative = minimal change, aggressive = large area for timing), target_slack (stop when slack reaches this value), and max_iterations. iTO is tightly coupled with iSTA—each optimize call needs STA timing graph and slack before and after.

# Agent calling patterns

# Agent calls iTO for closed-loop timing repair
from ieda_client import IEDAClient

client = IEDAClient()

# Step 1: Diagnose violations
proposals = client.call("iTO.diagnose",
    design_ref="snap_7f3a",
    scenario="func_worst")

# Agent can inspect each proposal
for p in proposals:
    print(f"{p['path']}: slack={p['slack']}, type={p['violation_type']}")

# Step 2: Run optimization (conservative strategy)
result = client.call("iTO.optimize",
    design_ref="snap_7f3a",
    scenario="func_worst",
    strategy="conservative",
    max_iterations=10)

# Step 3: Agent verifies results
print(f"Changes applied: {result['applied_changes']}")
print(f"New WNS:         {result['new_wns']}")
print(f"New TNS:         {result['new_tns']}")

# Step 4: If WNS is still negative, switch to aggressive strategy
if result['new_wns'] < 0:
    result = client.call("iTO.optimize",
        design_ref="snap_7f3a",
        scenario="func_worst",
        strategy="aggressive")

{
  "tool": "iTO.optimize",
  "arguments": {
    "design_ref": "snap_7f3a",
    "scenario": "func_worst",
    "strategy": "conservative"
  }
}

# Tcl interactive timing optimization
iTO::set_design snap_7f3a
iTO::set_scenario func_worst
iTO::set_strategy conservative
iTO::optimize -design snap_7f3a -scenario func_worst -strategy conservative
iTO::report_proposals
iTO::apply_proposals -count 20
iTO::write_def -output snap_7f3a.opt.def

# Input / output contract

# Role in the flow

    ··· prior steps ···
         │
  ┌─────────────┐
  │    iCTS     │  clock tree synthesis complete
  │ Clock Tree   │
  └──────┬──────┘
         │  cts design
         ▼
  ┌─────────────┐
  │   iTO      │  ← current tool: timing optimization (post-CTS)
  │ Timing Opt   │
  └──────┬──────┘
         │
         ▼
  ┌─────────────┐
  │    iRT      │  routing
  │   Routing    │
  └──────┬──────┘
         │  routed design
         ▼
  ┌─────────────┐
  │   iTO      │  ← re-enters: post-route ECO
  │ Timing Opt   │
  └──────┬──────┘
         │
         ▼
  ┌─────────────┐
  │  iSTA Signoff│  signoff timing verification
  └─────────────┘

# Related resources