Skip to content
RayChang987Public

Repository files navigation

Attar: GPU-accelerated VLSI physical design in PyTorch

Diverse P&R benchmarks, distilled into one plug-and-play PyTorch environment on the GPU.
Evolve VLSI placement, timing-optimization and routing algorithms in minutes, not days.

Python PyTorch PyPI Downloads Validated Tests License

Quick start  ·  Why Attar  ·  What's inside  ·  How it works  ·  Gallery

Quick start

pip install attar
import attar
d = attar.load('after_fp/orfs_asap7/aes', device='cuda')   # from the zoo, as tensors on the GPU
d.place()                                                   # or set d.pos from your own algorithm
print(attar.Evaluator(d).hpwl(), d.timing().wns)            # HPWL, and WNS as OpenSTA reports it
d.export('aes.def')                                         # back to OpenROAD, Innovus, ICC2, ...

Designs download from the Attar zoo on first use. The first timing run on a GPU compiles its kernels (about two minutes, once). No GPU? Everything also runs on the CPU, or try the demo in Colab: Open In Colab

Timing-driven placement written in fifteen lines of Python, run on cva6 and swerv: place for wirelength, time it, weight the nets by their slack as OpenROAD's global placement does, place again, time it

Timing-driven placement in 15 lines (examples/timing_driven.py): cva6 WNS -195 → -75 ps, in 2.2 s on an RTX 3080 Ti.

Why Attar

  • Fast. Exact HPWL of 8.9M pins in 3 ms; a 2.2M-cell design placed and legalized in 49 s. An idea, from your code or an AI agent's, is tested in seconds, not in an overnight P&R run.
  • One environment. 262 designs from 24 benchmark suites (ISPD 2005-2024, ICCAD 2015 and 2025, MCNC, GSRC, IBM-HB+, OpenROAD-flow-scripts) load with one call, in one format, from LEF/DEF, Bookshelf or YAL. An algorithm is a function from tensors to positions: no database API, no TCL.
  • Faithful. Against OpenROAD and OpenSTA on the same placement: HPWL within 0.00002%, timing (WNS) within 0.34%, power within 0.06%, global-routing wirelength within 3.6%.

What's inside

Roadmap in three cards. Data, 262 designs in the zoo: contest benchmarks ISPD 2005 (8), ISPD 2015 (20), ISPD 2018 (10), ISPD 2019 (10), ISPD 2024 (5), ICCAD 2015 (8), ICCAD 2025 (13), GSRC placement (4) for placement; MCNC (10), GSRC blocks (12), IBM-HB+ (28) for floorplan; ASAP7 (15 placement, 5 floorplan), Nangate45 (8 and 8) and NS3K (98 placement). Engines, done: die sizing, packing, macro placement, IO placement, global placer, legalizer, PDN-aware refinement, detailed placement, clock tree synthesis, global router, gate sizing, buffering and cloning, debuffering; not yet: delay-balanced clock trees. Evaluation, done: HPWL, Steiner wirelength, legality, displacement, density overflow, RUDY, global routing overflow, setup and hold timing, GR parasitics, propagated clocks and CRPR, slew, capacitance and fanout limits, power; not yet: blocked pin checking. Left to your P&R tool: PDN synthesis, detailed routing, routing DRC, sign-off

Every engine and evaluator, with its accuracy against OpenROAD and OpenSTA: docs/features.md.

How it works

Sources (LEF/DEF, Bookshelf, YAL, GSRC blocks) are distilled into the Attar IR and loaded as a Design on the GPU; attar.naive moves it and adds facts, the Evaluator measures it; export writes a DEF for your own flow (OpenROAD, Innovus, ICC2, ...)

Attar splits physical design at the power grid, as production flows do:

  • before_fp: given a netlist, find the die, IO pins and macros (d.floorplan()).
  • after_fp: given a fixed floorplan with its PDN, place the cells, then size, buffer, route and time them (d.place()).

Every design states the facts it has and where each came from, and every engine says which facts it needs:

>>> d.status()
  ✅ netlist           def             12268 nets, 42885 pins
  ✅ cell_geometry     lef             12420 cells (12009 movable, 0 macros), 56 masters
  ✅ pdn               def             1815 wire and 4785 via shapes on M1, M2, M3
  ...
  ❌ placement         12009 movable cells unplaced
  -> only a placement is missing: place the design, then d.export("out.def")

Docs: concepts · engines and evaluators · benchmarks · API · validation

Gallery

Floorplan mode: GSRC n100 at 85% block area, floorplanned twice: GP plus LP legalization leaves 5 macros outside the core (not legal), B*-tree packing fits them all (legal)
Floorplanning GSRC n100: B*-tree packing fits all 100 blocks into the core in 5.1 s.
cva6 after placement, colored by global-routing load on OpenROAD's gcells ariane136 after global placement: cells with a signal pin on the PDN, in stripes along the power grid
Routing congestion cva6, placed in 2.4 s. Pin access ariane136: cells with a signal pin on the PDN's vias.
ariane136 legalized: legal, rails and PDN included GSRC n300 floorplanned by B*-tree packing, with the strongest connections between blocks and IO pins
Legal placement ariane136, rails and PDN included, in 2.4 s. Floorplan GSRC n300: 300 blocks, 569 IO pins, packed in 43 s.

Acknowledgements

Attar's placer follows ePlace, DREAMPlace and Xplace; its checks follow OpenROAD. It is validated against OpenROAD-flow-scripts on ASAP7 and Nangate45. Benchmarks are from the ISPD, ICCAD and GSRC contests, MCNC and ORFS.

License

MIT License

Copyright © 2026 RayChang987  ·  free to use, modify and distribute; see LICENSE

Attar