Pin access: --access-cost, vias in pads inside wire keepouts, exact stub checks

--access-cost C makes a route pay C to pass where it would close another
pin's way out (its end cells, the via it may need there, and the
clearance around both) while that pin still has connections to route.

A pin inside a wire keepout can only leave by a via; its stub to the
cell centre was track inside the keepout, which the exact check refused.
The via now goes on the pin itself. Pin stubs are also checked exactly
against wire keepouts, as the exact engine will check them.

bench/diagnose.py reports what each refused connection collided with.

bench/bench.py

@@ -24,9 +24,11 @@ off. Exits non-zero if any run crashed or timed out.
 from __future__ import annotations
 
 import argparse
+from concurrent.futures import ThreadPoolExecutor, as_completed
 import json
 import math
 import os
+from pathlib import Path
 import re
 import shlex
 import subprocess
@@ -34,8 +36,6 @@ import sys
 import tempfile
 import threading
 import time
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from pathlib import Path
 
 NOT_ROUTED = re.compile(r"freeroute: (\d+) connection\(s\) not routed")
 TO_ZONE = re.compile(r"freeroute: (\d+) more connection\(s\) left to a zone fill")

bench/diagnose.py

@@ -24,6 +24,7 @@ from pathlib import Path
 import sys
 
 from freeroute.board import build_board
+from freeroute.board.search_tree import ShapeSearchTree
 from freeroute.dsn import parse_dsn
 from freeroute.route import grid_router
 from freeroute.route.exact_router import route_board_exact
@@ -69,6 +70,36 @@ def _capture_router():
     return seen
 
 
+def _capture_conflicts() -> list:
+    """Record each exact-check refusal: the copper box, its kind, and the
+    shape it came too close to. The check stops at a connection's first
+    conflict, so refusals and rejected connections line up in order."""
+    log: list = []
+    original = ShapeSearchTree.clearance_conflict
+
+    def conflict(self, box, net_no, layer, clearance, kind="wire"):
+        hit = original(self, box, net_no, layer, clearance, kind)
+        if hit:
+            expanded = box.offset(clearance)
+            other = next(
+                (s for s in self.overlapping(expanded)
+                 if s.net_no != net_no and s.on_layer(layer)
+                 and (s.blocks == "all" or s.blocks == kind + "s")),
+                None,
+            )
+            log.append((net_no, kind, layer, box, clearance, other))
+        return hit
+
+    ShapeSearchTree.clearance_conflict = conflict
+    return log
+
+
+def _gap(a, b) -> int:
+    dx = max(b.ll.x - a.ur.x, a.ll.x - b.ur.x, 0)
+    dy = max(b.ll.y - a.ur.y, a.ll.y - b.ur.y, 0)
+    return max(dx, dy)
+
+
 def _fresh(seen) -> GridRouter:
     router = grid_router.GridRouter(*seen["args"], **seen["kwargs"])
     router._conns = router._build_connections()
@@ -111,12 +142,14 @@ def _flood(router: GridRouter, pin, net_no: int, conns) -> tuple[int, Counter]:
 
 
 def diagnose(
-    dsn_text: str, edge_clearance_mm: float | None, resolution: int = 2, shove: bool = False
+    dsn_text: str, edge_clearance_mm: float | None, resolution: int = 2, shove: bool = False,
+    access_cost: float = 0.0,
 ) -> dict:
     dsn = parse_dsn(dsn_text)
     names = {i + 1: n.name for i, n in enumerate(dsn.nets)}
     scale = max(dsn.resolution.value, 1)
     seen = _capture_router()
+    conflicts = _capture_conflicts()
     exact = route_board_exact(
         build_board(dsn),
         trace_width=round(_rule_width_dsn(dsn) * scale),
@@ -125,6 +158,7 @@ def diagnose(
         edge_clearance=_mm_to_board(dsn, scale, edge_clearance_mm),
         resolution=resolution,
         shove=shove,
+        access_cost=access_cost,
     )
     routed = seen["router"]
     best = routed._diag_best
@@ -137,6 +171,19 @@ def diagnose(
         conns[idx].a_end, conns[idx].b_end = a_end, b_end
         state._commit(conns[idx], path)
     empty = _fresh(seen)
+    # refusals in the order the check made them, one per rejected connection
+    per_net: dict[int, list] = {}
+    for net_no, kind, layer, box, clearance, other in conflicts:
+        if other is None:
+            what = "?"
+        elif other.net_no == -1:
+            what = "keepout"
+        else:
+            what = ("trace/via of " if other.routed else "pad of ") + names.get(other.net_no, "?")
+        short = (clearance - _gap(box, other.tile)) / scale / 1000 if other is not None else 0
+        per_net.setdefault(net_no, []).append(
+            {"copper": kind, "layer": layer, "against": what, "short_mm": round(short, 4)}
+        )
     by_key = {(c.net_no, *_ends_of(c)): c for c in conns}
 
     rows = []
@@ -150,6 +197,8 @@ def diagnose(
         conn = by_key.get(key)
         if key not in grid_failed:
             row["kind"] = "rejected"
+            if per_net.get(net_no):
+                row["conflict"] = per_net[net_no].pop(0)
         elif conn is None:
             row["kind"] = "unknown"
         elif empty._search(empty._conns[conn.index], allow_ripup=False, conns=empty._conns) is None:
@@ -177,14 +226,20 @@ def main(argv: list[str] | None = None) -> int:
     ap.add_argument("--edge-clearance", type=float, metavar="MM")
     ap.add_argument("--grid-resolution", type=int, default=2, metavar="K")
     ap.add_argument("--shove", action="store_true", help="as mckicad routes")
+    ap.add_argument("--access-cost", type=float, default=0.0)
     ap.add_argument("--json", type=Path, help="also write the full table here")
     args = ap.parse_args(argv)
 
-    report = diagnose(args.dsn.read_text(), args.edge_clearance, args.grid_resolution, args.shove)
+    report = diagnose(args.dsn.read_text(), args.edge_clearance, args.grid_resolution, args.shove,
+                      args.access_cost)
     for row in report["failures"]:
         extra = ""
         for w in row.get("walled", []):
             extra += f"  [{w['pin']} reaches {w['reach']} cells, walled by {', '.join(w['walls'])}]"
+        if "conflict" in row:
+            c = row["conflict"]
+            extra += (f"  [{c['copper']} on layer {c['layer']} {c['short_mm']} mm too close"
+                      f" to {c['against']}]")
         print(f"{row['kind']:11} {row['net']}: {row['a']} to {row['b']}{extra}")
     total = sum(report["counts"].values())
     print(f"\n{total} failed: " + ", ".join(f"{k} {v}" for k, v in sorted(report["counts"].items())),