Skip to content

About

No description, website, or topics provided.

Resources

Stars

0 stars

Watchers

0 watching

Forks

 
 

Repository files navigation

Macro Placement Challenge 2026 — Scope Selector

This repository contains the final open-source implementation of my macro-placement approach for the 2026 HRT/Partcl challenge.

The repository deliberately keeps one submission algorithm:

submissions/final_placer.py

The rest of the tree is the challenge evaluator, benchmark integration, Docker setup, and the small adapter needed to run the optional route-aware scout.

Result

The public Scope-Selector package was validated on all 17 public IBM ICCAD04 designs:

Metric Result
Average proxy cost 0.961653
Valid designs 17 / 17
Average wirelength 0.075941
Average density 0.519471
Average congestion 1.251706
Hard-macro overlap failures 0 / 17

These are the observed public-run results from the final submission package. The official judge remains the source of truth for leaderboard results.

The published technical write-up reports the later verified leaderboard result as rank 1, with an average proxy cost of 0.9507 and zero hard-macro overlaps. The 0.961653 table above is the reproducible pre-verification Scope-Selector scorecard represented by the single-file package in this repository.

Verified leaderboard snapshot

Verified leaderboard snapshot: Archgen ranked first with an average proxy cost of 0.9507 and zero overlaps.

Final macro-placement system flow

Final system flow: generate different legal basins, scout them with exact proxy components, allocate the long repair budget to the best lane, and validate the returned placement.

Objective

The challenge proxy is lower-is-better:

proxy = wirelength + 0.5 * density + 0.5 * congestion

The important practical observation was that late-stage wirelength improvements were small compared with the remaining congestion and density cost. The final search therefore protects legality and HPWL while putting more proposal pressure on routing hotspots.

Final approach

The placer is a bounded hybrid search with strict validation gates:

  1. Start from the benchmark placement and create a congestion-aware basin by spreading smaller macros, with extra pressure near the canvas center.
  2. Legalize hard macros with GPU-friendly overlap checks, push-apart moves, and fallback candidate search. Soft macros remain available as low-risk actuators.
  3. Generate a strong evolutionary/analytical candidate and, when the optional Xplace build is available, a route-aware Xplace-RA candidate.
  4. Adapt the Xplace-RA lane and its density/route settings to the current design rather than using one fixed setting for every benchmark.
  5. Use GPU coordinate descent to rank many candidate moves. Every candidate still goes through the exact proxy evaluator before it is accepted.
  6. Reject non-finite, illegal, overlapping, or clearly regressive candidates. If Xplace-RA fails, fall back to the in-house candidate instead of returning an unvalidated placement.
  7. Stop before the hard runtime limit and return the best legal placement found.
flowchart LR
    A[Benchmark start] --> B[Congestion-aware spread]
    B --> C[Hard-macro legalization]
    C --> D{Candidate scouts}
    D --> E[EVO / analytical]
    D --> F[Xplace-RA lanes]
    E --> G[Legality and metric gates]
    F --> G
    G --> H[GPU proposal ranking]
    H --> I[Exact proxy accept/reject]
    I --> J[Best legal placement]
Loading

The official scorer remains the acceptance authority. The internal congestion-weighted ranking only changes which moves are proposed first; it does not replace the official proxy or legality checks.

Reproduce with Docker

The Docker image installs the challenge evaluator, fetches the public MacroPlacement testcases, builds the patched open-source Xplace dependency, and sets the contest-compatible runtime environment.

Build:

docker build -t macro-placement-final .

Run one benchmark:

docker run --rm --gpus all --network none \
  macro-placement-final submissions/final_placer.py -b ibm17

Run the complete public suite:

docker run --rm --gpus all --network none \
  macro-placement-final submissions/final_placer.py --all

The build needs network access to download dependencies. The evaluation commands can run with --network none after the image has been built.

Direct Linux setup

The intended target is a Linux CUDA host with an NVIDIA GPU. Install the Python dependencies from requirements.txt and the package from the repository root, initialize the MacroPlacement testcase submodule, and build Xplace using the patches in support/xplace_patches/.

At runtime, set:

export EVO_XRA_XPLACE_ROOT=/opt/Xplace
export XPLACE_PYTHON="$(which python)"
export EVO_XRA_ENABLE=1
export EVO_FORCE_FULL_TIME=1
export EVO_TARGET_TOTAL_TIME_S=3300
export AUTODMP_TOTAL_TIME_LIMIT=3300

Then run:

python -m macro_place.evaluate submissions/final_placer.py -b ibm17
python -m macro_place.evaluate submissions/final_placer.py --all

If Xplace-RA is unavailable, the final placer is designed to fall back to the in-house candidate path. That keeps the output flow safe, but it will not reproduce the best observed score without the route-aware dependency.

Repository layout

submissions/final_placer.py       # the one final algorithm
submissions/bookshelf_to_lefdef.py  # Xplace-RA format adapter
macro_place/                      # challenge loader and official proxy evaluator
support/                          # parser and Xplace patches
Dockerfile                        # reproducible CUDA build
test/                             # evaluator smoke tests

References and attribution

The challenge evaluator and third-party dependencies retain their upstream licenses. This repository is released under the Apache License 2.0; see LICENSE.md.

About

No description, website, or topics provided.

Resources

Stars

0 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages