Parallax Static Timing Analyzer

OpenSTA is a gate level static timing verifier. As a stand-alone executable it can be used to verify the timing of a design using standard file formats.

• Verilog netlist
• Liberty library
• SDC timing constraints
• SDF delay annotation
• SPEF parasitics
• VCD power acitivies
• SAIF power acitivies

OpenSTA uses a TCL command interpreter to read the design, specify timing constraints and print timing reports.

Clocks

• Generated
• Latency
• Source latency (insertion delay)
• Uncertainty
• Propagated/Ideal
• Gated clock checks
• Multiple frequency clocks

Exception paths

• False path
• Multicycle path
• Min/Max path delay
• Exception points
• -from clock/pin/instance -through pin/net -to clock/pin/instance
• Edge specific exception points
• -rise_from/-fall_from, -rise_through/-fall_through, -rise_to/-fall_to

Delay calculation

• Integrated Dartu/Menezes/Pileggi RC effective capacitance algorithm
• External delay calculator API

Analysis

• Report timing checks -from, -through, -to, multiple paths to endpoint
• Report delay calculation
• Check timing setup

Timing Engine

OpenSTA is architected to be easily bolted on to other tools as a timing engine. By using a network adapter, OpenSTA can access the host netlist data structures without duplicating them.

• Query based incremental update of delays, arrival and required times
• Simulator to propagate constants from constraints and netlist tie high/low

See doc/OpenSTA.pdf for command documentation. See doc/ChangeLog.txt for changes to commands. See doc/StaApi.txt for timing engine API documentation.

OpenSTA is dual licensed. It is released under GPL v3 as OpenSTA and is also licensed for commerical applications by Parallax Software without the GPL's requirements.

OpenSTA is open source, meaning the sources are published and can be compiled locally. Derivative works are supported as long as they adhere to the GPL license requirements. However, OpenSTA is not supported by a public community of developers as many other open source projects are. The copyright and development are exclusive to Parallax Software.

Removing copyright and license notices from OpenSTA sources (or any other open source project for that matter) is illegal. This should be obvious, but the author of OpenSTA has discovered two different cases where the copyright and license were removed from source files that were copied.

The official git repository is located at https://github.com/parallaxsw/OpenSTA.git. Any forks from this code base have not passed extensive regression testing which is not publicly available.

Build from source

OpenSTA is built with CMake.

Prerequisites

The build dependency versions are shown below. Other versions may work, but these are the versions used for development.

         Ubuntu   Macos
        22.04.2   14.5
cmake    3.24.2    3.29.2
clang             15.0.0
gcc      11.4.0
tcl       8.6      8.6.16
swig      4.1.0    4.1.1
bison     3.8.2    3.8.2
flex      2.6.4    2.6.4

External library dependencies:

           Ubuntu   Darwin  License
eigen       3.4.0   3.4.0   MPL2  required
cudd        3.0.0   3.0.0   BSD   required
tclreadline 2.3.8   2.3.8   BSD   optional
zLib        1.2.5   1.2.8   zlib  optional
libfmt      8.1.1   N/A     MIT   required if std::format not available

