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 (macOS users can install libomp with Homebrew)
• 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. Dali uses Qt's widget and painter APIs and does not require a separate OpenGL development package.
• 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, supplied on the command line or by a .dali recipe. 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 <output> — output base or .def filename (both placed and placed.def create placed.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.

Command recipes and interactive mode

Dali can run reproducible .dali command recipes or accept the same commands from an interactive terminal. These modes support design loading, placement configuration, execution, I/O-pin signoff, DEF export, and future host-tool integration while preserving the ordinary command-line flow.

See the Dali command language guide for recipe syntax, supported settings and commands, interactive usage, and the public embedding API.

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