( DAC 12 Item 5 ) ----------------------------------------------- [09/20/12]
Subject: JasperGold Apps, Vennsa OnPoint, NextOp BugScope were #5 at DAC
BUGHUNTERS: The business news after DAC was NextOp had joined Atrenta. The
technie user news at DAC was NextOp BugScope assertion synthesis worked
incrementally, Vennsa OnPoint does root cause analysis plus bins failures,
and that Kathryn Kranen was making "formal for the masses" by now offering
easily useable JasperGold Apps.
Anyway, these three Jasper/Vennsa/NextOp bughunter tools all taken together
were the #5 most interesting tools users saw at this DAC'12.
"What were the 3 or 4 most INTERESTING specific tools you
saw at DAC this year? WHY did they interest you?"
---- ---- ---- ---- ---- ---- ----
Jasper Apps. I like that Kathryn is trying to make formal more "user
friendly". Too many of my engineers walk away if asked to do anything
with formal. They don't understand it; therefore don't trust it.
- [ An Anon Engineer ]
---- ---- ---- ---- ---- ---- ----
I like JasperGold Apps. Screw the experts. Like the iPhone let's just
use what works in bits of SW we can easily use.
- [ An Anon Engineer ]
---- ---- ---- ---- ---- ---- ----
The only way we used formal before was we had to beg Herr Doktor Formal
to come down from his ivory tower to pleeease "do formal" on our project.
Kathryn's Apps hopefully will change that.
- [ An Anon Engineer ]
---- ---- ---- ---- ---- ---- ----
Talk about doing a 180. JasperGold used to be runnable only by experts.
Now they're adding Apps for the masses. Cooley lists: formal property
verification, x-propagation, connectivity, executable specs, behavioral
property synthesis, structural property synthesis, RTL development,
architectural models, etc. We should check this out.
- [ An Anon Engineer ]
---- ---- ---- ---- ---- ---- ----
Jasper Apps. Not everyone can afford to hire Harry Foster.
- [ An Anon Engineer ]
---- ---- ---- ---- ---- ---- ----
NextOp : benefit of assertions added at lower cost than manual capture
Vennsa : debug automation, direct impact on project workload/timescale
Jasper : look's an easy way to access formal technology
- [ An Anon Engineer ]
---- ---- ---- ---- ---- ---- ----
Vennsa OnPoint. Assertion synthesis like NextOp but no engineers' time
needed to sort the assertions OnPoint generates.
- [ An Anon Engineer ]
---- ---- ---- ---- ---- ---- ----
Vennsa. Root cause analysis of bugs and points to source code lines
that caused the bugs. Triage and binning of failures. X propagation
checks. All automatic. Company based in France.
- [ An Anon Engineer ]
---- ---- ---- ---- ---- ---- ----
1. OnPoint. Finds if the same bug is firing multiple checkers. Clever.
- [ An Anon Engineer ]
---- ---- ---- ---- ---- ---- ----
2. NextOp's assertion synthesis.
Perhaps we can use formal verification easier and more efficiently by
using this.
- [ An Anon Engineer ]
---- ---- ---- ---- ---- ---- ----
I liked NextOp BugScope incremental/progressive flow.
The problem with assertion synthesis is that it takes human time to
manually classify each property into assertions and coverage points.
NextOp's incremental/progressive flow largely automates this.
1. You give NextOp your design and a set of tests, and it generates
properties. You don't classify them. For this first set of
properties, everything is new and not classified.
2. You write new tests on new functionality, and re-simulate, using
BugScope with your simulator. You expect some of the assertions
to be violated, for example, some state was always 0, and
when you write a new test, it suddenly becomes 1. No manual
classification is required -- BugScope automatically classifies
these as cover properties; this automation makes it worthwhile.
3. Over time, the total # of cover properties should go up. If it
goes down, then this is an indication that something is wrong.
4. Once verification is finished, the remaining set of properties that
have not been automatically classified can be manually classified.
This should be a small subset of the total property set.
Basically, over time, BugScope generates a cover model for your design,
so you don't have to.
- [ An Anon Engineer ]
---- ---- ---- ---- ---- ---- ----
I like BugScope progressive functional coverage. Their progressive
flow is kind of like a script wrapper around the usual BugScope tool.
BugScope will generate properties, and the progressive flow script
lets you get some value from the properties even without the needing
to classify them into assertion and coverage.
The inputs to BugScope progressive flow are the design srclist and
some information that is saved during your simulation run. The tool
will save information about the properties it found during simulation.
These properties are generated after each run.
You compare the properties from the current run to the runs from
previous weeks and the tool generates a graphical representation of
what is happening to these properties after each new run, such as:
Covered properties : 46
Not Covered Properties : 23
New Properties : 12
Covered to Not Covered : 7
Although NextOp BugScope isn't fully integrated into our random Verilog
simulation flow yet, I think it could help track functional coverage
without having to actually write any assertions. It can easily tell us
if coverage drops, or if coverage stays flat week to week.
It tells us the difference between coverage of a new testbench vs. the
existing one.
We are migrating to UVM, but our current environment is in VMM. It is
difficult to port tests. Right now, I have a script to do the porting,
but not all the tests can be migrated this way. I could use this
progressive flow to check the functional coverage of the new testbench.
I've been demoing NextOp internally with our IP design. Our IP is a
*parameterized* memory controller that supports LPDDR2, LPDDR1, DDR3,
DDR2, and soon to support DDR4.
There are BugScope issues with parameterization and merging functional
coverage information between configurations -- and we are still working
through how best to approach to coverage between different parameterized
configurations. This isn't an issue that is restricted to BugScope by
the way. I think with any coverage flow on a parameterized design, you
have these issues.
I think we could use the BugScope generated properties with a formal
tool as well, but that isn't really being talked about yet.
- [ An Anon Engineer ]
---- ---- ---- ---- ---- ---- ----
I saw a 30 minute demo on NextOp BugScope at DAC.
BugScope has an app to measure your verification progress. BugScope
generates assertions/properties, which shift over time as you add more
tests. So you can compare the properties over time against what you've
already done.
It's an interesting idea. However, my understanding is that you need a
NextOp license for every simulation license because you use it to collect
data from each simulator, which makes it something that we can't afford.
- [ An Anon Engineer ]
---- ---- ---- ---- ---- ---- ----
NextOp BugScope sounds like an interesting tool. You can run
simulation and generate assertions on the fly, then incorporate the
assertions in your simulation environment.
If I had more of a budget, I would look into evaluating and purchasing
it. I did have some concerns about the acquisition of NextOp by
Atrenta, but with Atrenta being a larger and better known company, the
likelihood of the NextOp products being available and supported for
the next few years increases.
- [ An Anon Engineer ]
---- ---- ---- ---- ---- ---- ----
I think the idea of assertion synthesis is smart. The output of NextOp
is either "assertion" or "coverage". It will help user to strengthen
their verification environment.
But I still have some questions about the real BugScope capabilities,
like n-cycle assertion generation.
- [ An Anon Engineer ]
---- ---- ---- ---- ---- ---- ----
NextOp's BugScope gives users visibility into blind spots.
Most coverage tools merely summarize what the user already knows, but
the worse bugs never even cross your mind.
NextOp's technology infers from the known coverage spots to reveals the
unsuspected corner cases -- this is where BugScope's true power lies.
- [ An Anon Engineer ]
Join
Index
Next->Item
|
|