The TCL readline library links the GNU readline library to the TCL interpreter for command line editing To enable TCL readline support use the following Cmake option: See (https://tclreadline.sourceforge.net/) for TCL readline documentation. To change the overly verbose default prompt, add something this to your ~/.sta init file:

if { ![catch {package require tclreadline}] } {
  proc tclreadline::prompt1 {} {
    return "> "
  }
}

The Zlib library is an optional. If CMake finds libz, OpenSTA can read Liberty, Verilog, SDF, SPF, and SPEF files compressed with gzip.

CUDD is a binary decision diagram (BDD) package that is used to improve conditional timing arc handling, constant propagation, power activity propagation and spice netlist generation.

Download and build CUDD:

git clone https://github.com/cuddorg/cudd.git
cd cudd
git checkout 3.0.0
./configure
make

You can use the "configure --prefix" option and "make install" to install CUDD in a different directory.

Modern c++ compilers that support c++20 include support for std::format. With older compilers like gcc 11 on Ubuntu 22.04 and Centos7 the fmt library is used instead. If it is not installed locally, the github repository is downloaded and compiled in the build directory.

Building with CMake

Use the following commands to checkout the git repository and build the OpenSTA library and excutable.

git clone https://github.com/parallaxsw/OpenSTA.git
cd OpenSTA
mkdir build
cd build
cmake -DCUDD_DIR=<CUDD_INSTALL_DIR> ..
make

The default build type is release to compile optimized code. The resulting executable is in build/sta. The library without a main() procedure is build/libOpenSTA.a.

Optional CMake variables passed as -D= arguments to CMake are show below.

CMAKE_BUILD_TYPE DEBUG|RELEASE
CMAKE_CXX_FLAGS - additional compiler flags
TCL_LIBRARY - path to tcl library
TCL_HEADER - path to tcl.h
CUDD_DIR - path to cudd installation
ZLIB_ROOT - path to zlib
CMAKE_INSTALL_PREFIX

If TCL_LIBRARY is specified the CMake script will attempt to locate the header from the library path.

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

If you make changes to CMakeLists.txt you may need to clean out existing CMake cached variable values by deleting all of the files in the build directory.

Build with Docker

AN alternative way to build and run OpenSTA is with Docker. After installing Docker, the following command builds a Docker image.

cd OpenSTA
docker build --file Dockerfile.ubuntu24.04 --tag opensta_ubuntu24.04 .
or
docker build --file Dockerfile.centos7 --tag opensta_centos7 .

The centos7 build on mac/OsX with ARM processorts requires the platform to be specified.

docker build --file Dockerfile.centos7 --platform=linux/amd64 --tag opensta_centos7 .

To run a docker container using the OpenSTA image, use the -v option to docker to mount direcories with data to use and -i to run interactively.

docker run -i -v $HOME:/data opensta

Build on Macos/Darwin

The XCode versions of Tcl, Flex and Bison cannot be used to build OpenSTA. Use Homebrew to install them. The following command installs the tools required to build OpenSTA in the Brewfile.

brew bundle install

Set these variables before using cmake to cirumvent the Xcode versions.

  # flex/bison override apple version
  export PATH="$(brew --prefix bison)/bin:${PATH}"
  export PATH="$(brew --prefix flex)/bin:${PATH}"
  export CMAKE_INCLUDE_PATH="$(brew --prefix flex)/include"
  export CMAKE_LIBRARY_PATH="$(brew --prefix flex)/lib;$(brew --prefix bison)/lib"

Homebrew does not support tclreadline, but the macports system does (see https://www.macports.org).

Install using a package manager

Guix

OpenSTA is available in the default repositories:

  guix install opensta

Bug Reports

Use the Issues tab on the github repository to report bugs.

Each issue/bug should be a separate issue. The subject of the issue should be a short description of the problem. Attach a test case to reproduce the issue as described below. Issues without test cases are unlikely to get a response.

The test case should have a tcl command file recreates the issue named run.tcl. If is are more than one command file using the same data files, there should be separate command files, run1.tcl, run2.tcl etc. The bug report can refer to these command files by name.

Command files should not have absolute filenames like "/home/john/OpenSTA_bug/write_path_spice/dump_spice" in them. These obviously are not portable. Use filenames relative to the test case directory.

The files in the test case should be collected into a directory. The contents of the directory should be collected into a compressed tarfile.

Contributions

Contributors must sign the Contributor License Agreement (doc/CLA.txt) when submitting pull requests.

All contributors should read doc/CodingGuidelines.txt for notes on making code that adheres to the existing naming and formatting style.

Contributions that claim 4% performance improvements in OpenROAD flow scripts will largely be ignored. Small performance improvements simply do not justify the time required to audit and verify the changes.

Contributions that add dependencies on external libraries like boost, abseil and Intel TBB will not be accepted.

As the author of OpenSTA I vastly prefer writing code to reviewing code. I don't have the patience to go round after round to correct code formatting that is not consistent with the rest of the code.

Authors

• James Cherry

• William Scott authored the arnoldi delay calculator at Blaze, Inc which was subsequently licensed to Nefelus, Inc that has graciously contributed it to OpenSTA.

License

OpenSTA, Static Timing Analyzer Copyright (c) 2023, Parallax Software, Inc.

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see https://www.gnu.org/licenses/.