( ESNUG 314 Item 1 ) ---------------------------------------------- [3/17/99]
From: [ The Horse With No Name ]
Subject: One User's Critique Of The CoreBuilder & CoreConsultant Tools
John,
Please keep me very anonymous in this post. Very anonymous.
I've just spent the a couple of days working with Synopsys' CoreBuilder and
CoreConsultant tools. I've seen the presentation a few times now, so was
looking forward to trying them out. As part of my job I have to deliver
IP to customers, so it's important to me how the IP is delivered. The
easier I can make it for them, the less time I spend on the phone sorting
out tedious problems.
What did I think of it?
Well, it's cool. I liked it. Not something I often say after the first
use of an EDA tool.
So, what happened? I was given an alpha version of CoreBuilder and beta
version of CoreConsultant, and 5 days worth of training course slides to
explain what I should be doing with it. That suits me fine - I'd much
prefer to be given something to play with, rather than sit and learn all
about it before being allowed to play with it! They basically work like:
IP Maker IP Buyer
---------- ----------------
(e.g. MIPS ) (e.g. Hewlett-Packard)
CoreBuilder --> CoreKit files --> CoreConsultant
captures IP into (encrypted in converts CoreKit files
CoreKit files .kb format) into gates
I jumped in at the deep end and decided to use the CoreBuilder (The IP
developer tool) to package up a block that I'd worked on in a recent project.
I fired it up, which incidentally looks just like the CoreConsultant tool,
dove into the first of the configuration stages -- blam!, the tool crashes!
Damn. Which brought me neatly to my first conclusion: it sure is an Alpha
version of the tool. But then, it was described as Alpha.
It turns out that it was a minor problem mapping working directories onto
physical directories. Once I stopped trying to be clever it worked fine.
Onto the second step: including the RTL blocks that make up our design.
My first pass complaint about some of the stages of CoreBuilder was precisely
that it is a graphical tool. Going through entering all of the RTL blocks
was dull. Most days I'd trade Emacs for almost any GUI for repetitive data
entry. However having done this the hard way the first time round, I've now
figured out how to make a lot of it easier on most of these stages by
importing things from files. (OK, OK, I should have read the documentation
and spotted that there's a Tcl command line interface.)
It's in the next set of stages that things get clever. By including pragmas
in your design you can put configuration options into your CoreBuilder RTL,
and have them appear as dialogue boxes in the CoreConsultant tool.
CoreBuilder reads the pragmas and presents you with a little spreadsheet
to adapt these as required for CoreConsultant. You can chose between check
boxes, radio buttons, and parameters with allowable ranges. It's good stuff.
Setting up something reasonably complex with all the different types of
options was pretty simple.
In subsequent stages more of the design intent is captured. Identifying the
clocks, identifying any asynchronous reset signals -- all the usual stuff
that you'd have to do writing the DC synthesis scripts -- except I didn't
have to write a single line of script -- anywhere. By specifying a few
attributes about the design while in CoreBuilder (e.g. does it have muxes?
does it have arithmetic stuff?) CoreConsultant then later automatically
drives Design Compiler to get good results. After that, you then capture
the I/O set-up and hold times. The tools are (as far as I can see) very
much configured for top-down constraints -- not that that's a bad thing.
Parameters can be either specified as absolute times, or my preferred way,
as a percentage of the cycle time.
The later stages of the CoreBuilder process are all about determining what
should go into the design kit, if you need help URLs and putting together
the whole kit, but I'll skate over that to get onto the other side of the
tool, CoreConsultant. At the end of the CoreBuilder checklist you have
yourself a 'knowledge base' (Synopsys-speak for all of these things you've
entered captured into their strange encrypted CoreKit file format.)
Now the moment of truth -- it's all very well capturing this information,
what can you do with it? The CoreConsultant tools runs like an automated
unzip process, unpacking the design and then dropping into a checklist of
stages that the IP buyer has to go through to be able to synthesize the IP.
Here's what the checklist looks like:
Specify Target Technology X
Specify Configuration X
Specify Context Information X
Specify Design Intent X
Specify Port Intent X
Verify Budgets X
Specify Synthesis Strategy O
Synthesize O
Analyze Results O
[ Express Lane ]
[ OK ] [ HELP ]
All of the things that you'd have had to edit the scripts to change you're
led through by the tool. Target Technology == selecting libraries, wiring
load models, operating conditions. One of the good things about
CoreConsultant is that it is sensible about doing this. Having selected the
library, it doesn't give you a blank choice of models, but a pull down list
of the available options. It's not rocket science, but it's a good
practical way of avoiding those silly mistakes that cause scripts to crash
just after you turn your back on them. Configuration == the implementation
specific parameters. (e.g. "RAM size: 64 kbyte or 128 kbyte?") There's
parameter checking and it disables parameters when appropriate. Once you're
done with the configuration, CoreConsultant generates your specific RTL,
testbenches for the RTL, and documentation. Context == clock and reset
signals in your chip. Design Intent == block by block info for synthesis.
(e.g. synth for speed on block X and for area on blocks Y & Z.) Port
Intent == top level I/O constraints. Verify Budgets == makes sure everything
is constrained for synthesis and these constraints make sense. The rest
of the checklist (Specify Synthesis Strategy, Synthesize, Analyze Results)
is mostly just fancy, multi-choice GUIs driving Design Compiler.
Personally I don't get a kick out of writing or hacking Synopsys DC scripts
(sorry, John) so I like the CoreBuilder/CoreConsultant combination because
it lets me get on with the business of designing interesting things, in a
style which will synthesize well.
All in all, despite being an Alpha/Beta release of the tool -- and it sure
shows in some places -- I'm impressed. A lot of thought appears to have
gone into the tool to make sure that you're lead through the process that
you'd have to go through anyway, but with less opportunity to get things
wrong. If you want to go the whole hog and have help files and the works,
then that's fine, too -- there are options for help URLs in all kinds of
places. As someone who does have to hand off IP to other people (and has
learned the hard way that, if someone can get it wrong, someone will), I
think I'd much prefer to deliver IP packaged this way.
It's good stuff. I think IP buyers will look forward to the end of grubbing
round in someone else's RTL and scripts, trying to figure out where they've
hidden that last parameter.
- [ The Horse With No Name ]
|
|
