archgraph-layout 1.0.0__tar.gz → 2.0.0__tar.gz

{archgraph_layout-1.0.0/archgraph_layout.egg-info → archgraph_layout-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: archgraph-layout
-Version: 1.0.0
+Version: 2.0.0
 Summary: Hierarchical architecture diagrams from XML with floorplanning and orthogonal routing
 Author: Ellie Hartung
 License-Expression: MIT
@@ -96,7 +96,7 @@ XML ──► parse/expand ──► size blocks ──► auto-cluster huge lev
     ──► hierarchical floorplanning (bottom-up, several passes)
     ──► detailed QP placement + edge alignment (bottom-up, then top-down)
     ──► port sides (router-chosen) ──► orthogonal routing ──► congestion-driven spacing
-    ──► nudging ──► labels ──► SVG / HTML / JSON / PNG
+    ──► nudging ──► SVG / HTML / JSON / PNG
 ```
 
 **Floorplanning (placement).** Each subsystem level is a floorplanning problem over
@@ -151,19 +151,19 @@ the border of a subsystem that contains neither end is almost forbidden. Specifi
   painted over a hop. Crossings closer together than one hop share a single flat bridge.
   Each hop bumps to the side where the crossed wire has room (clear of its arrowheads,
   corners and neighbouring parallel wires). A crossing right next to a corner of the
-  horizontal wire hops sideways on the vertical wire instead. Bit-width markers and edge
-  labels keep clear of crossings.
+  horizontal wire hops sideways on the vertical wire instead. Bit-width markers
+  keep clear of crossings.
 
 ---
 
 ## Command line
 
 ```
-archgraph render  FILE.xml [-o OUT.svg|.html|.json|.png ...] [--stats]
+archgraph render  FILE.xml [-o OUT.svg|.html|.json|.png ...] [--stats] [--progress]
                   [--quality draft|normal|high|max] [--aspect 16:9] [--theme dark]
                   [--direction TB] [--seed N] [--set key=value ...]
 archgraph validate FILE.xml        # parse, report errors (with line numbers) and warnings
-archgraph stats    FILE.xml        # lay out and print quality metrics as JSON
+archgraph stats    FILE.xml [--progress] # lay out and print quality metrics as JSON
 archgraph expand   FILE.xml        # print the XML after templates/loops/includes expand
 archgraph FILE.xml -o out.svg      # shorthand for render
 ```
@@ -172,6 +172,21 @@ archgraph FILE.xml -o out.svg      # shorthand for render
 violations, wires through blocks, wire length hugging walls, minimum port escape,
 flow-consistency counts and timings.
 
+`--progress` shows elapsed time and compact stage bars for port assignment, routing,
+and congestion refinement, plus placement completion, output writing, and `Done`.
+Bars update in place in a terminal; redirected progress logs retain stage milestones.
+Placement shows completed passes and the current subsystem or optimization step.
+A spinner and elapsed time refresh during long computations; redirected logs receive
+an activity update every five seconds while a stage is running.
+Updates go to stderr, so `stats` JSON on stdout can still be redirected to a file.
+Counts describe the current stage; congestion counts show refinements performed out
+of the configured maximum and can finish early. For example:
+
+```sh
+archgraph render examples/soc.xml -o soc.html --progress
+archgraph stats examples/basic.xml --progress > metrics.json
+```
+
 ## Python API
 
 ```python

{archgraph_layout-1.0.0 → archgraph_layout-2.0.0}/README.md

@@ -71,7 +71,7 @@ XML ──► parse/expand ──► size blocks ──► auto-cluster huge lev
     ──► hierarchical floorplanning (bottom-up, several passes)
     ──► detailed QP placement + edge alignment (bottom-up, then top-down)
     ──► port sides (router-chosen) ──► orthogonal routing ──► congestion-driven spacing
-    ──► nudging ──► labels ──► SVG / HTML / JSON / PNG
+    ──► nudging ──► SVG / HTML / JSON / PNG
 ```
 
 **Floorplanning (placement).** Each subsystem level is a floorplanning problem over
@@ -126,19 +126,19 @@ the border of a subsystem that contains neither end is almost forbidden. Specifi
   painted over a hop. Crossings closer together than one hop share a single flat bridge.
   Each hop bumps to the side where the crossed wire has room (clear of its arrowheads,
   corners and neighbouring parallel wires). A crossing right next to a corner of the
-  horizontal wire hops sideways on the vertical wire instead. Bit-width markers and edge
-  labels keep clear of crossings.
+  horizontal wire hops sideways on the vertical wire instead. Bit-width markers
+  keep clear of crossings.
 
 ---
 
 ## Command line
 
 ```
-archgraph render  FILE.xml [-o OUT.svg|.html|.json|.png ...] [--stats]
+archgraph render  FILE.xml [-o OUT.svg|.html|.json|.png ...] [--stats] [--progress]
                   [--quality draft|normal|high|max] [--aspect 16:9] [--theme dark]
                   [--direction TB] [--seed N] [--set key=value ...]
 archgraph validate FILE.xml        # parse, report errors (with line numbers) and warnings
-archgraph stats    FILE.xml        # lay out and print quality metrics as JSON
+archgraph stats    FILE.xml [--progress] # lay out and print quality metrics as JSON
 archgraph expand   FILE.xml        # print the XML after templates/loops/includes expand
 archgraph FILE.xml -o out.svg      # shorthand for render
 ```
@@ -147,6 +147,21 @@ archgraph FILE.xml -o out.svg      # shorthand for render
 violations, wires through blocks, wire length hugging walls, minimum port escape,
 flow-consistency counts and timings.
 
+`--progress` shows elapsed time and compact stage bars for port assignment, routing,
+and congestion refinement, plus placement completion, output writing, and `Done`.
+Bars update in place in a terminal; redirected progress logs retain stage milestones.
+Placement shows completed passes and the current subsystem or optimization step.
+A spinner and elapsed time refresh during long computations; redirected logs receive
+an activity update every five seconds while a stage is running.
+Updates go to stderr, so `stats` JSON on stdout can still be redirected to a file.
+Counts describe the current stage; congestion counts show refinements performed out
+of the configured maximum and can finish early. For example:
+
+```sh
+archgraph render examples/soc.xml -o soc.html --progress
+archgraph stats examples/basic.xml --progress > metrics.json
+```
+
 ## Python API
 
 ```python

{archgraph_layout-1.0.0 → archgraph_layout-2.0.0}/archgraph/__init__.py

@@ -18,11 +18,12 @@ from typing import Optional
 
 from .model import ArchGraphError, Graph
 from .parser import parse_file, parse_string
+from .progress import report
 # import subpackages eagerly so the public functions below are not shadowed by them
 from .placement import engine as _engine  # noqa: E402
 from . import routing as _routing  # noqa: E402
 
-__version__ = "1.0.0"
+__version__ = "2.0.0"
 __all__ = ["load", "loads", "layout", "route", "build", "to_svg", "to_html", "to_json", "to_png", "save",
            "ArchGraphError", "Graph", "__version__"]
 
@@ -44,7 +45,7 @@ def layout(g: Graph) -> Graph:
 
 
 def route(g: Graph) -> Graph:
-    """Route all connections and buses, nudge them apart and place labels."""
+    """Route all connections and buses and nudge them apart."""
     _routing.route(g)
     from .geometry import Rect
     rects = [e.rect for e in g.root.iter_descendants()]
@@ -55,6 +56,7 @@ def route(g: Graph) -> Graph:
 def build(source: str, **overrides) -> Graph:
     """Parse (file path or XML text), apply setting overrides, lay out and route."""
     t0 = time.time()
+    report("Parsing XML")
     if os.path.exists(source) or source.lower().endswith(".xml"):
         g = parse_file(source)
     else:

{archgraph_layout-1.0.0 → archgraph_layout-2.0.0}/archgraph/cli.py

@@ -9,6 +9,7 @@ import time
 
 from . import __version__
 from .model import ArchGraphError
+from .progress import TerminalProgress, report, reporting
 
 
 def _common(p):
@@ -20,6 +21,7 @@ def _common(p):
     p.add_argument("--aspect", help="target aspect ratio, e.g. 16:9, 1.5, square")
     p.add_argument("--direction", help="default flow LR | RL | TB | BT")
     p.add_argument("--seed", type=int, help="random seed (layouts are deterministic per seed)")
+    p.add_argument("--progress", action="store_true", help="show stage progress bars and elapsed time on stderr")
 
 
 def _overrides(args):
@@ -61,6 +63,11 @@ def main(argv=None) -> int:
             return main(["render"] + list(argv))
         ap.print_help()
         return 1
+    with reporting(TerminalProgress() if getattr(args, "progress", False) else None):
+        return _run(args)
+
+
+def _run(args) -> int:
     try:
         if args.cmd == "validate":
             from .parser import parse_file
@@ -89,17 +96,25 @@ def main(argv=None) -> int:
         for w in g.warnings:
             print("warning:", w, file=sys.stderr)
         if args.cmd == "stats":
+            report("Computing quality metrics")
             print(json.dumps(metrics(g), indent=1))
+            report("Done")
             return 0
         outs = args.output or [os.path.splitext(args.input)[0] + ".svg"]
         for o in outs:
+            report(f"Writing {o}")
             save(g, o, scale=args.scale)
-            print(f"wrote {o}")
+            if not args.progress:
+                print(f"wrote {o}")
         if args.stats:
+            report("Computing quality metrics")
             print(json.dumps(metrics(g), indent=1))
-        print(f"done in {time.time() - t0:.1f}s", file=sys.stderr)
+        report("Done")
+        if not args.progress:
+            print(f"done in {time.time() - t0:.1f}s", file=sys.stderr)
         return 0
     except ArchGraphError as ex:
+        report("Failed")
         print("error:", file=sys.stderr)
         for m in ex.messages:
             print("  " + m, file=sys.stderr)

{archgraph_layout-1.0.0 → archgraph_layout-2.0.0}/archgraph/model.py

@@ -53,7 +53,6 @@ class Settings:
     junction_dots: bool = True
     shadows: bool = True
     background_grid: bool = False
-    edge_labels: bool = True
     default_shape: str = "box"
     bundle_parallel: bool = False      # merge parallel edges between the same endpoints
     margin: float = 24.0               # outer margin of the drawing
@@ -184,6 +183,7 @@ class Node(Element):
     min_h: Optional[float] = None
     virtual: bool = False              # internal helper node (not drawn)
     is_note: bool = False
+    layout_direction: str = "LR"       # inherited flow used by shape geometry
 
     kind = "node"
 
@@ -246,9 +246,6 @@ class Edge:
     id: str
     src: Endpoint
     dst: Endpoint
-    label: str = ""
-    src_label: str = ""
-    dst_label: str = ""
     classes: List[str] = field(default_factory=list)
     attrs: Dict[str, str] = field(default_factory=dict)
     style: Dict[str, Any] = field(default_factory=dict)
@@ -267,9 +264,6 @@ class Edge:
     line: Optional[int] = None
     # results
     points: List[Point] = field(default_factory=list)
-    label_pos: Optional[Tuple[float, float, float, float]] = None   # x, y, w, h (centre)
-    src_label_pos: Optional[Tuple[float, float]] = None
-    dst_label_pos: Optional[Tuple[float, float]] = None
     routed: bool = False
     uid: int = field(default_factory=lambda: next(_counter))
 
@@ -286,14 +280,12 @@ class Edge:
 @dataclass(eq=False, repr=False)
 class BusTap:
     endpoint: Endpoint
-    label: str = ""
     direction: Optional[str] = None
 
 
 @dataclass(eq=False, repr=False)
 class Bus:
     id: str
-    label: str = ""
     taps: List[BusTap] = field(default_factory=list)
     classes: List[str] = field(default_factory=list)
     attrs: Dict[str, str] = field(default_factory=dict)
@@ -305,7 +297,6 @@ class Bus:
     # results
     segments: List[Tuple[Point, Point]] = field(default_factory=list)
     junctions: List[Point] = field(default_factory=list)
-    label_pos: Optional[Tuple[float, float, float, float]] = None
     routed: bool = False
     uid: int = field(default_factory=lambda: next(_counter))
 

{archgraph_layout-1.0.0 → archgraph_layout-2.0.0}/archgraph/parser.py

@@ -30,7 +30,7 @@ LINE = "__line__"
 FILE = "__file__"
 
 NODE_TAGS = {"node", "component", "block", "unit", "item", "instance"}
-SHAPE_TAGS = {"chip": "chip", "memory": "cylinder", "storage": "cylinder", "database": "cylinder",
+SHAPE_TAGS = {"memory": "cylinder", "storage": "cylinder", "database": "cylinder",
               "fifo": "fifo", "mux": "mux", "demux": "demux", "register": "register", "processor": "box",
               "sensor": "ellipse", "connector": "connector", "alu": "alu", "adder": "adder", "port-pin": "pin"}
 SUBSYSTEM_TAGS = {"subsystem", "group", "cluster", "module", "domain", "board", "rack", "package", "die",
@@ -49,7 +49,7 @@ REF_ATTRS = {"from", "to", "src", "dst", "source", "target", "nodes", "path", "a
 SHAPE_ALIASES = {"memory": "cylinder", "storage": "cylinder", "database": "cylinder", "db": "cylinder",
                  "ram": "cylinder", "disk": "cylinder", "rect": "box", "rectangle": "box", "square": "box",
                  "roundbox": "rounded", "round": "rounded", "oval": "ellipse", "buffer": "triangle",
-                 "amplifier": "triangle", "amp": "triangle", "ic": "chip", "package": "folder",
+                 "amplifier": "triangle", "amp": "triangle", "package": "folder",
                  "queue": "fifo", "flop": "register", "reg": "register", "flipflop": "register",
                  "text": "plaintext", "label": "plaintext", "dsp": "multiplier", "terminal": "pin",
                  "io": "pin", "processor": "cpu", "pill": "pill", "monitor": "display", "screen": "display"}
@@ -62,7 +62,7 @@ def normalize_shape(s: str) -> str:
 
 KNOWN_SHAPES = {"box", "rect", "rectangle", "rounded", "roundbox", "ellipse", "oval", "circle", "diamond",
                 "hexagon", "octagon", "parallelogram", "trapezoid", "cylinder", "note", "folder", "component",
-                "chip", "cloud", "document", "fifo", "register", "mux", "demux", "alu", "adder", "multiplier",
+                "cloud", "document", "fifo", "register", "mux", "demux", "alu", "adder", "multiplier",
                 "triangle", "invtriangle", "pin", "connector", "stack", "plaintext", "none", "tab", "cpu",
                 "pill", "cross", "star", "shield", "gear", "antenna", "battery", "display"}
 
@@ -1086,25 +1086,28 @@ class Builder:
             e.ports[pid] = p
         return Endpoint(element=e, port=p, ref=ref)
 
-    EDGE_ATTRS = {"from", "to", "src", "dst", "source", "target", "label", "src-label", "tail-label",
-                  "dst-label", "head-label", "class", "dir", "directed", "arrowhead", "arrowtail", "weight",
+    EDGE_ATTRS = {"from", "to", "src", "dst", "source", "target", "class", "dir", "directed", "arrowhead", "arrowtail", "weight",
                   "minlen", "constraint", "layout", "straight", "bits", "width-bits", "bus-width", "net",
                   "tooltip", "id", "nodes", "path", "priority", "lanes"}
 
+    def _connection_attrs(self, el: ET.Element, attrs: Dict[str, Any]) -> Dict[str, Any]:
+        """Ignore retired connection labels while still accepting older XML files."""
+        retired = {"label", "src-label", "tail-label", "dst-label", "head-label"}
+        if retired.intersection(attrs) or el.find("label") is not None or (el.text or "").strip():
+            self.graph.warn(f"{_loc(el)}: connection labels are no longer supported; ignored")
+        return {k: v for k, v in attrs.items() if k not in retired}
+
     def _make_edges(self, el: ET.Element, extra: Dict[str, Any], sub: Subsystem):
         g = self.graph
         attrs = {k: v for k, v in el.attrib.items() if not k.startswith("__")}
         attrs.update({k: v for k, v in extra.items() if not k.startswith("__")})
+        attrs = self._connection_attrs(el, attrs)
         where = _loc(el)
         srcs = _split_refs(attrs.get("from") or attrs.get("src") or attrs.get("source"))
         dsts = _split_refs(attrs.get("to") or attrs.get("dst") or attrs.get("target"))
         if not srcs or not dsts:
             self.errors.append(f"{where}: <{el.tag}> needs from= and to=")
             return
-        label = attrs.get("label")
-        if label is None:
-            lab_el = el.find("label")
-            label = (lab_el.text or "").strip() if lab_el is not None else (el.text or "").strip()
         classes = _split_refs(attrs.get("class"))
         raw_style = {}
         for k, v in attrs.items():
@@ -1127,11 +1130,9 @@ class Builder:
                 de = self._endpoint(d, where, eid, "d")
                 if se is None or de is None:
                     continue
-                e = Edge(id=eid, src=se, dst=de, label=label or "", classes=list(classes), style=dict(style),
+                e = Edge(id=eid, src=se, dst=de, classes=list(classes), style=dict(style),
                          line=_line(el))
                 e.attrs = attrs
-                e.src_label = attrs.get("src-label", attrs.get("tail-label", ""))
-                e.dst_label = attrs.get("dst-label", attrs.get("head-label", ""))
                 dirv = (attrs.get("dir") or "").lower()
                 if attrs.get("directed") is not None:
                     e.directed = st.parse_bool(attrs.get("directed"), True)
@@ -1165,36 +1166,38 @@ class Builder:
         g = self.graph
         where = _loc(el)
         bid = el.get("id") or f"bus{len(g.buses) + 1}"
-        bus = Bus(id=bid, label=el.get("label", bid), line=_line(el))
+        attrs = self._connection_attrs(el, el.attrib)
+        bus = Bus(id=bid, line=_line(el))
         bus.classes = _split_refs(el.get("class"))
         bus.bits = el.get("bits", el.get("width-bits", ""))
         bus.orientation = el.get("orientation", "auto")
         bus.tooltip = el.get("tooltip", "")
-        raw = {k: v for k, v in el.attrib.items()
-               if k not in ("id", "label", "class", "bits", "orientation", "taps", "tooltip", "width-bits")
+        raw = {k: v for k, v in attrs.items()
+               if k not in ("id", "class", "bits", "orientation", "taps", "tooltip", "width-bits")
                and not k.startswith("__")}
         if "style" in raw and raw["style"].lower() not in st.DASH_PATTERNS:
             raw.update(st.parse_css_style(raw.pop("style")))
         bus.style = st.normalize_style(raw)
         k = 0
-        tap_specs: List[Tuple[str, str, Optional[str], Optional[int]]] = []
+        tap_specs: List[Tuple[str, Optional[str], Optional[int]]] = []
         for t in _split_refs(el.get("taps")):
-            tap_specs.append((t, "", None, _line(el)))
+            tap_specs.append((t, None, _line(el)))
         for c in el:
             if c.tag in ("tap", "member", "endpoint", "connect", "pin"):
+                self._connection_attrs(c, c.attrib)
                 ref = c.get("node") or c.get("ref") or c.get("to") or c.get("id")
                 if not ref:
                     self.errors.append(f"{_loc(c)}: <tap> needs node=")
                     continue
                 if c.get("port") and ":" not in ref:
                     ref = f"{ref}:{c.get('port')}"
-                tap_specs.append((ref, c.get("label", ""), c.get("dir", c.get("direction")), _line(c)))
-        for ref, lab, d, ln in tap_specs:
+                tap_specs.append((ref, c.get("dir", c.get("direction")), _line(c)))
+        for ref, d, ln in tap_specs:
             ep = self._endpoint(ref, f"{_loc(el)}" if ln is None else f"{os.path.basename(el.get(FILE, ''))}:{ln}",
                                 f"bus~{bid}~{k}", "t")
             k += 1
             if ep is not None:
-                bus.taps.append(BusTap(endpoint=ep, label=lab, direction=d))
+                bus.taps.append(BusTap(endpoint=ep, direction=d))
         if len(bus.taps) < 2:
             self.errors.append(f"{where}: bus '{bid}' needs at least two taps")
             return
@@ -1355,11 +1358,6 @@ def _bundle_parallel(g: Graph):
             continue
         first = es[0]
         first.multiplicity = sum(x.multiplicity for x in es)
-        labels = [x.label for x in es if x.label]
-        if labels:
-            uniq = list(dict.fromkeys(labels))
-            first.label = ", ".join(uniq[:3]) + (" …" if len(uniq) > 3 else "")
-        first.label = (first.label + "  " if first.label else "") + f"×{first.multiplicity}"
         for x in es[1:]:
             dropped.add(x)
             for ep in (x.src, x.dst):
@@ -1435,8 +1433,6 @@ def _apply_styles(g: Graph):
         base.update(e.style)
         if "color" in base and "stroke" not in e.style:
             base["stroke"] = base["color"]
-        if "label-color" not in cls and "label-color" not in e.style and "color" in (cls.keys() | e.style.keys()):
-            base["label-color"] = st.mix(base["color"], theme["text"], 0.35)
         if "stroke-width-scale" in e.style:
             base["stroke-width"] = base.get("stroke-width", 1.3) * e.style["stroke-width-scale"]
         for raw in [st.class_raw(e.classes, g.classes, "edge")]:

{archgraph_layout-1.0.0 → archgraph_layout-2.0.0}/archgraph/placement/engine.py

@@ -6,6 +6,7 @@ from typing import Dict
 
 from ..geometry import Rect
 from ..model import Graph, Subsystem
+from ..progress import report
 from . import sizing
 from .hierarchy import (HierarchicalPlacer, apply_keep_together, auto_cluster, build_layout_edges, lift_hints,
                         translate_element)
@@ -45,6 +46,7 @@ def unify_instances(g: Graph) -> int:
 def layout(g: Graph) -> Dict[str, float]:
     t0 = time.time()
     stats: Dict[str, float] = {}
+    report("Placement")
     sizing.size_all_nodes(g)
     unify_instances(g)
     apply_keep_together(g)
@@ -57,10 +59,16 @@ def layout(g: Graph) -> Dict[str, float]:
     level_hints = lift_hints(g)
     placer = HierarchicalPlacer(g, ledges, level_hints)
     placer.run()
+    report("Placement complete")
     g.extras["placer"] = placer
     stats["place_time"] = time.time() - t0
     stats.update({k: float(v) for k, v in placer.stats.items()})
     finish_ports(g, placer)
+    for _ in range(3):
+        if not resize_for_ports(g):
+            break
+        placer.rerun({}, {})
+        finish_ports(g, placer)
     stats["layout_time"] = time.time() - t0
     g.layout_stats.update(stats)
     return stats
@@ -68,6 +76,10 @@ def layout(g: Graph) -> Dict[str, float]:
 
 def finish_ports(g: Graph, placer):
     # ports, then a port-aware refinement pass, then final sliding
+    counted = not g.settings.float_ports or g.settings.routing == "straight"
+    total = len(g.all_ports()) if counted else 0
+    if counted:
+        report("Port assignment", 0, total)
     for p in g.all_ports():
         p.assigned_side = None
     assign_ports(g, slide=False)
@@ -76,17 +88,15 @@ def finish_ports(g: Graph, placer):
     distribute_ports(g)
     slide_ports(g)
     normalize(g)
+    if counted:
+        report("Port assignment", total, total)
 
 
 def resize_for_ports(g: Graph) -> int:
-    """Grow blocks whose sides carry more ports than fit at a comfortable pitch."""
-    from collections import Counter
-    pitch = max(g.settings.port_spacing, 2.2 * g.settings.edge_spacing)
+    """Grow blocks to fit the labels on their actual assigned sides."""
     grown = 0
     for n in g.nodes():
-        cnt = Counter(p.assigned_side for p in n.ports.values() if p.assigned_side)
-        need_h = (max(cnt.get("E", 0), cnt.get("W", 0)) + 1) * pitch
-        need_w = (max(cnt.get("N", 0), cnt.get("S", 0)) + 1) * pitch
+        need_w, need_h = sizing.size_node(n, g.settings, sizing.flow_of(n.parent, g.settings))
         if need_h > n.h + 1:
             n.h = float(int(need_h + 1.99) // 2 * 2)
             grown += 1
@@ -95,6 +105,10 @@ def resize_for_ports(g: Graph) -> int:
             grown += 1
     if grown:
         unify_instances(g)
+    # Subsystem dimensions are calculated by the placer, rather than set directly.
+    for sub in g.subsystems():
+        w, h = sizing.port_dimensions(sub, g.settings, sizing.flow_of(sub, g.settings))
+        grown += int(w > sub.w + 1 or h > sub.h + 1)
     return grown
 
 
@@ -110,10 +124,12 @@ def expand_congested(g: Graph, route_fn, max_iters: int = 1) -> int:
         grown = resize_for_ports(g)
         if worst < 6.0 and not grown:
             break
+        report("Congestion refinement", done, max_iters)
         placer.rerun(margin, pad)
         finish_ports(g, placer)
-        route_fn(g)
         done += 1
+        report("Congestion refinement", done, max_iters)
+        route_fn(g)
     g.layout_stats["spacing_iterations"] = done
     return done
 

{archgraph_layout-1.0.0 → archgraph_layout-2.0.0}/archgraph/placement/floorplan.py

@@ -28,6 +28,7 @@ from typing import Dict, Hashable, List, Optional, Sequence, Tuple
 import numpy as np
 
 from ..geometry import E, N, S, W
+from ..progress import activity
 
 FLOW_VEC = {"LR": (1.0, 0.0), "RL": (-1.0, 0.0), "TB": (0.0, 1.0), "BT": (0.0, -1.0)}
 
@@ -316,7 +317,7 @@ class Floorplanner:
             qy = cya[eb] + self._offby[er, var_a[eb]] * sgy[eb]
             dx = qx - px
             dy = qy - py
-            wl = float(np.sum(self._ew * (np.abs(dx) + np.abs(dy))))
+            wl = float((self._ew * (np.abs(dx) + np.abs(dy))).sum())
             bd["wire"] = wts["wire"] * wl / (self.L0 * self.wsum)
             if self.flow_mult > 0:
                 ux, uy = self.flow_vec
@@ -332,23 +333,24 @@ class Floorplanner:
                 # perpendicular edges are tolerable, backward edges are expensive
                 viol = (0.5 * np.maximum(0.0, delta - np.maximum(along, 0.0)) + 1.5 * np.maximum(0.0, -along))
                 viol = viol * self._eflow
-                bd["flow"] = wts["flow"] * self.flow_mult * float(np.sum(self._ew * viol)) / (self.L0 * self.wsum)
+                bd["flow"] = wts["flow"] * self.flow_mult * float((self._ew * viol).sum()) / (self.L0 * self.wsum)
             else:
                 bd["flow"] = 0.0
             if wts.get("bend", 0) > 0:
                 ha, hb, wa, wb = rha[ea], rha[eb], rwa[ea], rwa[eb]
                 sy = np.maximum(0.0, np.abs(dy) - 0.35 * np.minimum(np.minimum(ha, hb), 90.0))
                 sx = np.maximum(0.0, np.abs(dx) - 0.35 * np.minimum(np.minimum(wa, wb), 120.0))
-                bd["bend"] = wts["bend"] * float(np.sum(self._ew * self._estruct * np.minimum(sx, sy))) / (self.L0 * self.wsum)
+                bd["bend"] = wts["bend"] * float((self._ew * self._estruct * np.minimum(sx, sy)).sum()) / (self.L0 * self.wsum)
             else:
                 bd["bend"] = 0.0
             if self.use_crossings and ne >= 2:
                 o1 = (qx[:, None] - px[:, None]) * (py[None, :] - py[:, None]) - (qy[:, None] - py[:, None]) * (px[None, :] - px[:, None])
                 o2 = (qx[:, None] - px[:, None]) * (qy[None, :] - py[:, None]) - (qy[:, None] - py[:, None]) * (qx[None, :] - px[:, None])
-                o3 = (qx[None, :] - px[None, :]) * (py[:, None] - py[None, :]) - (qy[None, :] - py[None, :]) * (px[:, None] - px[None, :])
-                o4 = (qx[None, :] - px[None, :]) * (qy[:, None] - py[None, :]) - (qy[None, :] - py[None, :]) * (qx[:, None] - px[None, :])
-                cross = (o1 * o2 < -1e-9) & (o3 * o4 < -1e-9) & self._cross_mask
-                wcross = float(np.sum(cross * self._ewpair))
+                # The reverse orientation tests are the transposes of these
+                # same matrices; avoid recomputing two edge-by-edge products.
+                opposite = o1 * o2 < -1e-9
+                cross = opposite & opposite.T & self._cross_mask
+                wcross = float((cross * self._ewpair).sum())
                 bd["crossing"] = wts["crossing"] * wcross / max(1.0, math.sqrt(ne))
             else:
                 bd["crossing"] = 0.0
@@ -373,14 +375,12 @@ class Floorplanner:
                 hit = bbox & ~(allpos | allneg)
                 own = self._own
                 hit &= ~own
-                line_hits = np.sum(hit, axis=1).astype(float)
+                line_hits = hit.sum(axis=1).astype(float)
                 # orthogonal wires take one of the two L-shaped paths between the pins; a block
                 # only gets in the way when it obstructs both of them
                 pxc, pyc, qxc, qyc = px[:, None], py[:, None], qx[:, None], qy[:, None]
-                lox, hix = np.minimum(pxc, qxc), np.maximum(pxc, qxc)
-                loy, hiy = np.minimum(pyc, qyc), np.maximum(pyc, qyc)
-                in_x = (lox < rx1[None, :]) & (hix > rx0[None, :])
-                in_y = (loy < ry1[None, :]) & (hiy > ry0[None, :])
+                in_x = (minx < rx1[None, :]) & (maxx > rx0[None, :])
+                in_y = (miny < ry1[None, :]) & (maxy > ry0[None, :])
 
                 def hseg(yv):
                     return in_x & (yv > ry0[None, :]) & (yv < ry1[None, :])
@@ -389,7 +389,7 @@ class Floorplanner:
                     return in_y & (xv > rx0[None, :]) & (xv < rx1[None, :])
                 l1 = (hseg(pyc) | vseg(qxc)) & ~own        # horizontal first, then vertical
                 l2 = (vseg(pxc) | hseg(qyc)) & ~own        # vertical first, then horizontal
-                line_hits = np.minimum(line_hits, np.minimum(np.sum(l1, axis=1), np.sum(l2, axis=1)))
+                line_hits = np.minimum(line_hits, np.minimum(l1.sum(axis=1), l2.sum(axis=1)))
                 # orthogonal corridor blocking: when two connected blocks face each other (overlap
                 # in x and are stacked, or overlap in y and sit side by side) their wires run
                 # inside the shared channel; a third block sitting in that channel forces the
@@ -412,10 +412,10 @@ class Floorplanner:
                     iy = np.where(own, 0.0, iy)
                     span = np.where(vert, kx1 - kx0, ky1 - ky0)
                     blocked = np.where(vert[:, None], ix * (iy > 0), iy * (ix > 0))
-                    frac = np.minimum(1.0, np.sum(blocked, axis=1) / np.maximum(span, 1.0))
+                    frac = np.minimum(1.0, blocked.sum(axis=1) / np.maximum(span, 1.0))
                     frac = np.where(vert | horz, frac, 0.0)
                     line_hits = np.maximum(line_hits, frac)
-                bd["through"] = wts["through"] * float(np.sum(line_hits * self._ew * self._estruct)) / max(1.0, math.sqrt(ne))
+                bd["through"] = wts["through"] * float((line_hits * self._ew * self._estruct).sum()) / max(1.0, math.sqrt(ne))
             else:
                 bd["through"] = 0.0
         else:
@@ -748,15 +748,33 @@ class Floorplanner:
     def anneal(self, init: FPState, moves: int, accept0: float = 0.75, deadline: Optional[float] = None
                ) -> Tuple[FPState, float]:
         n = self.n
+        # The objective is unchanged during this anneal. Neighbour moves often
+        # revisit exactly the same state, especially for small subsystem levels.
+        # Cache only scores, and snapshot the mutable state lists in the key.
+        scores = {}
+
+        def evaluate(st):
+            key = (tuple(st.gp), tuple(st.gm), tuple(st.var), tuple(st.fx), tuple(st.fy))
+            cost = scores.get(key)
+            if cost is not None:
+                self.evals += 1
+                return cost
+            cost = self.evaluate(st)
+            # Bound memory only; eviction never skips a candidate or a move.
+            if len(scores) >= 8192:
+                scores.clear()
+            scores[key] = cost
+            return cost
+
         cur = self.tie(init.copy())
-        cur_cost = self.evaluate(cur)
+        cur_cost = evaluate(cur)
         best, best_cost = cur.copy(), cur_cost
         if n <= 1 or moves <= 0:
             return best, best_cost
         # initial temperature from uphill move statistics
         ups = []
         for _ in range(min(80, 10 + 4 * n)):
-            c = self.evaluate(self.neighbor(cur))
+            c = evaluate(self.neighbor(cur))
             if c > cur_cost:
                 ups.append(c - cur_cost)
         avg_up = (sum(ups) / len(ups)) if ups else max(1e-3, 0.05 * abs(cur_cost))
@@ -767,11 +785,12 @@ class Floorplanner:
         alpha = (2e-4) ** (1.0 / steps)
         done = 0
         stale = 0
+        activity(step=f"0/{moves} moves")
         while done < moves:
             improved = False
             for _ in range(per_T):
                 cand = self.neighbor(cur)
-                c = self.evaluate(cand)
+                c = evaluate(cand)
                 d = c - cur_cost
                 if d <= 0 or self.rng.random() < math.exp(-d / max(T, 1e-12)):
                     cur, cur_cost = cand, c
@@ -780,16 +799,18 @@ class Floorplanner:
                         improved = True
                 done += 1
             T *= alpha
+            activity(step=f"{min(done, moves)}/{moves} moves")
             stale = 0 if improved else stale + 1
             if deadline is not None and time.time() > deadline:
                 break
             if stale > max(12, steps // 4) and T < T0 * 0.01:
                 break
         # greedy polish from best
+        activity(step="polishing")
         cur, cur_cost = best.copy(), best_cost
         for _ in range(min(2000, 40 * n)):
             cand = self.neighbor(cur)
-            c = self.evaluate(cand)
+            c = evaluate(cand)
             if c < cur_cost - 1e-12:
                 cur, cur_cost = cand, c
         if cur_cost < best_cost: