HITAS SSTA is a Monte-Carlo like analysis: it is based on a collection of STA samples. Each STA sample is based upon the creation of a timing database sample, constructed by picking up random values for the statistical parameters embedded in either the SPICE netlist or the technology files. An SSTA sample consists therefore of a timing database and a STA run. In the end, there are as many different timing databases and STA runs as SSTA samples. STA runs are of course highly configurable, in order to extract any relevant information.
This example features 2 analysis: A SSTA analysis and the PATH analysis. In the SSTA analysis, slacks are computed, sorted and displayed in an efficient way. In the PATH analysis, particular paths are retrieved and their variations are displayed. For each of those analyses, 50 runs are performed on the ADDACCU design.
The script to generate the SSTA data is no different from a standard STA script except for 2 TCL instructions inserted at the beginning and at the end of the script. The script used to generate those data is named ssta.tcl.
The first instruction is responsible for the handling of the 50 runs:
runStatHiTas 50 -incremental -result slacks.ssta -storedir store |
In case the configuration variable avtLibraryDirs is used, this instruction must be placed after the configuration because modifications are applied to this configuration variable to get proper search paths.
Calling runStatHiTas will launch 50 separate runs of the ssta.tcl script one by one (multiprocessing is not used in the tutorial). Each run will have its data written into the file slacks.ssta and the required information to display the slack details will be stored in the directory store.
Using the option -storedir is not mandatory but if it is not used, only the slack summaries will be available.
The -incremental flag is set to enrich any previous execution of the SSTA database so 50 more runs will be added to any existing set of runs.
The second instruction is responsible for the handling of STA data:
ssta_SlackReport -senddata $stbfig simple |
ssta_SlackReport is called after the stb API execution. The stability figure and a slack data output mode is given to the function. The only mode available at the moment is simple. Called in this form, it retrieves at most the 10000 worst negative slacks from the stability figure. If no negative slacks are found, the worst positive one is searched. The slack descriptions are then written to the file slacks.ssta for a future use.
The script slack_analysis.tcl reads the slacks.ssta file and uses the data in the directory store to display some results.
The first kind of result output is generated using the command:
ssta_SlackReport -display "slacks.ssta" $ofile -storedir store |
The report is driven to the file slack_report.log.
At the beginning of the report, yield information is printed: the total number of runs, the number of runs with negative holds, the number of runs with negative setups, the number of runs with PVT errors and the global yield.
In a second part, each negative slack is printed with the number of occurrence the of slack, the run number where the slack is the worst, some statistical information and the slack description. As the store directory is given as an argument to the function, the detail of each negative slack is displayed after this summary.
Finally, at the end, a list with the different seeds used to generate each run database is displayed.
The second kind of result is output in a set of file through a gnuplot graphical file representation by using the command:
ssta_SlackReport -plot "slacks.ssta" "distrib" |
distrib is a prefix that will be used to generate the gnuplot files. There are 2 plots: 1 for the setups slacks and 1 for the holds slacks.
The gnuplot command file will be named distrib.holds.plt and distrib.setups.plt. The corresponding data files are distrib.holds.plt.dat and distrib.holds.plt.dat.
The distributions can be viewed using the UNIX command:
gnuplot <command file> |
The script to generate the PATH data is very easy. In this case there is no need for stability to be performed. The only operation to be done is to retrieve the list of desired paths to analyse. In this example all paths and accesses will be taken. As for the SSTA data generation, 2 TCL instructions are inserted at the beginning and at the end of the script. In between, the UTD is built and the path search is performed. The script used to generate those data is named paths.tcl.
The first instruction is responsible for the handling of the 50 runs:
runStatHiTas 50 -incremental -result paths.ssta -storedir store_paths |
The instruction is placed after the configuration variable avtLibraryDirs
After the UTD generation, the list of accesses and paths are extracted from the UTD and merged together:
set paths [concat [ttv_GetPaths $fig -access] [ttv_GetPaths $fig]] |
The last instruction is responsible for the handling of PATH data:
ssta_PathReport -senddata $paths simple |
ssta_PathReport is called with the path list and a path data output mode. The only mode available at the moment is simple. The path descriptions are written into the file paths.ssta for a future use.
The script path_analysis.tcl reads the paths.ssta file and uses the data in the directory store_paths to display some results.
The path result report is generated using the command:
ssta_PathReport -display "paths.ssta" $ofile -storedir store_paths |
The report is driven to the file path_report.log.
A summary of all paths/accesses is printed at the beginning of the report. Each path has an entry in the summary with some statistical information, the minimum delay of the path and the corresponding run number, the maximum delay and the corresponding run number and finally the path description.
As the store_paths directory is given as an argument to the function, the detail of each path is displayed after this summary. There are 2 details for each path: the detail for the minimum path value and the detail for the maximum path value.
Finally, at the end, a list with the different seeds used to generate each run database is displayed.