OpenROAD

OpenROAD is an integrated chip physical design tool that takes a design from synthesized Verilog to routed layout.

An outline of steps used to build a chip using OpenROAD are shown below.

• Initialize floorplan - define the chip size and cell rows
• Place pins (for designs without pads )
• Place macro cells (RAMs, embedded macros)
• Insert substrate tap cells
• Insert power distribution network
• Macro Placement of macro cells
• Global placement of standard cells
• Repair max slew, max capacitance, and max fanout violations and long wires
• Clock tree synthesis
• Optimize setup/hold timing
• Insert fill cells
• Global routing (route guides for detailed routing)
• Antenna repair
• Detailed routing
• Parasitic extraction
• Static timing analysis

OpenROAD uses the OpenDB database and OpenSTA for static timing analysis.

Documentation is also available here.

Introduction

OpenROAD is the leading open-source, foundational application for semiconductor digital design. It eliminates the barriers of cost, risk and uncertainty in hardware design to foster open access, expertise, rapid innovation and faster design turnaround. The OpenROAD application enables flexible flow control through an API with bindigns in Tcl and Python.

OpenROAD is a foundational building block in open source digital flows like OpenROAD-flow-scripts, OpenLane from Efabless, Silicon Compiler Systems; as well as OpenFASoC for mixed-signal design flows.

OpenROAD users range from hardware designers, industry collaborators, enthusiasts, academia and researchers.

Two main flow controllers are supported by the OpenROAD project repository:

• OpenROAD-flow-scripts - Supported by the OpenROAD project

• OpenLane - Supported by Efabless

The OpenROAD flow delivers an autonomous, no-human-in-the-loop, 24 hr turnaround from RTL-GDSII for design exploration and physical design implementation.

GUI

The OpenROAD GUI is a powerful visualization, analysis and debugging tool with a customizable Tcl interface.Figures show GUI views for various flow stages including post-routed timing, placement congestion, CTS.

Placement Congestion View:

CTS:

PDK Support

The OpenROAD application is PDK independent. However, it has been tested and validated with specific PDKs in the context of various flow controllers.

OpenLane supports Skywater130.

OpenROAD-flow-scripts supports several public and private PDKs including:

Open Source PDKs

• Skywater130 - 130nm
• Nangate45 - 45nm
• ASAP7 - Predictive FinFET 7nm

Proprietary PDKs

These PDKS are supported in OpenROAD-flow-scripts only. They are used to test and calibrate OpenROAD against commercial platforms and ensure good QoR. The PDKs and platform-specific files for these kits cannot be provided due to NDA restrictions. However, if you are able to access these platforms independently, you can create the necessary platform-specific files yourself.

• GF55 - 55nm
• GF12 - 12nm
• GF180 - 180nm
• Intel22 - 22nm
• Intel16 - 16nm
• TSMC65 - 65nm

Tapeouts

OpenROAD was used for full physical implementation in over 240 tapeouts in Sky130 through the Google sponsored, Efabless MPW shuttle and ChipIgnite programs.

OpenTitan SoC on GF12LP - Physical design and optimization using OpenROAD

Continuous Tapeout Integration into CI

The OpenROAD project actively adds successfully taped out MPW shuttle designs to the CI regression testing. Examples of designs include Open processor cores, RISC-V based SoCs, cryptocurrency miners, robotic app processors, amateur satellite radio transceivers, OpenPower based Microwatt etc.

Install dependencies

For a limited number of configurations the following script can be used to install dependencies. The script etc/DependencyInstaller.sh supports Centos7 and Ubuntu 20.04. You need root access to correctly install the dependencies with the script.

./etc/DependencyInstaller.sh -help

Usage: ./etc/DependencyInstaller.sh -run[time]      # installs dependencies to run a pre-compiled binary
       ./etc/DependencyInstaller.sh -dev[elopment]  # installs dependencies to compile the openroad binary

Build

The first step, independent of the build method, is to download the repository:

