( DAC 04 Item 9 ) ---------------------------------------------- [ 02/09/05 ]
Subject: Mentor Exemplar, Leonardo, Precision
THE BAR FIGHT (Part II) -- Challenging Synplicity Synplify Pro for the few
paying customers in the FPGA synthesis business, Mentor has half of its
users yearning to keep the glorious olde Leonardo around and the other half
are happy to jump onto their new Precision tool.
I've been a Leonardo synthesis user for a gazillion years, and
periodically do an evaluation on Synplicity, although it has been a
few years since I've taken the time to do that.
My problem with Synplicity has always been the simplicity. It has
always been touted as the single pushbutton solution, and maybe for
mainstream-type straightforward designs it does the job well. It
does have very fast compile times, but my main concern is quality of
results. I do ASIC designs also, some using Synopsys but mostly
Buildgates (maybe the subject of another synthesis comparison). So,
I'm used to waiting for the synthesis tool to grind it out, and I'm
happy if the results are good.
What I like about Leonardo is the large number of user variables that
can be set to control the synthesis via the variable editor. So, I can
synthesize a tough module with max_fanout = 4, put a noopt on it, and
synthesize the rest of the design with max_fanout 16. There are lots
of dials to tweak to the get the results I want. I didn't find that
in Synplicity.
I've just traded in my Leo for Precision Physical, because I'm now
staring at a Xilinx XC2V8000 design, that uses every multiplier and
almost all the block RAMs, and runs at 140 Mhz. You probably know that
the 8M gate part only comes in a -5 speed grade, -6 not available, so
140 Mhz is not peanuts.
My take on the FPGA synthesis market is that it's deja vu all over
again. It's the deep submicron problem that all of us ASIC guys were
looking at 7-8 years ago. I remember when Synopsys starting talking
about links to physical to handle the deep submicron problem. FPGA
folks have been carefully ignoring this problem, but I'm seeing timing
closure problems now in the FPGA arena, and the incremental synthesis
methodologies that Xilinx is pushing is not going to hack it, in my
opinion. So, it's Return of Son of deep submicron; this time in FPGAs.
The Precision Physical tool does the usual synthesis, calls a
place/route (medium effort), and then brings in the physical placement
and delays, and optimizes that. This is what is needed, I think, as
estimated wireloads just don't converge on big fast designs. And you
can get your new timing by running the Precision STA -- no going thru
another place route. So, it's more spins per day. I don't have lots
of experience with Physical yet, but I will soon.
The other thing I like about Precision vs Leonardo is that it's the
modern sources and processes paradigm, and it's being integrated into
HDL Designer.
I'm just rabid about HDL Designer, because it automates a whole bunch
of stuff that I never want to do again. I'm done running out of gas at
2:AM trying to understand why my Verilog module instantiation doesn't
match my Verilog module ports -- the tool reconciles it, even at 2:AM.
I've whined about state machine tools for a dozen years, particularly
StateCad, but this tool does a better job than I do -- always includes
recovery states, 3 processes, etc. So, I do bubble charts and the tool
writes the code. I don't even look at the code anymore.
Finally, the verification/debug cycle. I claim a factor of 2 with the
HDL environment, because of the links between simulation and the
database. You can fix a bug and be back after the next one after an
incremental sim compile in a matter of seconds. In some sense the
debug cycle length is dependent on how many bugs can be found and fixed
in a day, and this is largely dependent on the automated ease of use.
I recently bid against an in-house team that does not use the Mentor
environment, and I underbid them by a factor of 4 (darn, bid too low
again), and made my bid -- this a 3M gate sig proc design -- just
because I can go thru so many more spins in both simulation and
synthesis flow. So, I'm putting my money where my mouth is. (Or,
since I paid a small fortune for these tools, I guess I'm putting my
mouth where my money is). But I am finding I can keep my rates at
the top of the food chain, because I can do it a lot faster.
So, I guess I'm a big Mentor fan. I've just added SystemC to my
Modelsim, because I'm getting tired of paper specs -- I want an
executable spec I can refine. And I want the SCV verification lib to
generate data for verification. And I'm adding Property Specification
Language for assertion based verification. I can write the assertions
as to how the design should operate, and use the SCV lib to generate
the constrained random data that will test all the cases I didn't
think of -- these cases are what keep me up at night before tape-out.
- John Reykjalin of Grizzly Peak Engineering, Inc.
I have been a user of the Mentor FPGA synthesis tools since the
original AutoLogic platform in the early 90's. I have always felt that
Mentor had superior technology. I have owned Leonardo (4 years) and
Precision for quite some time. I was chosen as a Precision beta tester.
I have used the tool for most of my FPGA synthesis. The only place I
haven't used it was for a client that wanted everything to run with
Xilinx's WebPack. The design operating frequency was 8 MHz and the
part was less then 50% full.
I am currently using it on a VirtexII design running at 36 MHz. The
speed doesn't sound impressive but this design is challenging in the
number of cascaded comparitor -- many levels of logic. I have not had
an issue with Precision on this design. I have used Leonardo on PCI bus
designs running in Xilinx Spartan devices. In Altera designs running
at 66 MHz with APEX20 parts and various other FPGA designs.
Within Leonardo and Precision, I like the ability to control what the
synthesis tool produces. Some users would complain the tool should do
this right out of the box. Many of these complaints were directly
answered by the release of Precision. Precision has become as "Easy to
Use" as Synplicity, but retained that very important back door control.
I like the ability to script the flow very directly in TCL, use SDC
constraints, and control the flow and generation of supporting files.
As a power user of Design Compiler the ability to script directly feels
very comfortable to me.
Precision added a real FPGA Timing Analysis Tool which is as capable as
PrimeTime. I find this tool much more intuitive to use than the
foundry provided timing tools. With the ability of Precision to
support SDC format I can perform what-if with multiple FPGA families
and find the best part for the product. I can write my timing in SDC,
have Precision dump out the foundry format for P&R, then read in the
resulting netlist + SDF and perform the timing analysis. Very ASIC
like. :-)
I use Synplicity at many client sites and I find the tool capable. I
haven't done side by side comparisons of the tools (for years) so I
cannot comment on the performance of either. I do find the scripting
ability with Precision more intuitive than that in Synplicity.
Finally, Mentor has come out with Precision Physical Synthesis which
works well with high end Xilinx parts. This tool uses post placement
data and timing to make suggestions to P&R tools as to how to optimize
the design. This tool has found a place at several of my client sites
right next to Synplicity. I believe Mentor has a winning product in
Precision Physical Synthesis. They are addressing the problem as an
optimization issue not as a floorplanning issue. Although
floorplanning is critical to the tools functionality it is used more as
a post processor than a front end tool, like Amplify. I have found
that engineers will spend weeks trying to optimize (specify and
constrain) a path that Precision Physical takes care of out of the box.
It is a product that I feel has found a niche.
I believe that Mentor has a solid product with the best (on-shore)
customer support of any EDA vendor.
- Thomas Tessier of t2design
We are currently using Mentor's Leonardo Spectrum Level 3 synthesizer
and we plan to use Precision soon. We recently encountered a few
problems in the synthesis netlist generated by the tools (not the
same behavior of the design before and after synthesis). These bugs
were fixed rapidly in new releases and Mentor gave us workarounds for
previous versions of the tools.
We also found some problems following an upgrade of the operating
system -- for design reuse, the initial version of the synthesizer
can't be used anymore with the new operating system.
Nevertheless, all designs developed at Thales Optronics have been
synthesized with Leonardo Spectrum (essentially Xilinx FPGA & CPLDs).
Globally, we could say that the tool meets our need and users are
satisfied.
- Frederique Muselli Martin of Thales Optronics
I have used Mentor for FPGA synthesis even before the Leonardo days.
I am currently using Precision Synthesis 2004b.67. There have
been several areas where this new version did a much better job than
2004a. The biggest improvement is in the efficiencies in utilizing
Xilinx features. For example, this version with the new front end
enabled utilization of all features of the Xilinx FDRSE flops, making
optimal use of synchronous sets, resets and enables for Xlinx
flops. Since the previous versions did not infer these flip flops,
the new results are both smaller and faster.
There is still an issue with Precision synthesis in that it doesn't
look at preserve_signal or preserve_driver attributes until after pre-
optimization (resource sharing), so you sometimes must go to extreme
lengths to force it to create a particular structure. It would also be
very useful to have resource sharing controlled on a module rather than
a global basis.
I have been a beta user and have also pushed previous release versions
of Precision and issued a number of bug reports. In general, 2004b.67
seems to be much more stable. Additionally, I have several projects
where the design performance that Precision produces for the Xilinx
Virtex II / II Pro families is improved over previous releases.
- Thomas Krause of Millogic
Mentor's Precision 2004b.62 is easy to use right away compared with
Leonardo. I have personally had some good area and timing results
with Precision. It had a 10% improvement in area and speed versus
Leonardo, which is a very decent improvement.
With Leonardo, you were on your own. For example, with memory
controllers, Leonardo was fast, but I didn't know what the timing would
be because it didn't handle intra-clock timing, and required more
manual intervention. E.g. if you have a clock, then another clock
shifted by 90 degrees, Leonardo doesn't take it into account. Precision,
however, will solve the clock skews over different domains. It will
also handle internal DCMs (digital clock modules) automatically; this
is a huge improvement.
My main issue with Precision was that it was sometimes unstable and
crashed; this is better with 2004b. Also, Precision 2004b's new front
end is more powerful than in the past. In prior versions of Precision,
if you used generics, when you had module names, Precision would save
'module name_generic'. Because the name was so long, it couldn't do
timing optimization. This is fixed in the new front end because Mentor
uses a different database structure. Also the new front end uses a
better synthesis algorithm and as such should yield better results
I used a lot of constraints, for example, time divided by time, and
Precision couldn't synthesize this. Mentor says they will address in
2005a, as the front end will use different minimization algorithms. For
the moment I cannot use the new front end for most of my designs
because I use constant calculation declarations and the new front end
has a bug stating that it cannot synthesize time. Mentor says that
this issue has been addressed in 2005a.
- Wim De Sutter of Barco
Mentor's Precision RTL now provides good results for frequency and
area. One positive new feature is the Timing Constraint editor.
Precision does a very good job of translating vendor constraint files
from the previous timing constraints. Our designers had no problem
swapping from Leonardo Spectrum to Precision RTL.
Unfortunately old XILINX families like 3000, 4000 SPARTAN, are not
supported by Precision and so we must continue to preserve our Leonardo
Spectrum licenses. This will become a real problem when we upgrade old
devices. We are also still expecting Mentor to add new incremental
design features to Precision.
- Alain Giraudat of Thales Systemes Aeroportes SA
My team and I are regular users of Mentor's Leonardo. The key
functionality of this tool, besides its good ability to synthesize
designs, is its ability to run in batch mode. Once a script has been
designed and is fully functional, I can run synthesis just with a click.
This is particularly useful when we have to solve timing issues in my
team: we change the Verilog/VHDL input, and run a full compilation
(synthesis + place/route) on a separate workstation, just with a click.
We look at the result half an hour later.
The strengths of Leonardo, besides batch mode:
- easy to understand results: the log is clear, and gives comprehensive
warnings.
- the tool runs fast, and its results are good.
- GUI is nice, and navigating through a synthesized design is easy.
Leonardo weaknesses now:
- the tool is almost obsolete : no new functionalities are
developed, they just add new devices. In particular, no support
of Verilog 2001.
- no support of multi-clock designs: with this kind of designs, you
have to specify the fastest clock for ALL the design, which is
not optimal. You can bypass this problem by creating groups
within your design, but it requires additional work.
- preventing optimization of specific parts within the design is
not really easy, and requires additional work.
We conducted an evaluation of Synplicity last year, and its results
were far better than Leonardo, both in area and frequency. This
is pretty normal as the equivalent tool from Mentor is Precision.
We only found that the log result of Synplicity is not as easily
understandable as Leonardo's log. We will have to conduct a
comparision of Precision and Synplicity this year.
- Florian Jutisz of Motorola
The positives about Mentor's Precision: Their methodology on how to
constrain the design for timing. Also I think it's great that you can
add automatic and manual physical optimization after place and route.
What I hate about Precision Synthesis? It's the Mentor way of project
handling that they force you to do. In the first releases of Precision
Synthesis, all was fine and you didn't have to worry about opening,
copying, saving... a project. Even clean-up is now a chore. Not to
mention the bad logic it may produce from time to time. It is better
do a post-synthesis regression.
I am always in a hurry and I don't have the time to explore exactly
what is not working. However when targeting Altera devices, Precision
synthesis still seems to have its own mind. Of course it got better
over the last year, but for Altera targeted designs I would still
prefer Leonardo over Precision. It's just proven to be good.
Give Mentor another year of fixing and fine-tuning, and Precision will
become a nice tool. For Xilinx as I mentioned it's already in a pretty
good state, but for Altera there are more issues.
- [ An Anon Engineer ]
We have been using Leonardo-Spectrum FPGA synthesis tool for 8 years
and have designed more than 400 FPGAs with it ranging from small
capacity (1K Lut) to high capacity (50K Lut). Our various applications
developed are in the radio and networking domain using target
technology Altera and Xilinx for the main parts.
For all these years we have enjoyed Leo's QoR (area, frequency,
robustness, accuracy), ease of use, and particularly the high level
VHDL support for ROM, RAM, dual port RAM and Mac recognition, enabling
us to have a complete technology independent VHDL project.
Now we have to cope with more challenging FPGA new technologies such as
Virtex-4 and Stratix II. After a comprehensive set of studies we plan
to use Precision-RTL.
- Christian Bara of Thales Communication
I am an ASIC designer for automotive. We use FPGAs for prototyping,
and have Mentor's Precision 2004c.23.
Precision's advantage is that physical tuning of a critical path can
be performed by hand, and delay analysis is done in real time. A
fault with the tool is that there is no collaboration with debugging
environment.
Precision has gated-clock support, and I would like Mentor to also add
gated-clock support with a latch. Mentor Precision supports a number
of devices of physical synthesis, including Spartan2, FLEX10KE. We
would also like Mentor to add a function to connect an internal signal
outside for debug.
- Takahito Miura of Densotechno Co.
Mentor Graphics is now focusing development efforts on Precision.
So I didn't see new developments in the last releases of Leonardo.
However they still regularly provide new releases with library updates
and bug fixes. Leonardo is now a mature product that fulfills our
requirements and we don't plan to switch to Precision unless we get an
incentive offer (which at the time is not the case).
We don't have designs of large complexity and I believe that a good
starting point is to select the right technology (FPGA vendor/device
family and size). Even with the best tools, if you choose a technology
that does not fit your project needs, you'll go straight into the wall.
Leonardo tool flow is pretty simple, easy to use, and produces
reasonably good results for the designs we've made recently.
One feature that I particularly appreciate with Leonardo is the
operator/macro inference that worked quite well with the device family
we used.
My last two comments are not specific to Leonardo and I guess they
could apply to most synthesis tools, if not all. First, EDA vendors
often give recommendations on coding style to achieve the best results
and we can find a kind of "The Art of VHDL Synthesis" chapter in the
reference manual. My idea of art is rather at the opposite of what I
expect from a hardware description language and a synthesis tool. So I
would like to have a tool that is more independent on the coding style.
Secondly, I still think there's a big gap with the P&R tool. A tighter
link would help reduce the iteration loop and process the synthesis
operation with more accurate timing data."
- Stephane Debieux of Actis Computer
I like Mentor's Precision tools because the synthesis time is very
short, the result is very consistent, and it is easy to use the RTL and
Technology view.
Its weakness is that if I try to synthesize a relatively large design,
like Virtex-2-3000 for example, it takes a while to bring that
design up and to save it. It sometimes takes several minutes and locks
up my PC during that time. Synplicity does not have this problem.
I have not used the production version of Precision 2004c yet. I still
use 2003c version for the current project, as we don't want to change
the version in the middle of the project. I did use the beta version
of 2004c for a small Spartan-2 design only. I enabled and disabled the
front-end feature, but for that small design I did not see significant
difference.
- [ An Anon Engineer ]
We are primarily looking to use Mentor's Precision as an alternative
to our current synthesis tool, Synplicity Synplify. With only one
synthesis tool there is always the danger that we will hit a problem
with it which will halt development. If we have the option of two
different synthesis tools then it is unlikely that the same bug will
exist in both. The first levels of functionality we therefore look for
are that all our current code which works with Synplify also works with
Precision, and that the runtime, area and quality of results are at
least no worse with Precision when compared to Synplify, and that all
the same vendor parts are supported. Achieving this level of
functionality would get us to buy a copy of Precision (we're still only
evaluating it at the moment).
Beyond that any improvements in runtime, area and quality of results
over Synplify make Precision more and more compelling and would make us
consider it as out primary synthesis tool. Of these three runtime is
the least important, quality of results the most important.
For us, Precision's biggest strength is that when it works it is at
least as good as Synplify, and in some cases better, particularly in
terms of area. One really nice feature for us is that you can use
scripts to control Precision. Our equivalent node locked version of
Synplify only runs in the GUI which is a major pain for us (although
we can work around it).
Precision's biggest weakness is that the software is still buggy. One
of our designs crashed using the latest 2004c release. None of our
designs we've tried so far work using the new 2004 front end. Mentor
is working on fixing these but getting fixes seems to take a long time
(evidenced by the fact that our evaluation has been going on for nearly
a year now). On several occasions Synplicity has given us patched code
with fixes in a couple of days after identifying a problem, with Mentor
the turn around time is measured in weeks or more typically months.
With previous versions the area was 50% bigger with Precision compared
to Synplify. With 2004b/c the area is typically 5% smaller compared to
Synplify which is excellent. Going from 2004b to 2004c reduced run
times from 7.5 hours to 1.5 hours (Synplify takes 1.5 hours). I guess
that was a bug in 2004b rather than anything else.
- [ An Anon Engineer ]
Mentor Precision Strengths:
1. It supports different implementations, or versions of a project.
2. It remembers where I leave off.
3. Nice GUI. It allows me to specify constraints for instances, nets,
IOs and more...
4. The quality of results. It is consistent and some how better than
Leonardo. I can't explain the latter part, but I do feel confident
with Precision.
5. The wheel on my mouse works. That is very nice.
Precision's Weakness: None so far.
- TC Wang of Adtran
Throughout the past year I have been working with Precision Synthesis
tools. I've made use of several versions, the latest being 2004a68,
2004a75, and 2004b47.
In my opinion Precision's major strength lies in its ease of use. The
user interface is very intuitive which enables us to obtain results
quite fast. This applies to not only the gate level netlist generation
itself but also interoperability with P&R tools, namely ISE. It
becomes relatively easy to carry a design through the whole design
flow from the Precision GUI.
On the downside, this ease of use comes at a cost. There aren't many
options to control the synthesis process in Precision. By comparison,
Leonardo Spectrum allows setting a vast array of internal variables,
along with providing a full description for every single one of them.
If such options/information exists in Precision, they are not
available for users.
So it becomes unavoidable to think how much this is related to the
better results that I obtained performance-wise with Leonardo. For
instance, Leonardo allowed for control of the optimization effort while
Precision does not. As far as run times go, I didn't keep an exact
track but my overall impression is that I get faster synthesis when
using Leonardo, if only marginally.
And while it is indeed true that Precision theoretically supports a
large number of devices, I encountered several timing problems while
using Virtex-2Pro -- a service request is ongoing. These are due do
estimation issues while using this particular target technology, and
also due to incomplete/inaccurate delay tables. This is a severe
problem since it not only limits results from P&R but renders other
tools like Precision Physical useless.
- Lino Pinchete of Siemens
We use Mentor's Precision Synthesis 2004.B. Our design size is
sufficiently small that area is not a factor for us, nor is runtime.
However, quality of results is important to us -- and a big change
that I notice with 2004B is that Mentor has improved the QoR.
In the earlier version, if we ran the same design on a different
machine, we might get different results. But Mentor fixed this in
Precision 2004.68, e.g. our results are in EDIF, and when we send it
to a customer, they now get the same results.
Precision biggest strength is its schematics, which help me a lot in
the functional debug. They are better than Synplicity or Xilinx XXC.
It allows me to solve some design problems by doing signal trace
back, which is very efficient.
Precision's biggest weakness is their timing analysis. In principal,
I believe that this is true for any commercial synthesis tool, but I
haven't actually used the others to comment for sure. Their timing
results are worse than a 10-15% difference from a real timing report.
We resolve this by using the Xilinx timing analysis after P&R.
In general, I am satisfied with using Precision. The set-up was very
easy -- we never had problems with it.
- [ An Anon Engineer ]
We still use Leonardo Level 3. Not much longer though, it pretty
much stinks.
- [ An Anon Engineer ]
We have switched from Exemplar to Precision RTL Synthesis.
Generally it works good now.
- [ An Anon Engineer ]
Index
Next->Item
|
|
