Dali

Gridded Cell Placement Flow

Dali is a standard-cell placer for gridded-cell, well-aware technologies. It runs analytical global placement, then legalizes cells into gridded rows with N/P-well-aware clustering, row orientation, row-location and detailed-placement optimization, and finally completes each row with well taps and end caps before writing a legal DEF. Every stage can be stepped through in a live Qt GUI or exported as visualization snapshots.

Recommended compilation toolchain

• Ubuntu >= 18.04
• GNU Compiler Collection (GCC), version >= 4.8.5
• CMake, version >= 3.9.6
• GNU Make

Pre-requisite

• ACT
• Si2 LEF/DEF parser, a mirror can be found here
• PhyDB
• OpenMP (for MacOS user, libomp from Homebrew will work)
• Qt 6 Widgets is optional and enables Dali's live placement GUI. Install it with brew install qt on macOS or sudo apt install qt6-base-dev on Ubuntu 22.04 and newer. CMake enables the GUI automatically when Qt is available.
• GoogleTest is optional. If CMake cannot find it, tests in tests/common are skipped while the rest of the build remains available. On Ubuntu/Debian, install it with sudo apt install libgtest-dev.
• OR-Tools is optional and only enables an experimental CP-SAT legalization backend that no production flow uses yet. Nothing needs to be installed for a normal build; see placer options if you want it.

Clone repo and compile

$ git clone --recursive https://github.com/asyncvlsi/Dali.git
$ cd Dali/
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install

this will create a binary dali in folder Dali/bin. The default installation destination is $ACT_HOME. One can use the following command to specify the installation destination and install this package:

$ cmake .. -DCMAKE_INSTALL_PREFIX=path/to/installation

Qt GUI detection defaults to AUTO, so the normal cmake .. command enables the GUI automatically when Qt 6 Widgets is installed. Use -DDALI_GUI=ON only when configuration should fail if Qt is unavailable, or -DDALI_GUI=OFF to force a non-GUI build:

$ cmake .. -DDALI_GUI=ON

Running Dali

A placement run needs a LEF and a DEF. Providing a -cell file triggers the gridded well-placement flow:

$ dali \
    -lef design.lef \
    -def design.def \
    -cell design.cell \
    -target_density 0.7 \
    -output_name placed.def

Commonly used options:

• -o/-output_name <name>.def — output DEF (default dali_out.def)
• -d/-target_density <0..1> — target placement density
• -well_legalization_mode <strict/scavenge> — gridded well legalization mode
• -well_tap_pattern <row-end/row-end-every-other> — well-tap arrangement; see well-tap patterns
• -metrics_file <file.json> — per-stage HPWL and runtime metrics
• -net_hpwl_file <file.tsv> — final per-net weighted HPWL

Run dali with no arguments to print the full option list.

Production configurations

Two flag combinations are the ones used for real runs — the gridded well flow a -cell file selects, and the standard-cell flow -is_standard_cell selects. Both, with an explanation of what each flag buys and when to change it, are in placer options.

Visualizing the placement flow

Dali can step through a placement live in a Qt window, pausing at every stage so intermediate state can be inspected, with per-stage HPWL curves and displacement overlays:

$ dali ... -gui_debug -gui_pause every_snapshot

Requires a Qt-enabled build. See the live placement GUI.

Run tests

After configuring and building from the build/ directory, run:

$ make test-unit

This runs the fast GoogleTest-based unit tests in tests/application, tests/common, and tests/circuit.

To include integration tests such as the I/O placer benchmarks, run:

$ make test-integration

To run every test registered with CTest, run:

$ make test-all

The equivalent raw CTest commands are:

$ ctest --output-on-failure -L unit
$ ctest --output-on-failure -L integration
$ ctest --output-on-failure

GoogleTest is optional. If CMake cannot find it, GoogleTest-based unit tests are skipped while integration tests and the rest of the build remain available. If the test executables have not been built yet, build first:

$ make

3rd Party Module List

• Eigen: sparse matrix iterative linear solver

Miscellaneous

• Eigen gives different results for different C++ compilers, because floating point addition is not necessarily associative
• g++ in MacOS is an alias of clang instead of GCC
• 32bit and 64bit version g++ also give different results