iDRC · Design rule check

# Core capabilities

# Multi-rule geometry checks

iDRC supports full basic geometric DRC: spacing (same/adjacent layer metal and via minimum spacing), width (min/max wire and via width), enclosure (metal over vias and vias over metal), area (minimum polygon area), notch (minimum notch width), and more. Agents set the rule set via rules (e.g. ["spacing", "width"]) or ["all"] for a full check. Each rule returns independently so Agents can locate violation types without parsing logs.

# Incremental DRC (dirty region)

Full-chip DRC is among the slowest EDA steps. iDRC incremental mode tracks geometry changed since the last check (dirty region) and re-runs DRC only there. With incremental=true, iDRC pulls dirty regions from iDB, merges overlaps, and verifies locally. After a router fixes a few nets, incremental DRC often takes 2–10% of full-chip time. Results include clean_regions—verified violation-free bounding boxes.

# Region-scoped checks

Agents can limit DRC to a rectangle via the region parameter (BBox). In interactive repair, after identifying a violation region, Agents can loop edit-check on that area and margin in milliseconds instead of waiting for full-chip verification. Combined with rules, DRC becomes an interactive feedback loop—not batch-only.

# Typed violation reports

iDRC returns structured violations: each Violation has type, layer, BBox, object refs, and severity. Unlike text DRC logs, Agents can iterate, group by type, cluster by region, and rank by severity—enabling automated triage and repair priority. This is the data foundation for autonomous DRC repair loops.

# Agent calling patterns

iDRC exposes three equivalent calling protocols.

from ieda import Client

client = Client("http://localhost:9099")

# Full DRC check (all rules)
drc = client.call(
    "iDRC.check",
    design_ref="snap_7f3a",
    rules=["all"],
    incremental=False,
)

print(drc.violation_count)  # 0
print(drc.coverage)          # 1.0 (100% area checked)

# Incremental DRC: only check dirty regions
incr = client.call(
    "iDRC.check",
    design_ref="snap_7f3a",
    rules=["spacing", "width", "enclosure"],
    incremental=True,
)

print(incr.violation_count)  # 3
for v in incr.violations:
    print(v.rule, v.layer, v.bbox, v.severity)
    # enclosure, M2, [(100,200),(150,220)], ERROR

print(incr.clean_regions)   # verified-clean bounding boxes

# Region-limited DRC for interactive repair loop
region_check = client.call(
    "iDRC.check",
    design_ref="snap_7f3a",
    rules=["spacing"],
    region={"x0": 100, "y0": 200, "x1": 300, "y1": 400},
)

// JSON-RPC over MCP
{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "iDRC.check",
    "arguments": {
      "design_ref": "snap_7f3a",
      "rules": ["all"],
      "incremental": true
    }
  }
}

// Response
{
  "violation_count": 3,
  "violations": [
    {
      "rule": "enclosure",
      "layer": "M2",
      "bbox": [100, 200, 150, 220],
      "objects": ["via_0_123", "m2_456"],
      "severity": "ERROR"
    }
  ],
  "clean_regions": [
    [0, 0, 99, 199],
    [151, 221, 1000, 800]
  ],
  "coverage": 0.94,
  "design_ref": "snap_7f3a"
}

# Full DRC check (all rules)
iDRC::check -design snap_7f3a -rules {all}

# Specific rules only
iDRC::check -design snap_7f3a -rules {spacing width enclosure}

# Incremental check after local edits
iDRC::check -design snap_7f3a -incremental true

# Region-limited check
iDRC::check -design snap_7f3a -region {100 200 300 400} -rules {spacing}

# Query results
iDRC::report_violations
iDRC::report_summary
iDRC::violation_count

# Input / output contract

Request Schema — iDRC.check

Result Schema

# Role in the flow

iDRC mainly runs in post-route physical verification; incremental mode makes it essential in ECO loops.

  RTL → iMap → iFP → iPDN → iPL → iCTS → iTO → iRT
                                                             │
                                              After routing completes     │
                                                             ↓
                                                    ──────────
                                                    ↓
                                              ◆ iDRC (Design rule check)
                                              │   [spacing] [width]
                                              │   [enclosure] [area]
                                              │   [notch] [min-step] ...
                                              │
                                              ↓ DRC Clean?
                                              │
                                         Yes  │   No
                                          │         │
                                          ↓        ↓
                                       iLVS    iECO (ECO)
                                     (LVS)  │
                                          │      ↓
                                          ↓    iRT (local re-route)
                                       GDSII     │
                                                 ↓
                                               iDRC (incremental recheck)
                                                 ↑
                                                 └────── loop ──────┘

# Related resources