A Python Framework for Physics-Based Electromigration Assessment on Contemporary VLSI Power Grids
PROTON is an open-source cross-platform EDA tool for Electromigration (EM) assessment in contemporary VLSI power grids. The main key points of this tool are:
- PROTON can be straightforwardly integrated into any commercial design flow for physical synthesis in order to calculate the EM stress since it only requires files in SPICE format and the corresponding currents.
- It employs a complete set of accurate numerical and analytical techniques, that can significantly reduce the simulation complexity of large-scale EM problems. In particular, the analytical solution used for the line analysis is exact for the chosen spatial discretization guaranteeing a perfectly accurate and robust solution.
- It is built with an easy-to-use interface, that allows the user to explore different EM stress scenarios, for multiple time stamps, providing plots for the physical structures of the power grid.
O. Axelou, E. Tselepi, G. Floros, N. Evmorfopoulos and G. Stamoulis, "PROTON – A Python Framework for Physics-Based Electromigration Assessment on Contemporary VLSI Power Grids," 2023 19th International Conference on Synthesis, Modeling, Analysis and Simulation Methods and Applications to Circuit Design (SMACD), Funchal, Portugal, 2023, pp. 1-4, doi: 10.1109/SMACD58065.2023.10192229.
University of Thessaly
Greece
- PROTON Flowchart
- Requirements
- Installation guide
- How to run
- Example Runs
- Custom C/C++ kernel integration
In order to run the tool, the following requirements are needed:
- The python packages in
requirements.txt
. In order to install them in bulk, executepip install -r requirements.txt
. - For the installation of the Python numerical simulation: Given
$installation_dir
the installation directory, follow the installation steps in$installation_dir/simulation/readme.py
. - Install the Eigen library from Eigen download page.
- Install FFTW library from FFTW download page.
- Install Intel oneAPI (for MKL) from Intel oneAPI download page.
- For Intel oneAPI, the following paths must be added to the system's PATH environment variables (for
mkl_avx2.1.dll
,mkl_core.1.dll
,mkl_def.1.dll
,mkl_intel_thread.1.dll
,libiomp5md.lib
):path/to/oneAPI/Intel/mkl/latest/redist/intel64
path/to/oneAPI/Intel/compiler/latest/windows/redist/intel64_win/compile
- For FFTW library, we have already included it in the Thirdparty folder. In order for the system to link the dll libraries to the PROTON executable, the user needs to add the
./path/to/PROTON/Thirdparty/FFTW/
folder to the environment variables.
- After the installation of Intel onAPI, try sourcing the top-level
vars.sh
script with. path/to/intel/oneapi/mkl/latest/env/vars.sh
. This command sets the ONEAPI_ROOT variable.
In order to create the executable for PROTON, the following steps need to be run (provided that the above requirements are met):
- Clone/Download this repo. Note that the location of the cloned/downloaded repo is going to be the same as the installation folder
- Double-click on
PROTON_installer.py
or navigate to the folder of the repo and runpython PROTON_installer.py
. The executable is then created at the top level of the repo directory under the namePROTON.exe
for Windows andPROTON
for Linux. - The user can create a shortcut to the executable or add the folder to the environment variables (or use the
export
command in~/.bashrc
for Linux) in order to run it from anywhere in the system.
In order to check for the dependencies, try executing the C kernels by themselves. That means to execute:
./path/to/PROTON/bin/EMtool_analytical.exe
for the line analysis C kernel./path/to/PROTON/bin/EMtool_MOR.exe
for the MOR C kernel (point analysis)
Analogously for Linux, execute:
./path/to/PROTON/bin/EMtool_analytical
for the line analysis C kernel./path/to/PROTON/bin/EMtool_MOR
for the MOR C kernel (point analysis)
Provided that the necessary libraries are installed on the machine, the user can straight-forwardly run PROTON by typing python PROTON_main.py
for the graphical interface or python PROTON_cli.py
for the command-line interface.
Note that the same project can be created by either the GUI or the CLI version. This means that a user can create a PROTON project from the GUI and then open and access it from the CLI and vice-versa.
If the user has run the PROTON installer (python PROTON_installer.py
) and the PROTON executable has been created at ./path/to/PROTON/
, then the user can run our tool by double-clicking on the executable.
Note: Because of license purposes, our employs the highly-optimized open-source circuit simulator proposed by Christos Kalonakis (https://github.com/hrkalona/CircuitSimulation
) which unfortunately is only developed for Linux platforms. For this reason, if a user wished to run our tool on Windows, we have in path/to/PROTON/benchmarks/DC_analyses/
the pre-calculated DC currents for IBMPG1 and IBMPG2 benchmarks
(source).
In path/to/PROTON/examples/
we offer two TCL examples scripts for the CLI version of our tool. It can either be run with two ways:
- Through a command line at
path/to/PROTON/
by typingpython PROTON_cli.py examples/line_EM_analysis.tcl
or - By double-clicking on the
path/to/PROTON/PROTON_cli.py
and typingsource examples/line_EM_analysis.tcl
The user has the option to make use of custom C/C++ kernels of his/her choice. For this purpose, one can simply change the executable file (for Windows and/or Linux respectively) in bin/
folder.
The line analysis C++ kernel calculates the EM diffusion stress using the implementation of the ICCAD2022 paper with title "A Novel Semi-Analytical Approach for Fast Electromigration Stress Analysis in Multi-Segment Interconnects".
Inputs: It receives as input the analytical.cfg
configuration file that is inside the corresponding line in the input/
folder. For example, if we have selected line M5_n0_3
with Al technology, at 378K and 1 line width, the analytical configuration file will be project_folder/input/M5_n0_3/Al_378.0_1.0/analytical.cfg
. It contains the following info:
A_coeff
: The coefficient of matrix Anum_nodes
: The number of discretization pointssimulation_time
: The desired time for EM stress calculationinput_files
: The number of columns of matrix B. It also receives as input filesB.csv
andcurden.csv
(which are in the same folder asanalytical.cfg
) and contain matrixB
of sizenum_nodes
xinput_files
and a vector of sizeinput_files
that contains the current densities at every segment of the line.
Outputs: It provides the stress at each discretization point of the line at stores it in the corresponding line's folder inside output/
with the name stress_<simulation_time>.txt
. For example, if we run the analytical function for the line above at t=100s, then the stress results will be in project_folder/output/M5_n0_3/Al_378.0_1.0/stress_100.txt
.
The Model Order Reduction (MOR) C++ kernel implements a Moment-Matching (MM) Extended Krylov Subspace (EKS) method, so that the transient analysis for all points on the line speed up.
Inputs: It receives as input the mor.cfg
configuration file that is inside the corresponding line in the input/
folder as explained above for the Line analysis C++ kernel. It contains the following info:
set_working_directory
: The directory of the project. E.g., if the project is located at/home/proton/Desktop/first_project
, then this is given.set_output_directory
: The output directory for the reduced matrices. For the above example's line, it would beoutput/M5_n0_3/Al_378.0_1.0/reduced_matrices/
set_G
: The location of matrixA
. For the above example, it would beinput/M5_n0_3/Al_378.0_1.0/G.csv
. Note: matrix A is stored as G (simply another notation)set_B
: The location of matrixB
. For the above example, it would benput/M5_n0_3/Al_378.0_1.0/B.csv
.set_L
: The location of matrixL
. Same asB
.set_reduced_size
: The desired reduced size.
Outputs: In folder set with set_output_directory
command, the following reduced matrices are going to be stored:
Br.csv
Gr.csv
Cr.csv
Lr.csv
Note that all original and reduced matrices are stored in sparse triplet format.