( DAC'19 Item 6b ) ------------------------------------------------ [04/17/20]
Subject: Solido's 3-piggies of ML characterization tools is Best of 2019 #6b
SOLIDO'S ML FORMULA: Way before most of the other EDA companies slathered
this buzzword to all their tools, Solido was one of the first to announce
"machine learning" in an EDA tool -- it was for library characterization
in 2017. (see ESNUG 576 #4) At the time, they claimed to have been
using ML for 12 years before they announced it.
In this 2019 survey, users mentioned *3* ML technologies from Mentor-Solido:
Solido MLChar Generator -- uses existing libs + target corners to generate
new libraries. It does both standard cells and memories.
"We were able to generate a new STD cells library of ~1000 cells using
MLChar Generate in only 3 hours. Characterizing such a library with
Liberate would normally take us at least one day."
"I was able to use MLChar Generator to create a lib with over 1,000 cells
in 1 hour using 20 LSF clusters."
Solido MLChar Analytics -- analyzes Liberty files to find characterization
errors/debug and to understand trends in provider/custom-built or generated
libraries.
"We use Liberate for characterization and then run Solido MLChar
Analytics. Solido finds characterizations errors, such as mismatches
between CCS and NLDM."
"We do not try to find trends/errors using Synopsys SiliconSmart nor
Cadence Liberate, as those tools do not have a strong QA process
like Solido. Solido follows monotonicity trends for consistency."
Solido MLChar Transformer -- manipulates libs in all sorts of creative ways.
To wit -- copy, margin, merge, resize, transform, trim are it's commands.
"I estimate that using MLChar Transformer would save me about 90% of the
time compared with building and operating my own scripts. This is
because the Liberty structure is quite complex -- setting up the scripts
takes a VERY long time. Also, using scripts is not very reliable."
---- ---- ---- ---- ---- ---- ----
---- ---- ---- ---- ---- ---- ----
---- ---- ---- ---- ---- ---- ----
QUESTION ASKED:
Q: "What were the 3 or 4 most INTERESTING specific EDA tools
you've seen this year? WHY did they interest you?"
---- ---- ---- ---- ---- ---- ----
SOLIDO MLCHAR GENERATOR
We've used Mentor-Solido MLChar Generator for years; it is integrated in
our production environment.
We use it to generate new libraries, using our existing library + target
corners as input.
Generating Standard Cell libraries
1. For a recent example, one original standard cell library had
60 characterized corners; we then generate using MLChar
Generator libraries for another 60 corners. The results were
very good.
Subsequently, our design team needed to perform PPA optimization
and requested libraries for another 10 corners; those were
generated using MLChar Generator in a couple of days with one
tenth of the resources usually used for standard cell library
characterization.
2. Using MLChar Generator, we can generate libraries at least 10x
faster with 25% of the resource vs using traditional methods.
3. We are getting consistent results, even at 5 nm process
nodes, for libraries which have all the timing, power, noise
and variation attributes supported by Library Liberty format
required for 5 nm designs.
Memory Libraries
Solido now also generates memory libraries -- we've gotten very good
results for those libraries also.
1. We characterize 50% of the libraries using traditional
characterizer Silicon Smart or Liberate. This applies to
both standard cells and memories.
2. Our designer then does PPA analysis doing design of experiments
to optimize the original libraries. (The designer performs
this PPA using our internal RTL to GDS physical design
implementation flow.)
We use the above as input to MLChar Generator.
3. The libraries that Solido's tool delivered work well.
They are sign-off quality libraries -- they are as good as running
complete characterization.
Solido MLChar Generator's quality, productivity and throughput is
unbeatable -- there is nothing on market that comes close to it.
Solido's machine learning (ML) tools are the most advanced in EDA by
far, not just in the characterization space, but vs all EDA. This is
in terms of delivering consistent productivity and quality results that
meet and/or exceed expectations.
We work with all the major EDA vendors and have looked at lots of the
newer machine learning technology, so I've looked a what's available
in production today in terms of delivery.
- The challenge for a lot of the newer ML tech is guarantee
accuracy.
- I expect them to get there -- but it takes time to get
consistent results that Solido has.
We then use the MLChar Generator app/feature called "Anchor Optimizer"
to do corner optimization to ensure we generate target libraries with
the highest level of accuracy.
---- ---- ---- ---- ---- ---- ----
Solido MLChar Generator's inputs are characterized libraries. It then
generates new libraries as the output.
We are using it to generate new libraries. For example, PVT corners
that the vendor did not supplied for us.
We were able to generate a new std cell library of ~1000 cells using
MLChar Generator in only 3 hours. Characterizing such a library using
Liberate would normally take us at least one day.
Machine Learning seems very good for this purpose -- it's really fast
and accurate enough.
I would recommend MLChar Generator. It is quick, easy to use and find
issues. And Solido's support is very good.
---- ---- ---- ---- ---- ---- ----
We use Solido MLChar Generator for our library characterization. It
uses our existing input libraries, along with the corners we define to
generate new libraries with the same structure and cells.
This is our process:
1. We set up:
- Our input libraries
- Parser that fits our library name definition (i.e. Arch, PVT,
Vendor, Library type, with or without a Hold margin, etc.)
- Scripts that integrate the shell commands for automation
2. MLChar Generator generates the new libraries with specified PVTs.
3. When we want to create other libraries, we just need to modify
our scripts.
MLChar Generator vs traditional library characterization (e.g. Liberate)
1. Solido's MLChar Generator saves an enormous amount of time
compared to the traditional method of building libraries,
e.g. using Liberate.
I was able to use MLChar Generator to create a library with
over one thousand cells in 1 hour using 20 LSF clusters.
2. Liberate takes a lot of time for library characterization and
some settings are very vulnerable and sensitive.
In contrast, MLChar Generator is very easy to use and with
easy settings -- only a parser, input libraries, and output
libraries. Even a new user doesn't need to learn a lot of
knowledge as to how to use it -- it is quick to learn.
3. I've heard that Liberate may sometimes shut down in the bsub
and get stuck -- which could waste engineering time.
MLChar Generator does not have that issue.
I highly recommend MLChar Generator if you are going to
interpolate Liberty files. It has easy operation, far less
time consumption to execute, and good enough accuracy
(great accuracy for interpolation, not-so-good accuracy
for extrapolation).
In general, machine learning has taken over many fields of works
nowadays -- it has better accuracy in less time. I like the trend
toward develop ML on EDA tools, so that users are not required to fill
in a great number of settings and instead the tools perform the work
automatically.
---- ---- ---- ---- ---- ---- ----
---- ---- ---- ---- ---- ---- ----
---- ---- ---- ---- ---- ---- ----
SOLIDO MLCHAR ANALYTICS
Solido MLChar Analytics is a power tool that provides all you need to
analyze data using diagrams.
It comprehensively analyzes Liberty file data.
- You can use the GUI to display any attribute value and
visualize it with properties like index, temperature and
voltage.
- It can also depict the differences between two sets of
libraries in the same PVT corner.
My understanding is that MLChar Analytics supports different use models
with other characterization tools, such as SiliconSmart, Liberate and
Kronos.
It will help you analyze data in Liberty files instead of the text value
only; its visualization could greatly help you figure out some features
that you could not figure out from the original text format Liberty
files.
Running Analytics on Liberty files are in great demand right now.
Machine learning has the potential to get better library
characterization accuracy.
I recommend Solido MLChar Analytics to engineers who are going to figure
out the properties of data of Liberty files and the trends between
different PVT corners.
---- ---- ---- ---- ---- ---- ----
Solido MLChar Analytics takes a set of Liberty files as input and
produces a rules-based checks of the input libraries.
The tool runtime is really no more than 1 minute.
We use Liberate for characterization and then run Solido MLChar
Analytics.
Solido finds characterizations errors, such as mismatches between CCS
and NLDM.
- Its GUI is good for identifying errors visually.
- It plots graphs that can help you to find issues.
- It also does outlier checks for all the libraries and put
everything on a graph.
MLChar Analytics is quick, easy to use and find issues. And Mentor
Solido's support is very good.
I would recommend it.
---- ---- ---- ---- ---- ---- ----
We've been using Mentor-Solido MLChar Analytics for over a year now to
validate trends with our libraries. We want to see if our library data
is correct and follows specific rules.
Our libraries have massive amounts of data, which is sometimes
erroneous, so we use Solido MLChar Analytics to debug them.
Solido MLChar Analytics is vendor agnostic, so it doesn't matter what
tools you used to characterize your libraries. We just bring libraries,
multiple corners, and validate them with Solido.
We do not try to find these trends/errors using Synopsys SiliconSmart or
Cadence Liberate, as those tools do not have a strong QA process like
Solido. E.g. Solido follows monotonicity trends for consistency.
Even when we use libraries from an IP library provider, the attributes
can be inconsistent.
- For example, the provider can change the configuration files
between different corners when characterizing the libs.
- Even for well-used process technologies, they will do
improvements -- and recharacterize the corners.
These are extremely large files -- 100s of megabytes and gigabytes. We
have multiple libraries, with gigabytes of data, so we needed to be sure
that MLChar Analytics wouldn't get stuck at 10 corners.
We validated that it was flexible and responsive to be able to perform
validation and trend analysis in manual or batch mode.
---- ---- ---- ---- ---- ---- ----
---- ---- ---- ---- ---- ---- ----
---- ---- ---- ---- ---- ---- ----
SOLIDO MLCHAR TRANSFORMER
We use MLChar Transformer in our flow for two purposes.
1. Merging libraries <-- this is our primary use.
- We take our existing libraries, and then use Solido MLChar
Generator to generate more libraries.
- On occasion, we may have incomplete or incorrect input data
for Generator to be able to build a model, so a particular
library cell may fail to properly generate. (This is the
exception, but it happens on occasion.)
- In those cases, we characterize the missing cell manually using
traditional library characterization tools such as Synopsys
SiliconSmart or Cadence Liberate.
- For these cases, we use Solido MLChar Transformer to
automatically merge the specially created library cell (arcs,
slews, etc.) with the rest of the newly generated library.
As part of this, Transformer automatically merges the two
library data into one library.
2. Adding or removing margins for the libraries.
- We use Transformer to do data adjustment - for electrical
and timing rules - for both our manually characterized
libraries and the libraries we generate automatically using
Generator.
3. Specific adjustment for set up and hold.
- This is a less common use of Transformer for us.
Before we incorporated Solido MLChar Transformer into our product flow,
we would do those tasks with scripts.
Having Transformer is better than using our scripts because:
- With scripts, for every rule we had to create and run a
different script.
- Transformer is one tool that we configure and run for *all*
our rules.
So, Mentor Solido MLChar Transformer's integrated infrastructure gives
us more flexibility and saves us time.
---- ---- ---- ---- ---- ---- ----
I primarily use Solido MLChar Transformer to resize my Liberty files.
As an example, I used it for one project where I wanted to interpolate
some Liberty files using Solido's MLChar Generate.
- I had foundry supported libraries and in-house libraries in
hand.
- The two libraries had different attribute values, such as
"internal_power".
- Since I did not use "internal_power" in my project, I employed
MLChar Transformer's "Trim" function to remove that unnecessary
attribute.
- I was then able to successfully interpolate my desire corners
with libraries from different sources.
Here are some of the MLChar Transformer features:
I have used MLChar Transformer features: Margin, Merge and Trim.
- I used Trim and Merge to rebuild a library, removing the
attribute of "lvf_sigma" for some cells while maintaining
the original data for others.
- I used "Margin" to add extra margins on "hold_constraint" LUTs
from CCS libraries, and it is useful and flexible.
MLChar Transformer has a parser, though you may need a template to use
it. We normally only need to change the regular-expression part of the
parser. (my version is in Python format.)
It also has a character display in the terminal, for various commands.
This makes it very easy to use, clearly showing what all the tools are,
along with some relevant examples.
Transformer saves unnecessary recharacterization, because you don't have
to re-characterize new libraries for the same corners. Instead you can
just use Transformer to remove, merge, copy, or margin your original
Liberty files. This could efficiently save you time -- especially for
large scale libraries like Base libraries which contain 1000's of cells.
MLChar Transformer vs. Building Scripts
I estimate that using MLChar Transformer would save me about 90% of the
time compared with building and operating my own scripts. This is
because the Liberty structure is quite complex -- setting up the scripts
takes a VERY long time.
Additionally, using scripts is not very reliable. For example, for
different attributes, you may need to modify the scripts to fit the data
structure of the target, and it is hard to verify if your generated
libraries using scripts are acceptable and available.
Technically, you could do any operation using internal scripts but its
reliability and cost of time for the more complex transformations would
be enormous.
Therefore, I would definitely recommend MLChar Transformer instead of
using scripts to reconstruct a Liberty file.
---- ---- ---- ---- ---- ---- ----
For std cell lib generation, we are using:
90% Solido MLChar Generator
10% Solido MLChar Transformer
We are not limited by licenses. The ratio reflects our library
generation flow.
---- ---- ---- ---- ---- ---- ----
Related Articles
User buzz on Siemens/Solido machine learning is #1 for Best of 2018
Amit on Solido machine learning, lib characterization, and Siri
Amit added 263 engineers on Library Characterization this year!
Solido ML, BDA Ravi, Tom Beckley SSS makes #2 for Best of 2017
Join
Index
Next->Item
|
|
