 |
 |
 |
 |
 |
 |
 |
 |
 |
|
|
|
|
|
|
|
|
|
This document describes how SPEF parasitic information maps to OpenAccess. OpenAccess includes standard implementations for translating SPEF information to and from an OpenAccess database. This document contains mapping information about the following SPEF constructs:
spef2oa is the translator for creating an OpenAccess database from a SPEF file. For information about using the translator, see SPEF to OpenAccess Translator (spef2oa). oa2spef is the translator for creating a SPEF file from an OpenAccess database. For information about using this translator, see OpenAccess to SPEF Translator (oa2spef).
According to the SPEF standard, the parasitic values for resistance, capacitance, inductance, and delay can be specified as single float values or as triplet float values (float : float : float). In OpenAccess, parasitic values are associated with analysis points. A single float value is associated with a single analysis point. Three analysis points are required to represent triplet float values. The three analysis points are min, typ, and max.
Both the spef2oa and oa2spef translators include command line options for handling single and triple analysis points. spef2oa adds the parasitic values to an OpenAccess database as follows:
oa2spef extracts parasitic values from an OpenAccess database as follows:
A SPEF file includes a HEADER section, which is composed of a number of subsections. The HEADER subsections are:
The information related to the HEADER section and its subsections is not stored in the OpenAccess database. However, spef2oa uses the unit values and the values for *DIVIDER, *DELIMITER, and *BUS_DELIMITER during a translation.
When extracting the parasitic values to a SPEF file, the oa2spef translator uses default values for these constructs, but you can specify other values by using command line options.
The SPEF standard specifies time, resistance, capacitance, and inductance units. The units used in OpenAccess are MKS units. For each parameter, the following table lists the base unit, the SPEF unit construct, the oa2spef unit options, and the default oa2spef units if units are not specified on the command line. oa2spef adjusts parasitic values based upon the units specified on the command line.
| Parameter | Base Unit | SPEF Unit Construct | oa2spef Options | Default Unit |
|---|---|---|---|---|
| time | second | *T_UNIT | PS for picosecond NS for nanosecond |
PS |
| resistance | Ohm | *R_UNIT | OHM or KOHM for kilOhm |
OHM |
| capacitance | Farad | *C_UNIT | PF for picoFarad FF for femtoFarad |
PF |
| inductance | Henry | *L_UNIT | HENRY MH for milliHenry UH for microHenry |
HENRY |
NAME_MAP is an optional SPEF file section. Its purpose is to reduce file size by mapping an index to a name that is frequently used in a SPEF file.
spef2oa implements an index-to-name map table that represents the name map section in a SPEF file. An index and an associated name are entered into the table while reading the entries in the NAME_MAP section. A unique index is assigned to each net (plus its instances and terminals) that has parasitic information. Instead of storing the name of a net, term, or instance, the index associated with the object is stored.
By default, oa2spef does not write a name map unless the –nameMap option is used. When the –nameMap option is used, oa2spef maps all nets that have parasitic data. In addition to the net name, all instance, terminal, and all instance terminal names that are associated with the mapped net are also mapped. Power and ground nets are always mapped when the –nameMap option is used, whether or not they contain parasitic data. However, instances, terminals, and instance terminals connected exclusively to the power and ground nets, are never mapped.
The SPEF constructs for power and ground nets are:
*POWER_NETS net_name { net_name }
.
.
.
*GROUND_NETS net_name { net_name }
.
.
.
In OpenAccess, the type of net (whether power or ground) is obtained by using the oaNet::getType() method. The following table maps the SPEF power and ground constructs to their corresponding objects in OpenAccess.
Type of Net in SPEF |
oaType |
POWER_NET |
oacPowerSigType |
GROUND_NET |
oacGroundSigType |
Dependent on the type of net, oa2spef adds it in the *POWER_NETS section or in the *GROUND_NETS section. The index from the name map table is used instead of the net name if an index is stored as an extension to a net.
spef2oa ignores the *POWER_NETS and *GROUND_NETS designations, but it doesn't ignore the parasitic data. Parasitic data is always associated with signal nets.
The PORTS section of the SPEF file lists the terminals in a block along with their direction and connection attributes. The construct for the PORTS section is:
*PORTS port_entry { port_entry }
port_entry ::= port_name direction { conn_attr }
port_name is replaced by the name of the term. If an index to the name exists in the name map table as an extension to the oaTerm object, oa2spef uses the index for the port_name.
The direction of an oaTerm is determined by its oaTermType. The oacInputTermType maps to a SPEF input port represented by the I direction indicator, oacOutputTermType maps to an output port represented by the O direction indicator, and oacInputOutputTermType maps to a SPEF bidirectional port represented by a B direction indicator.
Note: oa2spef does not write the <conn_attr> section for PORTS. However, you can inherit the related class in a custom implementation to include this data.
spef2oa ignores the PORTS section of the SPEF file.
The SPEF D_NET section describes the detailed parasitic information for a particular net. The construct for this section is:
*D_NET net_ref total_cap [ routing_conf ] [ conn_sec ] [ res_sec ] [ induc_sec ] *END
*CONN conn_def { conn_def } { internal_node_coord }
conn_def ::= [ *P port_name direction { conn_attr } | *I pin_name direction { conn_attr }]
The *P section lists the terms that are present on a net. spef2oa ignores this section. oa2spef maps the port_name or the index to the term name if the index is stored as an extension on the oaTerm object. The direction is determined according to the oaTermType of oaTerm. Refer to the *PORTS section for mapping between direction and oaTermType.
*CAP cap_elem { cap_elem }
cap_elem ::= [cap_id node_name par_value | cap_id node_name node_name2 par_value ]
cap_elem maps to the oaCouplingCap object in OpenAccess. cap_id is an id used while creating the oaCouplingCap object.
node_name (or node_name2) ::= [<net_name><pin_delimiter><oaNode id> |
[ oaTerm name | <index>] |
[ <instance_name><pin_delimiter><term_name> ]*
]
* Only if a capacitor is connected to an instTerm.
The par_value is the capacitance value for a given analysis point or for the triple analysis points if provided. spef2oa creates the "From" and "To" nodes to represent node_name and node_name2. If node_name2 is absent, oaGroundedNode is created. The oaCouplingCap is created with a given cap_id. The appropriate oaCouplingCap::create() method is used if a capacitor is connected to an instTerm or node in a different parasitic network.oa2spef suppresses grounded capacitors that have values of 0.0. If there are multiple values on a capacitor (from multiple analysis points), the capacitor is suppressed only if all the values are 0.0.
A node id is obtained from oaNode.
*RES res_elem { res_elem }
res_elem ::= res_id node_name node_name par_value
The res_elem maps to the oaResistor object in OpenAccess, and the res_id maps to the id that is used while creating the oaResistor object. Refer to cap_sec for mapping of the node_name. The par_value is the resistance value for a given analysis point or for multiple points.
*INDUC induc_elem { induc_element }
induc_element ::= induc_id node_name node_name par_value
The R_NET section describes the reduced parasitic information for a particular net.
Issues:
The construct for R_NET is:
*R_NET net_ref total_cap [ routing_conf ] { driver_reduc } *END
Note: spef2oa ignores the *R_NET section if there is no "driver_reduc" section, and oa2spef does not write reduced parasitic information for a net that does not have a driver.
driver_reduc ::= driver_pair driver_cell pie_model load_descThis section maps to the following reduced parasitic models that can be stored for each driver of a net.
driver_pair ::= *DRIVER pin_namespef2oa finds the instTerm associated with the given pin_name, and the reduced parasitic models are created using this instTerm.
driver_cell ::= *CELL < cell_name >
pie_model ::= *C2_R1_C1 par_value par_value par_valuespef2oa does the following:
load_desc ::= *LOADS rc_desc { rc_desc}
The SPEF construct for LOADS is:
*LOADS rc_desc { rc_desc }
rc_desc ::= *RC pin_name par_value { pole_residue_desc }
pole_residue_desc ::= *Q number_of_poles pole { pole } \
*K number_of_residues residue { residue }
pin_name maps to the oaDesignObject, which is one of the receivers for the driver, and par_value maps to the delay value. An oaElmore object stores the delay value associated with this receiver object. Each receiver's oaElmore object is associated with the reduced model (oaLumpedElmore or oaPiElmore) for this driver. If a pole_residue_desc is included, it is represented by an oaPoleResidue object in OpenAccess, which in turn, is associated with an oaPiPoleResidue model.
spef2oa creates oaElmore objects for each *RC section for the appropriate model if pole_residue_desc is not present. If pole_residue_desc is present, spef2oa creates the oaPoleResidue object to represent poles and residues.
oa2spef gets the oaElmore objects from oaPiElmore or oaLumpedElmore models for writing pin_name and par_value in the *RC section.
Copyright © 2004-2010 Cadence Design Systems, Inc.
All rights reserved.