git clone --recursive https://github.com/The-OpenROAD-Project/OpenROAD.git
cd OpenROAD

OpenROAD git submodules (cloned by the --recursive flag) are located in src/.

The default build type is RELEASE to compile optimized code. The resulting executable is in build/src/openroad.

Optional CMake variables passed as -D<var>=<value> arguments to CMake are show below.

Argument	Value
CMAKE_BUILD_TYPE	DEBUG, RELEASE
CMAKE_CXX_FLAGS	Additional compiler flags
TCL_LIBRARY	Path to Tcl library
TCL_HEADER	Path to tcl.h
ZLIB_ROOT	Path to zlib
CMAKE_INSTALL_PREFIX	Path to install binary

Build by hand

mkdir build
cd build
cmake ..
make

The default install directory is /usr/local. To install in a different directory with CMake use:

cmake .. -DCMAKE_INSTALL_PREFIX=<prefix_path>

Alternatively, you can use the DESTDIR variable with make.

make DESTDIR=<prefix_path> install

Build using support script

./etc/Build.sh
# To build with debug option enabled and if the Tcl library is not on the default path
./etc/Build.sh -cmake="-DCMAKE_BUILD_TYPE=DEBUG -DTCL_LIB=/path/to/tcl/lib"

The default install directory is /usr/local. To install in a different directory use:

./etc/Build.sh -cmake="-DCMAKE_INSTALL_PREFIX=<prefix_path>"

LTO Options

By default, OpenROAD is built with link time optimizations enabled. This adds about 1 minute to compile times and improves the runtime by about 11%. If you would like to disable LTO pass -DLINK_TIME_OPTIMIZATION=OFF when generating a build.

Regression Tests

There are a set of regression tests in test/.

# run all tool unit tests
test/regression
# run all flow tests
test/regression flow
# run <tool> tests
test/regression <tool>
# run <tool> tool tests
src/<tool>/test/regression

The flow tests check results such as worst slack against reference values. Use report_flow_metrics [test]... to see the all of the metrics. Use save_flow_metrics [test]... to add margins to the metrics and save them to .metrics_limits.

% report_flow_metrics gcd_nangate45
                       insts    area util slack_min slack_max  tns_max clk_skew max_slew max_cap max_fanout DPL ANT drv
gcd_nangate45            368     564  8.8     0.112    -0.015     -0.1    0.004        0       0          0   0   0   0

Run

openroad [-help] [-version] [-no_init] [-exit] [-gui]
         [-threads count|max] [-log file_name] cmd_file
  -help              show help and exit
  -version           show version and exit
  -no_init           do not read .openroad init file
  -threads count|max use count threads
  -no_splash         do not show the license splash at startup
  -exit              exit after reading cmd_file
  -gui               start in gui mode
  -python            start with python interpreter [limited to db operations]
  -log <file_name>   write a log in <file_name>
  cmd_file           source cmd_file

OpenROAD sources the Tcl command file ~/.openroad unless the command line option -no_init is specified.

OpenROAD then sources the command file cmd_file if it is specified on the command line. Unless the -exit command line flag is specified it enters and interactive Tcl command interpreter.

Below is a list of the available tools/modules included in the OpenROAD app.

OpenROAD (global commands)

• OpenROAD

Database

• OpenDB

Parasitics Extraction

• OpenRCX

Synthesis

• Restructure

Initialize Floorplan

• Floorplan

Pin placement

• ioPlacer

Chip level connections

• ICeWall

Macro Placement

• TritonMacroPlacer

Tapcell

• Tapcell

PDN analysis

• PDN
• PDNSim

Global Placement

• RePlAce

Timing Analysis

• OpenSTA

Gate Resizer

• Resizer

Detailed Placement

• OpenDP

Clock Tree Synthesis

• TritonCTS 2.0

Global Routing

• FastRoute
• Antenna Checker

Detailed Router

• TritonRoute

Metal Fill

• Metal Fill

Graphical User Interface

• GUI

License

BSD 3-Clause License. See LICENSE file.