( ESNUG 308 Item 2 ) ---------------------------------------------- [1/20/99]
Subject: (ESNUG 307 #11) Can I Put Text In DBs Made By Library Compiler ?
> Has anybody discovered a way to compile text strings into a db library
> with Library Compiler? We have groups within Ford who we make custom
> db libs for. We have engineers run off with a db lib, make a chip, and
> then they come back asking: "Did that db lib use the XYZ spice data?"
> or "Was the 1-2-3 bug fixed with that db lib we used?" I can't, nor
> can my db lib "customers", currently just use Design Compiler to look
> at the db to find text strings that I'd like to put into db libs that
> contain comments / text strings about revs, date created, bugs fixed,
> spice assumptions, etc. I suppose you could create some kind of phoney
> model with ascii encoded "delays", but I'd like to know if there's a
> better way to do this.
>
> - Rodney Ramsay
> Ford Microelectronics
From: dchapman@goldmountain.com (Dave Chapman)
John,
An ugly but effective way to do this is to define a ROM which contains the
string data you want, and then have the user instantiate the ROM when they
want to read the ID string.
The problems with this speak for themselves, but it will do the job.
Obviously, you do not instantiate the ROM for the final tape-out.
I hope somebody out there has a better suggestion.
- Dave Chapman
Goldmountain
---- ---- ---- ---- ---- ---- ----
From: Bob Cook <RJCook@ieee.org>
John,
In the Synopsys-format library source code:
define (my_attribute, library, string) ;
my_attribute : "Hey, I can set my own library string attribute."
Then, in Design Compiler:
dc_shell> get_attribute find(library, TECHLIB) my_attribute
Performing get_attribute on library 'TECHLIB'.
{"Hey, I can set my own library string attribute."}
Defined attributes can be of type string, integer, or float. And they
can be assigned to a library, cell, pin, etc.
- Bob Cook
R.J. Cook Associates, Inc.
---- ---- ---- ---- ---- ---- ----
From: Helmut Reinig <helmut.reinig@hl.siemens.de>
John,
Yes, you can do such a thing by adding user-defined attributes to your
library. They can be retrieved by get_attribute in Design Compiler. The
library source code looks like this:
library (<your library>) {
...
define (<attribute_name>, library, string);
<attribute_name> : "<attribute_value>";
...
}
Hope this helps.
- Helmut Reinig
Siemens Semiconductors Munich, Germany
---- ---- ---- ---- ---- ---- ----
From: Jean-Marc Calvez <jean-marc.calvez@st.com>
John,
There are always the "version" and "comment" library attributes; they will
show up in a report_lib. I don't know how much info you can put in comment
but I remember using a string over 1KB long once in a .lib file.
- Jean-Marc Calvez
STMicroelectronics Grenoble, France
---- ---- ---- ---- ---- ---- ----
From: cjy@aluxs.micro.lucent.com (Chris Younger)
John,
User defined attributes are very easy to add to .lib source. First define
the attribute in the library header:
define ("attribute_name", "group_name","attribute_type");
where attribute_name = name of attribute
group_name = name of group in which attribute is used (pin,
cell, etc)
attribute_type = string, integer or float
For example, for version strings added to each cell in the library:
library("FOO") {
...
define ("xyz_co_ver","cell","string")
...
cell("MY_CELL") {
xyz_co_ver : "created 12/17/98: spice=v3.1: gds=v5.0: translator=v1.0"
...
}}
To extract the info from the db use get_attribute:
get_attribute FOO/MY_CELL xyz_co_ver
Hope this helps.
- Chris Younger
Lucent Technologies
---- ---- ---- ---- ---- ---- ----
From: [ Synopsys R&D ]
Hi, John,
I'm in Synopsys R&D, and in my past I worked quite a bit on Library Compiler.
There is an easy way to do what you're asking, using user-defined attributes.
Actually there are two ways, depending on whether you want to annotate the
source '.lib' or if you want to annotate the db after it has been processed
by read_lib.
1) You can create your own attributes in a '.lib' file using the
"define" construct, at the library-level of your description.
For example,
library (demo) {
define( new_attr, library, string );
...
defines a new user-defined attribute named 'new_attr'. If you
want to supply a value for it, you could follow its definition
with the line
new_attr : "whatever string you want";
To find out the values of your user-defined attributes once the
library has been compiled, you use the 'get_attribute' command:
get_attribute find(library demo) "new_attr" -quiet
{"whatever string you want"}
The 'define' construct is quite flexible. It can create attributes
of type 'string', 'float', or 'integer'. It can create such
attributes on all the primary object types in your library (library,
cell, pin, ...). You cannot redefine an existing attribute, that's
about the only limitation (probably a good one).
This should be documented in the LC manual.
2) If you want to tag a library AFTER it has been compiled via read_lib,
you just use the 'set_attribute' command:
set_attribute find(library demo) "newer_attr" "some value" -type string
John, if you post this please keep my name anonymous.
- [ Synopsys R&D ]
|
|
