warehack.ing/rpmroute
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Route multi-pin nets as trees: spanning-tree pairs, T into routed copper

Browse Source 
A net's pin groups were joined as a chain in pin order, and each
connection had to end on one chosen pin. Groups are now paired by a
minimum spanning tree (Manhattan distance between their nearest pins), and
a connection may start or end on any copper its net has already routed on
that side (path cells, via cells on every layer; not walled cells, whose
via moves into the pad). Plane nets keep their drops to the plane.

A connection that tees onto another records it as an anchor. Ripping a
connection rips what hangs on it, transitively, inside the same rip-up
transaction, so rollback restores all of them. The exact engine gets the
connections in commit order with their anchors and drops a T whose anchor
it rejects. --no-tree restores the chain.
This commit is contained in:
rsp2k
2026-10-05 12:21:00 -06:00
parent 89d6d8d9dd
commit b91e44e360
6 changed files with 338 additions and 14 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/freeroute/route/grid_router.py
+158 -10
View File
@@ -65,7 +65,7 @@ class RouteResult:
__slots__ = (
"wires", "vias", "half_width", "unrouted", "connections", "connection_ends", "failed",
"net_half", "narrowed",
"net_half", "narrowed", "connection_anchors",
)
def __init__(self, half_width: int) -> None:
@@ -79,6 +79,9 @@ class RouteResult:
#: what each routed connection joins, and the zone both ends sit in
#: (or ""), parallel to ``connections``
self.connection_ends: list[tuple[str, str, str]] = []
#: for each routed connection, the earlier ones (positions in
#: ``connections``) whose copper it ended on, parallel to ``connections``
self.connection_anchors: list[tuple[int, ...]] = []
#: connections left unrouted: (net_no, one end, the other end)
self.failed: list[tuple[int, str, str]] = []
#: half width of each net routed wider than the default (its class)
@@ -127,6 +130,9 @@ class _Connection:
"half",
"stubs",
"stub_near",
"anchors",
"copper",
"seq",
)
def __init__(self, index: int, net_no: int, a: Pin, b: Pin) -> None:
@@ -158,6 +164,14 @@ class _Connection:
# routed at the default width instead; the half width it went in at
self.narrow = False
self.half = 0
# connections whose copper this one ended on (a T into its net's
# tree): ripping one of them leaves this one dangling
self.anchors: frozenset[int] = frozenset()
# the nodes of its committed copper (path cells, via cells on every
# layer), where another connection of its net may end
self.copper: frozenset[Node] = frozenset()
# commit order: a connection is always committed after its anchors
self.seq = 0
class GridRouter:
@@ -188,8 +202,17 @@ class GridRouter:
net_widths: dict[int, int] | None = None,
via_drill: int | None = None,
hole_to_hole: int = 0,
tree_nets: bool = True,
) -> None:
self.board = board
# Multi-pin nets: pair a net's pin groups by a minimum spanning tree,
# and let a connection start or end on copper its net already routed
# (a T into the tree), not only on one chosen pin.
self.tree = bool(tree_nets)
self._dependents: dict[int, set[int]] = {}
self._commits = 0
self._plane_nets: set[int] = set()
self._net_conns: dict[int, list[_Connection]] = {}
# Pin access: while a pin still has connections to route, the cells
# its route would leave by (its end cells, the via it may need there,
# and the clearance around both) cost other nets this much extra, so
@@ -699,6 +722,13 @@ class GridRouter:
goal_cell = self._group_target(conn.a_group)
starts = self._group_ends(conn.a_group, conn.net_no, conns, allow_ripup)
goals = self._group_ends(conn.b_group, conn.net_no, conns, allow_ripup)
# either side may also start or end on copper its net already routed
a_tree = self._tree_ends(conn, conn.a_group)
b_tree = self._tree_ends(conn, conn.b_group)
for node in a_tree:
starts.setdefault(node, None)
for node in b_tree:
goals.setdefault(node, None)
if not starts or not goals:
return None
# A start that is already an end joins at once, except that ending on
@@ -711,6 +741,7 @@ class GridRouter:
]
if common:
conn.a_end, conn.b_end = starts[common[0]], goals[common[0]]
conn.anchors = _anchors([common[0]], starts, goals, a_tree, b_tree)
return [common[0]]
net_no = conn.net_no
@@ -776,6 +807,7 @@ class GridRouter:
if ok:
path = _reconstruct(came_from, current)
conn.a_end, conn.b_end = starts.get(path[0]), end
conn.anchors = _anchors(path, starts, goals, a_tree, b_tree)
return path
cx, cy, cl = current
base = g_score[current]
@@ -822,6 +854,49 @@ class GridRouter:
)
return None
def _tree_ends(self, conn: _Connection, group) -> dict[Node, int]:
"""Copper its net has already routed on ``group``'s side of ``conn``,
each node mapped to the connection that laid it: a route may start or
end anywhere on it. Empty for plane nets, which keep their drops to
the plane, and when tree routing is off."""
if not self.tree or conn.net_no in self._plane_nets:
return {}
adjacent: dict[int, list[tuple[int, _Connection]]] = {}
for c in self._net_conns.get(conn.net_no, ()):
if c is conn or not c.routed:
continue
a, b = id(c.a_group), id(c.b_group)
adjacent.setdefault(a, []).append((b, c))
adjacent.setdefault(b, []).append((a, c))
owners: dict[Node, int] = {}
seen = {id(group)}
stack = [id(group)]
while stack:
for other, c in adjacent.get(stack.pop(), ()):
for node in c.copper:
# a walled cell's via moved into the pad: no copper there
if node not in self._keepout and node not in self._via_only:
owners.setdefault(node, c.index)
if other not in seen:
seen.add(other)
stack.append(other)
return owners
def _with_dependents(self, victims: list[_Connection], conns: list[_Connection]) -> list[_Connection]:
"""``victims`` and every routed connection that ended on their copper,
directly or through another: ripping a route rips the routes teed onto
it, which would otherwise dangle. Anchors come before what hangs on
them, as they were committed."""
found = {v.index: v for v in victims}
stack = list(victims)
while stack:
for i in self._dependents.get(stack.pop().index, ()):
c = conns[i]
if c.routed and i not in found:
found[i] = c
stack.append(c)
return sorted(found.values(), key=lambda c: (c.seq, c.index))
# --- pin stubs ----------------------------------------------------------
# A pin rarely sits on a cell centre, so every route starts and ends with a
# short stub from the pin to its first cell. The grid has to see that
@@ -1431,6 +1506,13 @@ class GridRouter:
# via k joins wire segments k and k + 1
conn.vias[0 if idx == 0 else idx - 1] = location
conn.routed = True
self._commits += 1
conn.seq = self._commits
conn.copper = frozenset(path) | frozenset(
(*cell, layer) for cell in conn.via_cells for layer in self.layers
)
for anchor in conn.anchors:
self._dependents.setdefault(anchor, set()).add(conn.index)
self._settle(conn, -1)
def _forget_stubs(self, conn: _Connection) -> None:
@@ -1473,6 +1555,12 @@ class GridRouter:
conn.wires = []
conn.vias = []
conn.routed = False
for anchor in conn.anchors:
hanging = self._dependents.get(anchor)
if hanging is not None:
hanging.discard(conn.index)
conn.anchors = frozenset()
conn.copper = frozenset()
conn.rip_count += 1
self._settle(conn, +1)
@@ -1688,7 +1776,7 @@ class GridRouter:
crossed |= self._stub_owners(
end, node[:2], node[2], conn.net_no, conns, self._conn_half(conn)
)
victims = [conns[i] for i in sorted(crossed)]
victims = self._with_dependents([conns[i] for i in sorted(crossed)], conns)
if self.rollback:
return self._ripup_transaction(conn, path, victims, conns)
for victim in victims:
@@ -1699,7 +1787,7 @@ class GridRouter:
def _ripup_transaction(self, conn, path, victims, conns) -> bool:
"""Route ``conn`` through ``victims``, reroute them at once in free
space, and undo it all if fewer connections end up routed."""
saved = [(v, v.path, v.a_end, v.b_end, v.rip_count) for v in victims]
saved = [(v, v.path, v.a_end, v.b_end, v.rip_count, v.anchors) for v in victims]
own_rips = conn.rip_count
for victim in victims:
self._rip(victim)
@@ -1717,8 +1805,8 @@ class GridRouter:
self._rip(victim)
self._rip(conn)
conn.rip_count = own_rips
for victim, old_path, a_end, b_end, rips in saved:
victim.a_end, victim.b_end = a_end, b_end
for victim, old_path, a_end, b_end, rips, anchors in saved:
victim.a_end, victim.b_end, victim.anchors = a_end, b_end, anchors
self._commit(victim, old_path)
victim.rip_count = rips
return False
@@ -1740,6 +1828,7 @@ class GridRouter:
planes_by_net.setdefault(zone.net_nos[0], []).append(zone)
plane_ids = frozenset(id(z) for zs in planes_by_net.values() for z in zs)
conns: list[_Connection] = []
self._plane_nets: set[int] = set()
nets = set(pins_by_net) | set(zones_by_net) | set(planes_by_net)
# deterministic: fewer-pin nets first, then by net number
for net_no in sorted(nets, key=lambda n: (len(pins_by_net.get(n, [])), n)):
@@ -1752,12 +1841,18 @@ class GridRouter:
# a plane net: every other group goes straight to the plane
# (usually a stub and a via), not pad to pad across the board
pairs = [(g, hubs[0]) for g in groups if g is not hubs[0]]
self._plane_nets.add(net_no)
elif self.tree:
pairs = _spanning_pairs(groups)
else:
pairs = list(zip(groups, groups[1:], strict=False))
for ga, gb in pairs:
conn = _Connection(len(conns), net_no, _first(ga[0]), _first(gb[0]))
conn.a_group, conn.b_group = ga, gb
conns.append(conn)
self._net_conns: dict[int, list[_Connection]] = {}
for conn in conns:
self._net_conns.setdefault(conn.net_no, []).append(conn)
return conns
def _fixed_pieces(self, net_no: int) -> list[_FixedPiece]:
@@ -1807,18 +1902,22 @@ class GridRouter:
return wide, narrowed
def _snapshot(self, conns: list[_Connection]) -> list[tuple]:
# in commit order, so a connection teed onto another comes after it;
# its anchors as positions in this list
routed = sorted((c for c in conns if c.routed), key=lambda c: (c.seq, c.index))
position = {c.index: i for i, c in enumerate(routed)}
return [
(c.net_no, [(layer, list(pts)) for layer, pts in c.wires], list(c.vias),
(*_ends_of(c), self._left_to_zone(c)))
for c in conns
if c.routed
(*_ends_of(c), self._left_to_zone(c)),
tuple(sorted(position[a] for a in c.anchors if a in position)))
for c in routed
]
def _result_from(self, snapshot, unrouted: int) -> RouteResult:
result = RouteResult(self.half_width)
written: set[tuple[int, IntPoint]] = set()
result.unrouted = unrouted
for net_no, wires, vias, ends in snapshot:
for net_no, wires, vias, ends, anchors in snapshot:
for layer, points in wires:
result.add_wire(net_no, layer, points)
for location in vias:
@@ -1829,7 +1928,8 @@ class GridRouter:
result.add_via(net_no, location)
result.connections.append((net_no, wires, vias))
result.connection_ends.append(ends)
routed = {ends[:2] + (net_no,) for net_no, _w, _v, ends in snapshot}
result.connection_anchors.append(anchors)
routed = {ends[:2] + (net_no,) for net_no, _w, _v, ends, _a in snapshot}
result.failed = [
(c.net_no, *_ends_of(c), self._left_to_zone(c))
for c in self._conns
@@ -1842,6 +1942,52 @@ def _first(items):
return items[0] if items else None
def _anchors(path, starts, goals, a_tree, b_tree) -> frozenset[int]:
"""The connections whose copper a found path starts or ends on."""
found = set()
if starts.get(path[0]) is None and path[0] in a_tree:
found.add(a_tree[path[0]])
if goals.get(path[-1]) is None and path[-1] in b_tree:
found.add(b_tree[path[-1]])
return frozenset(found)
def _group_points(group) -> list[tuple[int, int]]:
pins, zones = group
if pins:
return [(p.location.x, p.location.y) for p in pins]
points = []
for zone in zones:
box = zone.bounding_box()
points.append(((box.ll.x + box.ur.x) // 2, (box.ll.y + box.ur.y) // 2))
return points or [(0, 0)]
def _spanning_pairs(groups) -> list[tuple]:
"""A minimum spanning tree over a net's groups (Prim, Manhattan distance
between their nearest pins), as (in the tree, joining it) pairs: each
connection joins the nearest group not yet joined, not the next in pin
order."""
if len(groups) < 2:
return []
points = [_group_points(g) for g in groups]
def gap(i: int, j: int) -> int:
return min(abs(ax - bx) + abs(ay - by) for ax, ay in points[i] for bx, by in points[j])
best = {j: (gap(0, j), 0) for j in range(1, len(groups))}
pairs = []
while best:
j = min(best, key=lambda k: (best[k][0], k))
_, i = best.pop(j)
pairs.append((groups[i], groups[j]))
for k in best:
d = gap(j, k)
if d < best[k][0]:
best[k] = (d, j)
return pairs
def _group_label(group) -> str:
pins, zones = group
parts = [f"{p.component_ref}-{p.name}" for p in pins[:3]]
@@ -2039,6 +2185,7 @@ def route_board(
access_cost: float = 0.0,
negotiate: int = 0,
rollback: bool = True,
tree_nets: bool = True,
net_widths: dict[int, int] | None = None,
via_drill: int | None = None,
hole_to_hole: int = 0,
@@ -2062,6 +2209,7 @@ def route_board(
access_cost=access_cost,
negotiate=negotiate,
rollback=rollback,
tree_nets=tree_nets,
net_widths=net_widths,
via_drill=via_drill,
hole_to_hole=hole_to_hole,